How Koryphaios works
One request can turn into a small team of agents working in parallel, reviewing each other, and committing recoverable checkpoints as they go. Here's the machinery.
The three roles
Manager (“Kory”)
Reads your request, classifies the task, and decides whether to answer directly or decompose it into subtasks. It has full tool access (read/write files, shell, web) and is the only agent that talks to you. It asks before executing delegated work unless YOLO mode is on, and it synthesizes the final answer from what the workers and critic produced.
Workers (builders)
Specialist sub-agents the manager spawns per subtask (frontend, backend, tests…). Each runs in an isolated git worktree with access only to the paths the plan granted, so parallel workers never clobber each other's files. You can route each worker to a different model.
Critic
A read-only reviewer that can only inspect the code (read / grep / glob / ls). It sees the worker's full transcript — thinking, tool calls, results — and returns PASS or FAIL with feedback. On FAIL the work loops back for revision, up to a configurable number of iterations. This is the “self-checking team” that catches mistakes before they reach you.
You control how much of this runs: Agent Mode in the composer switches between Auto (Kory decides), Single Agent (one agent does everything), and Multi-Agent (always delegate). The critic can be toggled per turn.
Parallel isolation with git worktrees
Running several agents on one repo at once is normally a recipe for merge chaos. Koryphaios gives each parallel worker its own git worktree — a checked-out copy of the branch sharing the same object store — so they edit in isolation and their results are merged back deliberately. No two agents fight over the same file.
Time travel (undo / redo)
Every change an agent makes is captured as a ghost commit by the shadow logger — a parallel history that doesn't touch your real branch until you want it to. That means you can rewind the workspace to any prior state instantly, review exactly what changed at each step, and fork a session to try a different path. It's an undo button for autonomous work.
Real-time streaming
The desktop UI talks to the local backend over WebSocket (with an SSE fallback), so you watch thinking, tool calls, file edits, and each worker's status live — not a spinner that resolves minutes later. File edits stream into a Cursor-style live diff as the agent writes them.
Context & memory
Koryphaios actively manages the context window: stale tool outputs are auto-stubbed (and recoverable on demand) so long sessions don't drown in their own history, and a live context-usage bar shows exactly what's occupying the window. Persistent memory and notes can be injected into context under a token budget — see those pages for detail.