Ergana In development

Codex + Claude Code · one workspace

Put your agents
to work together.

Give Codex and Claude Code one feature. Ergana is being built to split it, run the work in parallel, send failures back and bring you a verified result to accept.

Explore the preview Watch it work · 0:49

Waiting for you

Neo asks to write a file src/Export/CsvWriter.cs Review it in the preview
Concept previewSample team and tasks. Ergana is in development.
Runtimes
Codex + Claude Code
Execution
Your own machine
Accounts
Choose per agent · planned

Why Ergana

The fastest way to run a mixed team of coding agents you can trust.

Codex and Claude Code, working together on the accounts you already have. Coordinated in milliseconds, verified by a second model, approved by you.

Fast

Coordination at machine speed.

Routing, triage and checks take milliseconds, and agents work in parallel. The only thing you wait for is the work itself.

Trusted

No model grades its own homework.

Work built by one vendor’s model is verified by another’s. Failures go back on the board, and you approve what matters.

Yours

Your accounts, your rules.

Use the Codex and Claude Code subscriptions you already pay for. No API keys, no second AI bill.

In development. These describe the planned product.

Instead of

  • three terminal windows
  • copy-pasting diffs between agents
  • a second model in another tab
  • guessing which account ran what

one board.

A home for your agents. That’s a “company”.

Think of a company as a persistent team workspace: its agents, projects, shared instructions, task history, and budgets belong together.

You can give work directly to an agent. When a job needs more hands, use a manager to delegate and pull the results together. Keep one company for your product, or separate companies for different clients. You don’t need to run a business to use one.

In development. The previews below show the planned product using sample data.

From issue to done.

Five moments. You own two of them.

  1. You

    Brief

    Describe the outcome once, in plain words.

  2. Morpheus

    Split

    A manager breaks it into tasks and picks the agents.

  3. Neo + Trinity

    Build

    Claude Code and Codex work in parallel, on the accounts you chose.

  4. Trinity

    Test

    Failures go back on the board. A second model verifies the rest.

  5. You

    Accept

    Review a verified result. Nothing ships on silence.

The planned workflow, shown with a sample team.

Coordination · powered by Jev

The small decisions, made in milliseconds.

Between every agent run sit dozens of small calls. Who takes this task? Is this request risky? Is this run stuck? Does this result match the brief? Ergana is being built to make them with Jev, TypeSafe’s fast decision model, so coordination never becomes the bottleneck.

Routing

Picks the agent, model and account for each task, by what it is, how hard it is and how risky.

ERG-42 → Neo · Claude Code · Work

Approval triage

Rates each tool request, so you’re only interrupted for the ones that matter. The rest follow rules you set yourself.

write src/Export/CsvWriter.cs → ask you dotnet test → your rule: allow

Watchdog

Spots a run that loops, stalls or drifts from the brief, and flags it before it burns an hour of tokens.

ERG-44 · same edit 3× → flagged

Pre-check

Checks a result against the brief before the full second-model verification, so obvious misses go straight back.

ERG-42 · newline case missing → Neo

Planned. Sample decisions are illustrative. Overall speed still depends on the task and the providers; benchmarks will follow validation.

A mixed team is a safer team

No model grades its own homework.

Verification is its own task, run by a model from a different vendor than the one that did the work. It checks the result against the brief and reports what passed, what failed and what still needs you.

A second model brings another perspective; tests and evidence still matter.

No second AI bill

Use the subscriptions you already pay for.

Connect several Codex and Claude Code accounts and assign them deliberately. Every run shows which provider and account it used. No API keys needed.

Planned, with illustrative account labels. Existing runs keep their selected account; changing a preference applies to new work. Provider limits and charges still apply; this is not unlimited usage.

  • Claude Code · WorkNeo
  • Codex · PersonalMorpheus, Trinity
  • Codex · Workavailable

No API keys

Nothing gets lost in a terminal

Failures are part of the workflow.

A failing test sends the task back to its agent, visibly, on the board. The parent issue waits until the fix passes, so nothing ships half-done and nothing is quietly retried.

More work in parallel.
Less work coordinating it.

Keep work moving with parallel runs, shared context, clear boundaries, and a workspace you can return to.

Let independent work move

Implementation and tests can move together. Parallel execution is a first-release goal, including multiple runs on the same authorized provider account. One busy agent should not make every other agent wait.

Performance work focuses on responsive output and low execution overhead. Actual throughput depends on your machine, the task, and provider limits. Benchmarks will follow validation.

Give a brief, keep the context

Keep the handoff in the workspace. Describe the outcome once. A manager can break it into tasks, delegate to specialists, and consolidate their results. Shared company instructions keep the team working to the same conventions.

Return to the task’s output and decisions without piecing together terminal sessions. Start with one agent when that is all the job needs.

Room to work. Boundaries that stay put.

Agents work inside sandboxes. The planned execution environment limits which files, tools, and resources an agent can reach, so giving it a task doesn’t mean handing over your whole machine.

Isolation contains the reach of mistakes. Approvals and verification help you assess what happens inside those boundaries.

Review at the moments that matter

