orkai

Your process, as people

Your virtual employees. Already briefed.

Define roles once per project. Load one in chat, or assign one to a task — orkai work runs the same playbook in the background.

Same workflows · two ways to run them

workflow

Owns the requirement, not the code

The non-technical seat: capture what users need, acceptance criteria, and priority — without drowning in implementation detail.

Downstream roles inherit a clear brief. You stop re-explaining “what we’re building” in every chat.

user outcomesacceptance criteriapriority

workflow

Shapes the technical side of the requirement

Turns the Product Owner brief into architecture decisions, standards, and constraints the builders must follow.

Boundaries, patterns, and “how we build here” live in orkai — so implementers don’t invent a new stack every session.

architecturestandardsconstraints

workflow

Breaks work down and assigns the right roles

Reads the brief and architecture, then persists plan › milestone › tasks — and assigns Frontend, Backend, or other roles where each task belongs.

The tree is the contract. Builders pick up concrete jobs; you don’t re-scope mid-chat.

plan treerole assignmentmilestones

workflow

Your UI stack, already in muscle memory

Component patterns, routing, lint, and build gates are part of the playbook — not something you paste every morning.

Picks up tasks the Feature Planner assigned. Ships in the shape your repo already expects.

componentsroutinglint + build

workflow

Backend conventions — without repeating yourself

APIs, operations, tests, and the gates you care about are already in the graph for this role.

Same playbook powers interactive sessions and async work tasks the planner assigned.

APIs / opstest patternbuild gates

runs workflows

Work with them in chat

Start a session, load a workflow, and the agent walks the steps you already defined — with project context attached.

Product Owner owns the brief. Architect owns the shape. Feature Planner owns the tree. Builders execute. You don’t re-teach the role.

runs workflows

Assign them to tasks

Attach a workflow_id to a task. The work daemon picks it up, loads that playbook, and runs — tech-debt cleanup, small fixes, gated builds.

Without workflows, work has nothing to execute. They are the key that makes background agents possible.

Playbook · Product Owner

Playbook · Architect

Playbook · Feature Planner

Playbook · Frontend Developer

Playbook · Backend Developer

Example · interactive session

Load Feature Planner — turn the checkout redesign brief into a plan with the right roles on each task.

Loaded Feature Planner from orkai. Walking the playbook you configured:

I have the Product Owner acceptance criteria and Architect standards already in context — no re-brief.

Persisting plan › milestone › tasks, then assigning Frontend to the UI slice and Backend to the payment webhook.

Want the first milestone scoped to launch-critical only?

Example · async worker

orkai work · worker assigned

Clean stale deps in internal/index

Backend Developer workflow_id running

Sound familiar?

New chat. Blank slate.

Same question, two answers — a stranger, or a coworker who already knows your work.

Without orkai

New chat Context: none

Can you pick up the auth refactor we started yesterday?

I don't have earlier context for this project. Which repo, branch, and constraints should I use?

Please re-attach the architecture PDF if you want me to follow it.

With orkai

New chat Memory restored

Can you pick up the auth refactor we started yesterday?

Picking up where we left off — auth refactor from yesterday's session.

architecture-notes.mdTDD-first reviewsSession · yesterday

I have your architecture doc and TDD preference. Start with the middleware package?

How it works

Index. Work. Pick up where you left off.

One install on your machine — not a blank slate every morning.

code CSV docs

orkai index · typed entities

Index
Index your work

Code, docs, datasets, plans — typed on disk
session · today architecture.md preferences

agent saving context

Work
Work normally

Cursor · Claude Desktop · Claude Code over MCP
overview()

Last session ready

3 docs · 2 standards · 0 setup

Continue
Pick up where you left off

New chat opens with structured context already there

MCP · orkai index · plans per project

For Cursor and Claude Desktop on your machine — not a cloud memory API.

Gate every commit

Standards in orkai. Review on every push.

Point each process at the standards you already keep in orkai. Wire a git hook. When an agent ships a bad change, the run fails, the JSON report says why, and the same agent fixes it — before the branch moves on.

Standards
In orkai

Architecture · design system · backend rules you already saved

backend-standardsdesign-tokensfe-patterns
Configure
Project + machine

.orkai.yaml processes · ~/.orkai/config.yaml chat models

backend_reviewfrontend_reviewdesign_system
Git hook
Every commit / push

orkai review · exit non-zero stops the land

pre-commitpre-pushexit 1
Agent loop
Read report → fix

JSON on disk · same agent patches until green

.orkai/reportssuggestionre-run

Report · blocked commit

orkai review · backend_review fail

mode · diff strict · true knowledge_base · 2 standards .orkai/reports/

3 files 1 failed 1 high · 1 medium

fail backend/internal/services/pdf_service.go

high
New report DTOs live in the service package — standard requires one responsibility per package.

suggestion · move transport DTOs to the handler boundary
pass backend/internal/services/tool_service.go
pass backend/internal/services/system_prompt.go

exit 1 · pre-commit blocked

Same agent · closes the loop

standards · .orkai.yaml · ~/.orkai/config.yaml · git hook · .orkai/reports · docs/review

What you get

Persistence in every shape you already use

Pick a scenario — the kind of answer you only get when context has structure.

Example · pre-merge risk check

I'm making RefundHandler async before Friday — what breaks?

It's not just the handler — 14 callers still invoke Process and wait for refund_id in the response body. Indexing left a note on that function: it's synchronous on purpose today, mostly webhook and mobile paths.

The payments SDK also hard-codes a 2s timeout, which won't work once you enqueue. You'll need idempotency keys and a poll path — your saved API standard already calls that out.

