v0.4.0

AgentBus 0.4 gives agents and people one clear API, the same for every vendor.

What you can do now

• Run a shell command from the chat. A message that starts with ! runs in the session's copy,
  on its runner, with no model call. The output is in the conversation, and the next turn sees it.
• Start a session in any folder you type. No -folder flags and no restarts. The connector
  checks the folder and keeps it.
• codex and agy on runners that hold no secrets. Connect codex (ChatGPT) or agy (Google) once on
  control, as with claude. Control renews the sign-ins. Runners never hold one.
• agy (Google's Antigravity, Gemini) is a harness, beside claude and codex.
• Each conversation gets a home of its own on a runner. A turn sees none of the runner user's
  settings, memory or transcripts, and none of another conversation's.
• Every agent gets the folder's AGENTS.md, whatever its harness, once.
• Agents can use the API as tools (MCP), off by default. Set [agent_api] tools = true and a
  claude or codex turn gets list_agents, ask_agent, review_turn, apply_turn and the rest.
• See your runners. GET /api/v0/runners lists runners and connectors, online or not, with
  the harnesses each one found.
• See what AgentBus added to a turn. The context.added event lists the instructions, the
  folder's AGENTS.md, who asked, and the tool server's text.
• A failed turn says why, even when the agent gave no reason: the refusal of its last model
  call.
• Closed sessions read as closed and are never offered to continue.

Changes to the API

The API is now three nouns: agent, session and turn. Every action is on a turn. The old routes are
removed with no alias. The full list is "What 0.4 changes after 0.3" in docs/CLIENT_API.md.

• POST /api/v0/turns answers {session, turn, state, ...} at once. A turn can be queued.
• Turn states: queued, running, finished, failed, stopped.
• POST /api/v0/turns/<id>/stop replaces cancel. POST /api/v0/turns/<id>/review starts a
  review turn.
• Model calls: GET /api/v0/turns/<id>/calls/<call>. Events by page:
  GET /api/v0/sessions/<id>/events?turn=.
• New: GET /api/v0/sessions/<id>, PATCH /api/v0/sessions/<id> with closed: true,
  POST /api/v0/sessions/<id>/commands, GET /api/v0/runners, POST /api/v0/mcp.
• New events: command.queued, command.started, command.ran, command.failed,
  context.added, tools.listed.
• Gone from the client API: /api/v0/jobs, /api/v0/attempts, /api/v0/workspaces,
  /api/v0/calls, /api/v0/turns/<id>/events.
• The runner protocol moved to /api/v0/runner/ (protocol 2), with its own doc. Upgrade
  control, connectors and runners together: a 0.3 runner cannot talk to 0.4 control.
• A connect's view gains paste. An ended connect keeps no link or code.
• /docs/llms.txt is short, for an agent to read in one go. The long reference is
  /docs/reference.md.

Known limits

• A ! command works only after a session's first turn has ended. The agent does not answer a
  command by itself: it sees the output with your next message. A later release changes both.
• A session stays on one runner. Its copy lives there.
• agy on a runner is not yet checked with a real turn. claude and codex on a runner were.
• agy gets no instructions of AgentBus's own and no MCP tools. A turn with forbid set, or with
  subagents = false, is refused on agy.
• agy's Google sign-in on runners is your own risk with Google (its terms, clause 6). It is off
  unless you set subscriptions_on_runners = "own".
• OpenRouter turns show a cost of $0.
• Copies on shared or network disks are slow. Keep the data folder on the machine's own disk.
• Network control is Linux only, and off by default.
• Not yet tested on a real Ubuntu 24.04 machine. CI runs the gate on ubuntu-latest.
• The v0 API may still change.

Upgrading from 0.3

• Read "What 0.4 changes after 0.3" in docs/CLIENT_API.md. A 0.3 client needs changes.
• Back up control's data folder first. Copies made by 0.3 stay where they are and still work.

Install

• brew install staysup/tap/agentbus, or
• curl -fsSL https://raw.githubusercontent.com/staysup/agentbus/main/install.sh | sh

AgentBus is open code under FSL-1.1-ALv2. Each release becomes Apache 2.0 two years after it is
published.

v0.3.0

AgentBus 0.3 lets you talk to many agents in one conversation, and run them on other machines.
Your code stays on your machine until you say "apply".

Talking to agents

• A session is a conversation. You write and an agent answers. Ask for anything else in plain
  words in the chat.
• Saved agents. An agent is a harness (claude or codex), its access, a model and a name.
  Access is your own subscription, or an OpenRouter key read from a variable by name. Add agents
  with POST /api/v0/agents or "+ Agent" in the cockpit.
• Switch model or agent on any message. The conversation carries on with the new one.
• Messages queue. Send the next message while a turn runs. It runs after it.
• Agents ask agents. An agent can hand work to another agent, or to several at once. Each
  answer comes back as the next turn of the session. Ask in the chat: "have codex review this".
  The asked agent is told who asked it and can read that turn's changes.
• Rename a session with PATCH /api/v0/sessions/<id>.

Your folder is safe

• Each conversation works in its own copy of your folder, uncommitted edits included. Your
  folder does not change while agents work.
• Every turn has a diff: each file added, changed or removed, with its own text diff.
• Apply up to a turn, all or nothing. POST /api/v0/turns/<turn>/apply brings in every turn
  not yet applied, up to that one, in one step. If a file in your folder changed since, nothing is
  written and you get each file and why.
• Review is optional. Read the diff and say "apply", or ask another agent to check it first.

Three roles, one or more machines

• One program, three roles. Control keeps the API, the queue, the record, the settings and the
  gateway. A connector owns the folders on its machine. A runner runs agents.
• agentbus up runs all three in one process. One person on one machine needs nothing else.
• agentbus server, agentbus connector and agentbus runner run them apart. Keep control and
  the connector where your code is. Run runners anywhere, such as a Linux VM. Runners pull their
  work, so they work behind a router.
• File contents travel by hash. Each side sends only what the other lacks. A second session on
  a big folder sends almost nothing.
• A runner's turn shows live in a cockpit pointed at control: events, model calls and replies.

Runners hold no secrets

• Control gives each runner turn a token of its own. Control's gateway swaps it for the real
  credential on the way out.
• An OpenRouter key stays in control's environment, read by the variable's name.
• Your own Claude subscription can serve your own runners. Connect it once on control with
  agentbus connect claude, or Connect in the cockpit. It is off by default: set
  subscriptions_on_runners = "own" in permissions.toml.

Network control (Linux)

• Off by default. Turn it on in permissions.toml:
  [network] contain = "on" and allow = ["github.com", ...].
• Then each agent reaches only its gateway, control and the hosts you allow. Everything else is
  refused and recorded as network.refused.
• A runner that cannot close an agent off (a Mac, for example) refuses the turn and says why.

Settings

• permissions.toml decides edits, limits on asking, the agents' API and network control.
• instructions.md holds the text every turn gets.
• Both have API routes. A runner on another machine reads them from control.

Failures end clearly

• An interrupted transfer, a restarted role, a repeated request, a connector that went away and a
  file edited before apply each end with a clear error or a clean result. Never half-applied work.

Known limits

• OpenRouter turns show a cost of $0. The price table has no OpenRouter prices yet.
• A session stays on one runner. Its copy lives there.
• Copies on shared or network disks are slow. Fast copies need APFS, xfs or btrfs, with the folder
  and the data folder on the same disk.
• The first transfer of a big folder is slow: about 30 s for 50,000 files (414 MB). Later sessions
  take about 4 s.
• Network control is Linux only. On macOS, contain = "on" refuses every turn.
• An asked agent reads the asker's changes through the API. Its own copy is made from your folder,
  so it cannot run those changes.
• codex on a subscription cannot run on a remote runner yet. Use an OpenRouter agent there, or
  agentbus up.
• The v0 API may still change. 0.4 will reshape some routes.

Upgrading from 0.1

• Read "Versions" in docs/CLIENT_API.md: what 0.2 changed, then what 0.3 changed.
• Your 0.1 turns still work. The seeded claude and codex agents keep them unchanged.

Install

• brew install staysup/tap/agentbus, or
• curl -fsSL https://raw.githubusercontent.com/staysup/agentbus/main/install.sh | sh

AgentBus is open code under FSL-1.1-ALv2. Each release becomes Apache 2.0 two years after it is
published.

v0.1.1

Changelog

• b9fd573 Codex hint check: a relative CODEX_HOME is read from the turn's folder
• ed0d331 Merge branch 'main' into permissions-file
• d3adba3 README: a screenshot of the API docs
• c1c332d README: the API docs screenshot right under the links
• 6e23e44 Root redirects to /docs, the gateway guard covers vendor paths only, and GET /api/v0/version
• 8c8e1ca Stop one turn, and tell each turn its history is there
• 7819cbd Tests: fast unit tests by default, the slow ones behind the integration tag
• 783bf36 agentbus up: -listen takes any IP address, such as 0.0.0.0 in a container
• 7655e15 agentbus up: any browser origin by default, -origin as an optional lock
• 1eaac75 gateway: refuse forbidden shell commands for claude and codex
• c15737c permissions.toml: read_folders grants reading only, from review
• b5b69fd permissions.toml: say where read_folders is reads only
• d56ed8b permissions.toml: what a turn may do without a person to ask

v0.1.0

Changelog

• 0f9707f AgentBus 0.1