Keep approvals, steering, and spending close to the work. Review tool requests, send a correction, or stop a run. See whether a message is queued or delivered, and whether a cost is reported, estimated, or unavailable.

Budget warnings and run limits are planned. Provider reporting delays mean these controls cannot guarantee an exact billing cap.

Your workflow, on your operating system

Planned for Windows, macOS, and Linux. Keep the same way of assigning, following, and reviewing agent work on the platform you prefer.

Windows and Linux are being qualified first, with macOS to follow. Agent workloads target Linux sandboxes; host support does not mean every native Windows or Mac application can be built inside them.

In development. These are product goals, not a list of generally available features.

Watch it work.

Follow a CSV export through a planned Ergana workflow: an issue, a manager that splits it, two agents working in parallel, a failed test sent back, and a verified result for you to accept.

One issue, across the board

Morpheus splits the issue. Neo builds the endpoint with Claude Code while Trinity writes tests with Codex. When a test fails, the work moves back to Neo on the board. Nothing reaches you until it passes and is verified.

  • 0:04 Write the issue
  • 0:10 Split the work
  • 0:14 Build and test in parallel
  • 0:23 Run the tests
  • 0:27 Send a failure back
  • 0:33 Retest and verify
  • 0:38 Accept and finish

49-second animated concept · sample data · no audio. Captions and the transcript below cover the full story. Timing is illustrative, not a benchmark.

Read the walkthrough transcript

0:04 — The issue. In the Launchpad company, open an issue: add CSV export to the orders page, handle empty results, commas, quotes and newlines, and bring it back for review. It is assigned to Morpheus, the manager.

0:10 — The split. Morpheus, using Codex, splits the issue in two: Neo builds the export endpoint with Claude Code, and Trinity tests the edge cases with Codex.

0:14 — Parallel work. Both agents work side by side, Neo on the Work account and Trinity on the Personal account. Neo asks to write a new file; nothing runs until you approve. Labels are fictional; multi-account support is planned.

0:23 — Testing. Both tasks move to Testing. Trinity runs the suite: 13 tests pass and 1 fails, because a newline inside a field is not quoted.

0:27 — Sent back. On the board, Neo's task moves back to In progress while the parent issue waits in Testing. Neo reads the failing test and fixes the quoting rule.

0:33 — Retest and verify. Neo's task returns to Testing and the rerun passes, 14 of 14. Trinity then checks the work against the original brief, using a different model from the one that wrote it.

0:38 — Done. The sub-issues fold back into the issue. You accept it and it moves to Done. Nothing is merged or deployed by this demo.

Try the workspace

Neo wants to write the CSV export endpoint. Approve or decline the request, then follow the task or inspect the team's budgets. This concept uses sample data.

Waiting for approval

Neo TOOL 2 min ago

Worker agent asks to write files inside the company workspace.

write src/Export/CsvWriter.cs — sample change

Morpheus HIRE 6 min ago

Manager proposes a new agent. Only a tenant owner can activate it.

Vale · reviewer · claude code · reports to Morpheus · budget 40 / month

Trinity TOOL just now

Worker agent asks to run a command inside the company sandbox.

dotnet test --filter ExportTests

Decision log

  • No decisions yet. Approve or decline a request above.

Nothing runs on silence

Requests wait for a person. If nobody is at the screen, the work waits — an absent human is never read as approval, and never as a refusal either.

  • A manager proposes an agent; a tenant owner activates it. Ordinary company access is not enough.
  • Pending requests survive closing and reopening the app.
  • Approving a tool action never grants an escape from the company's sandbox.
  • Every decision is recorded against the task it belongs to.

Interactive concept Sample data. Approving here affects this page only.

Task · Test the CSV export

--:--:-- Press “Start run” to replay a sample run.

Idle

You see it as it happens

Output reaches the screen while the agent is still working. What Ergana can show is limited by what the runtime emits — but it never holds back output it already has.

  • A message you type appears in the conversation immediately, marked as not sent to the agent.
  • Delivery only happens when you choose to steer, and the interface distinguishes queued from delivered.
  • If delivery fails, it says so. It does not claim delivery it cannot establish.
  • Stop means stopped. Work whose effects are uncertain goes to a visible Needs attention state for a human to inspect — never a silent replay.

Interactive concept Sample data on a timer. No runtime, provider or network call is involved.

Launchpad · reporting lines

Agent detail

Agent
Morpheus
Role
Manager · development
Runtime
Codex
Reporting line
Reports to you
Tasks
3 open · 1 delegated tree
Status
Active · warning at 80% reached
Budget
Estimated 81% of a 250 monthly budget

Interactive concept Sample data. Amounts are illustrative and carry no currency or pricing meaning.

Already have an agent app?

Cross-provider teamwork, with the coordination built in.

MCP bridges already let coding agents work across Codex, Claude Code, and other runtimes. Ergana is being built to make that coordination part of your workspace: connect your accounts, assign agents, and keep their tasks, approvals, and results together.

That can mean two Codex accounts and a Claude Code account in the same team. Codex and Claude Code come first; support for additional vendors is planned. The aim is to keep the same workflow as your mix of accounts and vendors grows.

