Coban Join the waitlist

Desktop app, in development

Change the agent.
Keep the project.

Coban runs coding agents inside a workspace that outlives them. The task, the worktree, the commands they ran, the decisions you made and what the project knows all stay on your machine — whichever agent produced them.

One email when there is a signed build to install.

TASK-201 · add OAuth login claude · native
    reading the repository

    A run, as Coban shows it. Answer the request to see both paths.

    One loop, start to finish

    This is the whole first release. It should be worth using even if you never change providers.

    1. Open a repository

      It becomes a project with its own tasks, history and settings — not a chat session that disappears when you close the window.

    2. Give an agent a task

      Scope and acceptance criteria first, then the run. Write-heavy work happens in its own Git worktree, so a run cannot disturb what you have open.

    3. Watch, and answer

      Files read, commands run, tests, diffs. Anything risky waits in a queue with the command and the reason attached. Nothing is installed, committed or pushed behind your back.

    4. Review as one package

      The diff, the test results, the reviewer's findings and the open questions arrive together. Approval is bound to a specific diff; a later change invalidates it.

    5. Come back tomorrow

      Close the app. The local service keeps the record: every run, every decision, everything the project has learned.

    What survives a change of agent

    Mid-task, you can hand the work to a different agent. Coban does not paste the old conversation into the new one — it passes the task and what the project knows.

    Handing TASK-201 to Claude native

      4,120 tokens of context — not the 61,400 in the transcript.

      Six parts of the same project

      Agent output is only useful if you can inspect it. Every run leaves something you can read.

      Tasks
      The unit of work: the prompt, every run against it, the files produced, the tests and the decisions. Reopen it a week later and the context is still attached.
      Review
      Acceptance criteria matched against tests, changed files, findings marked blocking or not, and the open questions nobody answered yet.
      Terminal
      A real PTY beside the agent, not a log viewer. Run the build yourself, watch the process the agent started, keep both in the project window.
      Git and worktrees
      Each write task gets its own worktree and branch. Parallel attempts stop fighting over your working tree, and diffs are read against the commit the run actually started from.
      Memory
      Conventions, decisions and known traps the agent may read. Agents propose; you verify. AGENTS.md and CLAUDE.md stay your files.
      Approvals
      Every permission-sensitive action, with the command, the path and the risk. Grant once, for the run, or for one exact command — never a blanket shell permission.
      coban — acme-shop
      The Coban workspace: project tabs, an approval waiting at the top, running agents, active tasks and project memory.
      Design preview. Demo data; the shipped build will differ.

      One integration at a time

      A capability a provider documents still has to hold for the version, account type and platform you actually run. So each one is measured before it is offered.

      AgentWhere it standsConnection
      Codex First real integration. Local app-server with a structured API and generated schemas; the installed binary version is pinned. app-server
      Claude Second path, through the documented SDK or a maintained ACP bridge. No dependency on private control messages, and no third-party use of your session. SDK / ACP
      OpenCode Documented stdio protocol. Compatibility is measured per provider rather than assumed from the protocol itself. ACP
      Others ACP negotiates capabilities per version, so support is tested one agent at a time. An agent that cannot be driven safely is labelled, never quietly downgraded to a wider permission mode. ACP

      You bring your own agent access. Coban finds what is installed and uses it; it never resells or impersonates a provider account.

      Your code, your machine, your record of what happened

      Coban runs on your computer and stores its data there. Remote access and team sync come later, and they will be something you switch on.

      • Nothing is uploaded for the product to work. Projects, tasks, runs and events live in a local database next to your repositories.
      • Credentials go to the system keychain. Not to a Coban server, and never into an agent's prompt.
      • A worktree is isolation, not a sandbox. It separates working files. It is not an operating-system sandbox and will not be described as one.
      • Guarantees only where they can be checked. An agent driven through a structured protocol can be held to an approval. One wrapped as a raw terminal cannot, and is labelled that way.

      Tell us where to send the first build

      Early access goes to people working across more than one repository who review agent changes themselves. If that is you, a line about your setup helps.

      One email when there is something to install. No newsletter.