The Cortex Agents screen during the recorded run: agent cards on three runtimes, one showing Claude Code's own interface, and the Orchestrator panel with the objective Charge invoice tax exactly once, completed.

{{ tip.title }}{{ tip.text }}

            {{ s.t }}{{ cursorEl }}

          

          
          {{ w.foot }}

More agents won't fix a coordination problem.

Your coding agents can work independently. The hard part is making their work move in one direction.

Replays a run recorded in Cortex on 13 Oct 2026 · select a window to inspect it

One objective, three runtimes.

create_objective {
  "title": "Charge invoice tax exactly once",
  "tasks": [
    { "key": "trace", "assigned_agent_id": "<invoice-trace>" },
    { "key": "fix",   "depends_on": ["trace"],
      "assigned_agent_id": "<fix-review>" },
    { "key": "tests", "depends_on": ["trace"],
      "assigned_agent_id": "<test-plan>" }
  ]
}

A short script, acting as an MCP client, submitted this. Cortex did not plan it: it ran each task on the agent it was assigned to, in dependency order, and passed the trace to the two tasks waiting on it.

Fig. 1 · The Agents screen during the recorded run, in the real app. The agents' output is real; the project is a small example service with two planted bugs. Select a number to read the note.

Choose the next move

objective · charge invoice tax exactly once

          replay ×5 · t = 8.5 s
          
          all COMPLETED at 20.7 s

Fig. 1 · Agents screen · 1280 × 800

What the screen is showing.

What Cortex is

Cortex is a Windows desktop app that starts Claude Code, Codex and OpenCode as processes it owns, shows whether each agent is ready, busy or crashed, and runs tasks across them where one agent's result feeds the next.

Any MCP client you configure can drive the same core. The run above was submitted that way: one create_objective call with three tasks and their dependencies.

Cortex has no cloud service, account or telemetry of its own; the agent CLIs talk to their own providers. Agents, tasks and the MCP server stop when you close the window.

Three CLIs behind one contract.

Cortex drives the CLIs already installed and signed in on your machine; it does not bundle them. Each adapter translates one CLI: executable, flags, protocol, readiness, end of turn. Starting, stopping, limits and recovery are the same for all three.

Claude Code

Protocol

stream-json, JSON lines over stdio

Process · modes

One per session. Structured (default) or terminal; created from the New agent dialog or MCP.

In structured mode

Anything that would need approval is denied. Rules you allowed in Claude Code's own settings still apply.

Codex

Protocol

exec --json, JSON events on stdout

Process · modes

One per instruction, resuming the same thread. Structured; created over MCP.

In structured mode

Runs in a read-only sandbox: it can read and run read-only commands, not write.

OpenCode

Protocol

ACP, Agent Client Protocol over stdio

Process · modes

One per session. Structured; created over MCP.

In structured mode

Edit, shell and web requests are refused.

A missing CLI marks its runtime unavailable, with a fix; Cortex still starts. All three declare interrupt and turn completion. The contract is built so another CLI can be added without changing the core; none is scheduled.

Fig. 2 · Terminal mode

Or keep the CLI's own interface.

Terminal mode gives you Claude Code's own interface in the card. Cortex owns the pseudoconsole and the process tree; the CLI's own permission rules apply, including an auto mode you turned on there.

A terminal agent is driven only by you: it takes no tasks, MCP messages or interrupts, and Cortex keeps no transcript of it.

The pairing agent card in terminal mode: the Claude Code interface inside the card, answering that retries wait 2, 4 and 8 milliseconds instead of seconds, with its input box and auto-mode footer.

Any MCP client can drive the same core.

Cortex hosts an MCP server on 127.0.0.1, port 47821 by default. Claude Code, or any MCP client you configure with your token, can list, create, start, message, interrupt and stop agents, submit objectives, cancel tasks and follow every turn.

Events are read by cursor with poll_agent_events, which keeps the latest 256; there are no push notifications yet. An agent Cortex started gets a read-only credential for its session.

Claude Code mcp · cortex read · 7

            list_projects
            list_runtimes
            list_agents
            get_agent_status
            poll_agent_events
            list_tasks
            get_task_status
          

> What state is ledger-api in?
● cortex · list_agents
└ 5 agents, all READY
● cortex · get_task_status  trace
└ COMPLETED
● cortex · poll_agent_events  cursor 412
└ 3 new events, next cursor 415

Codex mcp · cortex write · 3

            create_agent
            send_message
            create_objective
          

> Set up the invoice tax objective.
● cortex · create_agent  fix-review · codex
└ created
● cortex · create_objective  "Charge invoice tax exactly once"
└ 3 tasks; fix and tests depend on trace
● cortex · send_message  retry-debug
└ accepted

OpenCode mcp · cortex control · 4

            start_agent
            stop_agent
            interrupt_agent
            cancel_task
          

> Stop retry-debug and restart test-plan.
● cortex · interrupt_agent  retry-debug
└ turn interrupted
● cortex · stop_agent  retry-debug
└ STOPPED
● cortex · start_agent  test-plan
└ READY

Illustrative sessions, not a recording: each CLI configured as an MCP client of Cortex. The 14 tool names and agent states are real; highlighted names are the ones called.

What works today, and what does not yet.

As of 13 October 2026, v0.1.0. An item is listed as available only after its real path has run end to end on Windows.

Available

Agents with an ID, a project and a runtime; definitions persist across restarts
Start, stop and restart, with buttons enabled only by the reported state
Structured and terminal interaction modes, chosen per agent
A console to send an instruction and read the output
Processes screen: PID, parent, command, owner, kind, start time
A cap on running agents: 6 by default, 1 to 32 in config.json
Job Object ownership and recovery at startup
Objectives of 1 to 10 tasks with dependencies; retried once by default; 2 run in parallel by default
MCP server with 14 tools
Documentation: installation, user guide, command and MCP tool reference
Remote MCP access with OAuth 2.1, verified with a test client against a simulated public URL

Planned

NEXT · V1.5

Messages between agents
Global skills, hooks and behaviours
Routing: choosing the runtime or agent for a task, with the reason recorded
A command-line interface
A public, signed download of the installer

LATER · V2

Scheduler and resource manager, with CPU and memory
Supervisor and timeouts
Git worktree isolation and file ownership
Loop detection and journal-based recovery
Permissions and autonomy modes
Execution timeline

Fifteen places in the first beta.

You confirm your email with a 6-digit code that expires in 10 minutes. Your place is held while you confirm, for at most 30 minutes, and becomes yours once the code is accepted. After that, this page offers the Windows installer (x64, unsigned) with its version, size and SHA-256.

Your name and email are stored only to run the beta. Registrations that are not confirmed are released within 30 minutes and deleted later.

Registration needs JavaScript. Turn it on in your browser and reload this page.

Until there is a public build, follow the project on Instagram, Threads and YouTube, or read the documentation.