An existing cross-provider MCP project

T3 Code — when you want a direct interface to your coding agents

T3 Code brings several coding providers into desktop, web, and mobile interfaces. It already documents multiple Codex and Claude accounts. Those capabilities alone are not a reason to switch.

Ergana adds a team-oriented workflow: agents with roles, shared company instructions, delegated tasks, and budgets that stay together from one piece of work to the next.

T3 Code’s own overview and account guides

Paperclip AI — when you want to organize an AI company

Paperclip is the closest alternative: it already coordinates agents, accounts, goals, and budgets. You can self-host it without a Paperclip account. It also supports external tools and MCP connections.

Ergana starts with the agent you want to run. Give one agent a task, follow its live output, and steer the work yourself. Add a manager when delegation helps. The company keeps the context together as you grow into a team.

Our priorities are a short path from account selection to useful work, responsive parallel runs, and external connections that are easy to set up and reuse. These are the experiences we want to earn your preference on during the beta.

Paperclip has substantial overlap here. We haven’t established a performance or integration advantage; both need comparison on real tasks.

Paperclip’s self-hosted setup · Account and integration release notes

Codex Desktop — when your work centers on Codex

Codex’s app already supports parallel work and workflows around projects, reviews, and automations. If that fits how you work, Ergana does not need to replace it.

Ergana packages the coordination around your agents. You can already connect Codex to other coding agents through MCP tooling. Ergana’s planned workflow brings account assignment, delegation, approvals, and shared task history into one place, with the same team structure as support for more vendors arrives.

OpenAI’s Codex app overview

Claude Desktop — when you want Claude across coding and everyday work

Claude Desktop combines Chat, Cowork, and Code. Its Code workspace already includes parallel sessions, visual diffs, and app previews; it is much more than a chat window.

Ergana gives a mixed team a shared workspace. MCP tooling can already connect Claude Code with Codex and other agents. Ergana’s planned workflow includes that coordination, with several accounts, reusable agent roles, and one place to follow delegated work. You still sign in to and authorize your own accounts.

Anthropic’s desktop documentation

Based on the linked product documentation, checked 24 September 2026. Ergana is in development; its capabilities above describe the planned product. This is a workflow comparison, not a benchmark or a claim of feature exclusivity.

Early access

Explore
Ergana.

Explore the workspace while we get Ergana ready for you.

The waitlist isn't open yet

We're getting email updates ready before accepting signups. You can explore the product here in the meantime.

Try the interactive preview

No email address is collected while signups are closed.

Questions about Ergana

Do I need a manager and a whole team to start?

No. Give work directly to one agent inside a company. The company keeps its instructions, projects, and history together. Add specialists and a manager when delegation helps; a reporting hierarchy is a way to organize work, not the starting task.

Is Ergana limited to two accounts or two vendors?

The plan supports multiple accounts per vendor, so a team can use more than two accounts even with Codex and Claude Code alone. Those are the first-release providers. Additional vendors are planned; we haven’t announced which ones or their release dates.

Does multi-account support mean unlimited usage?

No. It means choosing among provider accounts you are authorized to use and seeing which account a run uses. It does not remove provider quotas, combine subscriptions into unlimited capacity, or promise automatic account switching. This capability is planned.

What do company, agent, task, and runner mean?
Company
A persistent home for an agent team and its projects, instructions, tasks, files and budgets. It can represent a product, a client, or your own work. Each company keeps its own records.
Agent
An AI worker belonging to exactly one company, with its own role, instructions, reporting line and spending.
Task
A unit of assigned work with its own history and output. Tasks form trees as managers delegate.
Runner
The service that actually executes agents through Codex or Claude Code, on a workstation you control.
What stage is Ergana at?

Ergana is in active development. This page describes the intended product, including planned parallel execution and multi-account support. There is no public download yet. The waitlist will open once email updates are ready.

When is the first release?

No release date has been announced. Email updates and waitlist signups are being prepared. Check back here for availability.

What will it cost?

Subscriptions are planned, but no plans, prices or tiers have been decided and nothing is for sale today. When the waitlist opens, joining will be free.

Will I need API keys?

The first-release goal is to work with your own Codex and Claude Code subscriptions, without requiring API keys. Multiple provider accounts and explicit account selection are planned. Provider access, usage limits, and charges still apply; exact sign-in and account compatibility are being validated.

Where does the work actually run?

Agents run through a runner on your machine. Local execution keeps your working files close to the tools, but agent requests still go to Codex or Claude’s provider. The current development setup uses Docker. Windows and Linux are being qualified first, with macOS planned to follow. Agent workloads target Linux sandboxes; native Windows and Apple toolchains are outside the first-release scope. This is not an offline language model.

Execution continues while the interface is closed, as long as the background service and runner are running. Work that needs a human waits rather than assuming an answer.

Is the preview on this page the real product?

No. The workspace views here are interactive concepts running on sample data in your browser, and the video is a walkthrough of those concepts. They show the interface and behaviour being built, not a recording of working software.

What happens to my email address?

We aren't collecting email addresses while waitlist signups are closed. The privacy note explains how the waitlist will handle your address when it opens.