The ops alerts in refund.yml are fine to update after deploy — they're metric names only. The risky part is the four SDK wrappers and the webhook retry loop, which assume a 200 with the ID in-body.

Callers would need to shift from blocking on the response to enqueue + poll:

id, err := handler.Process(ctx, req)
// becomes
job, err := handler.Enqueue(ctx, req)
status, err := client.PollUntilDone(ctx, job.ID)

I'd touch internal/webhook/retry.go and the mobile client first — they're the noisiest in prod when refunds stall.

Want a file-by-file checklist and the tests to run before Friday?

Example · what's actually blocking launch

What's blocking our v2 launch? I saved the roadmap in orkai — don't make me re-explain it.

I read your saved roadmap — 11 tasks still open across three milestones. Here's the honest split.

Blocked until billing is live: webhook signature verification and the refund + revocation runbook. Neither can be validated without real payment events.

Safe to start now: API contract tests, staging load test with alert thresholds, and a draft launch checklist. None of those need production cards.

Needs production + real payments: end-to-end purchase smoke and final go-live sign-off. Schedule those after redirects are wired.

One thing the plan wording glosses over: it says M5 blocks M6, which is true for billing policy, but you can still ship the site and wire redirects first — that unblocks a week of parallel work.

I'd tackle it in this order: contract tests → deploy + redirects → billing hardening in parallel → E2E checklist → go-live. Contract tests are the fastest win and they de-risk the SDK work you flagged last session.

Want me to mark contract tests in progress and draft the parallel track?

Example · find it in your own library

Where did we document the EU residency rule for subprocessors? Not in this chat.

I searched your indexed library — three docs mention EU subprocessors. You didn't need to re-upload anything; they're already on your machine from when you indexed them.

Your EU residency policy is the source of truth: customer PII stays in EU regions, and any metadata subprocessors need written approval before go-live. That's in the policy PDF you saved under policies/.

Nexus's SOC2 is where it gets interesting. Primary storage is in Dublin — that passes residency. But the subprocessor table lists US analytics for usage events, which is probably the gap you're feeling.

Your internal legal FAQ backs that up: when residency passes but a subprocessor sits outside the EU, route it to legal for an exception — don't assume the vendor is cleared.

So Nexus is conditional: fine on storage, not fine on analytics metadata without a legal call.

Want a one-page summary for legal with the exact passages cited?

Example · revenue split for the board deck

How is revenue split by region and product — what's growing fastest? Use the subscription export I indexed.

I pulled your subscription export and applied the churn_v3 filters you saved after the CFO call — enterprise trials under 14 days are excluded, logo churn uses paid seats only.

North America still leads at 32%, Europe is close behind at 29%, but Latin America is the fastest-growing region at 259% YoY. On products, AI Copilot is the standout — it went from $2.8K to $189K in a single year.

Total revenue $2.26M All regions · all products

Fastest region Latin America 259% YoY

Fastest product AI Copilot $2.8K → $189K

Revenue by region

North America

32%

Europe

29%

Asia Pacific

25%

Latin America

14%

Segment	Region	Revenue
SMB	North America	$228K
Enterprise	Europe	$196K
Startup	Asia Pacific	$142K

Security Suite remains the revenue leader overall; Workflow Auto is the one to watch on the downside — it dropped sharply in 2026. Collab Hub still has the highest margin if you need a profitability slide.

Want a PDF with the full ranked table and a delta footnote for the board deck?

Example · why you missed question 7

I indexed my midterm and lecture notes — why did I get Q7 wrong?

I compared your midterm scan against the lecture notes you indexed — here's what actually cost you points.

On question 7 (∫₀² x·e^(x²) dx) you set up the integrand but stopped before finishing substitution. Your work shows you recognized e^(x²) inside the integral — you just didn't complete the u-sub.

Your Week 5 notes say: when you see f′(x)·g(f(x)), let u = f(x). Here u = x², so du = 2x dx — you needed a ½ factor before integrating e^u. Prof. Chen's shortcut for this pattern is in Lecture 6, slide 14, which you also have indexed.

Same slip on Q11 and Q14 — all three are substitution, not integration-by-parts. That's roughly 18 points you can recover with targeted practice, not a full re-read of the unit.

I can generate five drill problems on substitution only, matched to the notation style you saved. Or a quick practice test if you want exam conditions.

Start with drills, or a timed practice test first?

Example · preferences + session context

Hi — picking up where we left off.

Morning — I loaded your last session and the structured context orkai keeps for you.

You set an explicit rule: one-line commit message, only after unit tests pass. I learned that you open with a risk pass before Friday releases and that we're on the auth middleware change from yesterday.

Nothing to re-explain — that's already in context before you ask anything.

Tests passed on the package. Ready to commit.

All green. Per your rule, here's the one-liner:

fix(auth): narrow middleware context key to session scope

Scope matches what we discussed yesterday — session-scoped key only, no global bleed. If you widen it, the commit message should say so.

Stage it, or adjust the scope first?

Local & private

Yours — not rented

One download. Your projects, rules, and history stay on your disk. We don't train on your code — license check only.

Licensing — 7-day trial, $49.99 single, or $99 for 3 devices
No cloud account required
Offline grace — 14 days on paid plans (not trial)

Your engineering process, followed by Claude, Cursor, Codex, and OpenCode

Your virtual employees. Already briefed.

New chat. Blank slate.

Index. Work. Pick up where you left off.

Index your work

Work normally

Pick up where you left off

Standards in orkai. Review on every push.

In orkai

Project + machine

Every commit / push

Read report → fix

Persistence in every shape you already use

Yours — not rented

Try free for 7 days