Product

How Kojo works.

A session is the shared context; a run is bounded; a computer is an execution resource. This page describes the product today.

Preview means built and tested, not yet proven end to end in production; it may change. Not yet means not available yet. The status table lists every capability this site claims.

On this page: sessions · roles · runs · computer · pull requests · agents · monitors · status · limits

A session is the shared context

A session is one conversation, the repositories you picked for it, and one computer. People and the session's agent work in it together, and so can your own agents through the API.

Who is here

• The session header shows everyone here now, the agent included while it works. “Here now” says where each person is: on Changes, on terminal main, typing in it.
• A cursor in each person's colour sits on the tab or terminal they are on. “Show where others are” turns the cursors off on your screen.
• Alone in a session, an owner sees “Invite someone to pair”: it adds a teammate as an editor and emails them the link. “Copy link” copies the session's address; membership still decides who can open it.

Shared terminals

• Terminals are shared shells in the computer. Everyone in the session sees the same screen, and they keep running across reloads and closed tabs.
• One person can take a terminal's keyboard while others watch, ask for it, or are handed it. An owner can always take it, a hold lapses when its driver walks away, and the agent is told which terminals someone drives.

Approvals

In Ask mode the agent asks before steps such as running a command or editing a file, and waits. Someone other than the person who started the task can answer. If nobody answers in time, the step is denied, never quietly allowed.

Roles Preview

Also in a session

• Attach screenshots, PDFs, text and code files to a message, by picking, pasting or dropping them; the agent receives them. Preview
• Fork a session to try another approach on its own branches. Preview

A run is bounded

A run is one stretch of agent work, up to two hours. While it works, the agent pushes its branch every few minutes; at the end, the conversation is saved and the next run resumes it. Sleep and wake keep memory and running processes on the same computer. If the computer is gone, the next run starts a new one from the pushed branch and the saved conversation; running processes do not come back.

Model routes

Each run uses a chain of model routes that your company or you set: your Claude subscription, a Claude API key, or an open model through Claude Code. If a route hits a usage limit or fails before any work, the run moves to the next one, in the same conversation.

Runs on models through Kojo, when you bring no key of your own, are charged to your credit. Preview

Autonomy

Each session runs in Ask, Auto-edit or Full auto. Whatever the autonomy, a merge waits for a person's approval of that merge.

A computer is an execution resource

cpu         4 vCPU
memory      8 GB
checkout    /workspace/<repository>-<branch>, one folder per repository
image       a pinned Claude Code, Node, Python, Chromium, git and build tools
sleeps      after 15 idle minutes, memory and processes kept
wakes on    a message, a preview, a terminal
lifetime    until the session is archived

• Browsers. Every run has a browser in the computer, so the agent can see the app it is building.
• Previews. Each server the agent runs gets a Preview button that opens it on its own origin through a signed link.
• Viewers open only the session's declared preview port; any other port needs an editor. Links last 15 minutes. Preview
• Your keys in your terminals. When your admin and you both turn it on, terminals you open get your own Claude key and GitHub access, so claude, git and gh work there and bill to you. Preview
• The agent's web browser. Save a login once; the agent opens a browser signed in with it when it needs one, and you can watch or take over. Preview

Pull requests and repositories

A session holds the repositories you pick; a model never picks them. The agent works on its own branch in each and pushes as it goes. “Open a pull request” publishes the work as a draft, described by each request and the agent's answer, with the screenshots it committed; “Update the pull request” rewrites it. Kojo opens pull requests with its own GitHub access, not a token from the computer, and merges only on a person's approval of that merge.

Many repositories, one change Preview

A session can hold several repositories. Its work publishes as linked draft pull requests, one per repository, opened in order; if one fails, retrying finishes the rest without opening duplicates. Preview

GitHub access in the computer Preview

With the GitHub App, the computer gets a token for the session's repositories only, new for each run and revoked when it ends. With a personal token you connected, the computer uses that token. Preview

An agent is a member Preview

The API has the same surface as the app. Scoped API keys join a session as automation members: they read and send messages, and a key that works as its person may use the computer when that person is an editor. A catalog lists each operation with its JSON Schema and the scope it needs, and MCP tools let an agent read sessions and activity. An agent can start work for other agents up to 3 levels deep and 5 at once, by default. Preview

Signed in, the API page of the app lists every operation your workspace can call, and nothing else, with the OpenAPI document to download.

$ curl -X POST "$KOJO_API/coding/sessions" \
    -H "Authorization: Bearer $KOJO_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "repositories": [{"full_name": "acme/web", "mode": "pr"}],
      "first_turn": "Make the checkout test pass on Safari."
    }'

Illustrative request. $KOJO_API and $KOJO_KEY are placeholders; the API page in the app has the current operations and schemas.

A local client that lets your own Claude Code join a cloud session is built but not distributed yet. Not yet

Workflows and monitors Preview

A monitor watches GitHub events, such as a new issue, filters them, asks a typed question about each, and proposes work under a policy you set, with a dry run against real issues before anything is turned on. Monitors are turned on per workspace. Preview

A monitor starting a run and opening a draft pull request on its own has not been exercised end to end. Not yet

What works today

Every capability this site claims, with its status from our build ledger. A capability is Available only when its tests exercise the real behaviour.

Built for a specific workflow. Expanding deliberately.

• Claude Code is the supported harness. Open models run through it as fallback routes; Codex and Cursor are not supported.
• Kojo runs in the browser, on desktop and phone. There is no native app, no local worktree mode and no push notifications: a session page is live while it is open.
• One active run per session. Parallel work uses more sessions.
• Hosted service. Not self-hosted, not open source.
• Kojo sleeps when nobody uses it. The first visit after a quiet spell shows a waiting page while it wakes, and a tab left idle rests until you continue.
• Agents through the API, multi-repository pull requests and monitors are Preview. Preview See what works today.

Not a fit today: local-only workflows, self-hosting requirements, teams that need Codex or Cursor as the primary harness, or one person who only wants a desktop worktree manager.