Skip to main content

How CAO shipped 32 reviewed PRs, approved from my phone

· 9 min read

I was on a family holiday in Bali, half watching the kid and half watching my phone, when it started buzzing: the CAO repo might need a look.

CI had gone red on two new HIGH-severity Dependabot alerts in the docs site's dependencies. Dependabot had already opened its own fix for each one, and both were red — each fix failed the scanner on the other alert.

A combined fix landed in one pull request, and it still wasn't green. This time on two MEDIUM alerts, in a dependency called minimatch.

CAO's architect — the agent whose job is to weigh security and policy calls, not just write code — looked into why a gate set for HIGH and CRITICAL severities was failing on a MEDIUM. In about 15 minutes, this agent found the root cause: the CI step that uploads the security report ignores its own severity filter once it switches to a certain output format. Then it proved both MEDIUM alerts were unreachable code in this repo — flagged, but never callable.

The fix was a scoped exemption: it named the exact advisory and the exact two files, and, lastly, it set an expiry date three months out so it can't be forgotten. That state was handed off to an independent reviewer, who checked it against the exact advisory and the live gate, with no shortcuts: no blocking issues, four minor nits to tidy up.

A Telegram message from the Herdr bot, asking whether to push a fast-forward update, with a one-tap "Push it" button The moment of the tap: the Herdr bot asking whether to push #1184's formatting fix as a fast-forward.

Three of those nits went out in the next push, folded into one short follow-up commit. About 10 minutes later, there was one more catch: the Code Quality check flagged a formatting slip in the new guard test. The same agent picked it up, fixed it, and pushed once I approved.

By the time I'm writing this, every check is green — Security Scan included — and, after another contributor's review and approval (thanks for reviewing my PR!), it's merged.

That was one Saturday. Over twelve days, the same loop — CAO, the open-source CLI agent orchestrator, running a small team of agents against its own repo — shipped 32 pull requests on its own, asking me for approval before pushing a PR (or anything that reaches the remote, or touches something unexpected).

A digital team for physical AI: CAO agents run a robot factory floor

· 34 min read

A factory line is only as fast as its slowest team. When a fast team runs in front of a slow team, it fills the buffer between them, and then it stands still. On a real site, a planner and the team leads see this and change the plan, every shift. In this post, four AI agents do that job on a simulated line of nine robots. In each of our live runs where the first team blocked, the supervisor agent found the slowest team from the measured state of the floor, and slowed the first team to its pace.

The agents run on CLI Agent Orchestrator (CAO), an open-source tool that runs a team of CLI agents, such as Claude Code or Kiro CLI. CAO gives each agent its own role, its own tools, and its own credential: the key that sets what the agent can do. This is the second post in a series. In the first post, four agents moved one parcel across two zones, one leg after the other. Here, a digital team of agents runs a whole line: three robot teams that work at the same time, and a supervisor that balances them.

Running AI-DLC on CAO: shared memory and multi-intent orchestration

· 10 min read

If you run AI-DLC, you drive one development intent through a structured, audited lifecycle, with a human in the loop at every decision that matters. That focus is deliberate. AI-DLC is not a fully autonomous agent, and it is not a scheduler for many intents at once. One intent, done well.

Real product work rarely stays inside one intent. An API change needs a client change. A migration has to land before a release. And even a single intent accumulates a lot of context as it moves through its stages. At that point you want two things AI-DLC does not set out to provide: a place to keep what each intent learns, and a way to run several intents without them colliding.

That is what this post is about. You can run AI-DLC on top of CAO, and CAO supplies exactly those two things.

Why physical AI needs multi-agent orchestration

· 35 min read

Robots now work in mixed teams: each area of a factory, a warehouse, or a laboratory has its own robot team. When an item crosses from one area to the next, the hard part is the coordination, not the motion. Someone must plan the route, pass the responsibility for the item to the next team, and confirm that the job is done. Each site builds this coordination itself, and the work grows with the fleets.

Agentic AI can take on this coordination. Agentic AI is AI that works toward a goal on its own. An AI agent uses a large language model (LLM), the type of model behind chat assistants, to read a goal in natural language. Then it plans the steps, and calls software tools that carry them out. But an agent that moves machines needs limits that a chat assistant does not need. It must act only within the authority of its team. And the proof that a step is done must come from the physical world, not from the text of another agent.

Multi-agent orchestration is the coordination of several AI agents, each with its own role, so that together they do a job that no single agent should do alone. CLI Agent Orchestrator (CAO) is an open-source tool for multi-agent orchestration. It runs a team of CLI agents: AI assistants that work in a terminal, for example Claude Code, Kiro CLI, or Codex. Each agent has its own role, its own tools, and its own credential, the key that sets what the agent can do.

In this post, you learn why physical AI needs agentic AI, and why agentic AI that moves machines needs orchestration. The first physical AI example of CAO, cross-zone transport, applies CAO to a parcel on a simulated factory floor. A supervisor agent plans the job. Two zone worker agents each move only the robots of their own zone, and an independent checker agent verifies the result. In 10 live runs, every run ended in the expected state. Custody is the responsibility for the parcel. Exactly one zone has custody at a time, so one team at a time is responsible for the parcel. Custody changed 6 times, and each time only after the simulator measured the parcel at the dock. The 3 requests that were not possible ended with no command to any robot. You also see the five criteria that a team of agents must meet on a shared floor, and how the example meets each one with CAO. Then you see what a run looks like, and how the example maps to a real site.

The simulated floor at the end of the demo. The pink parcel is on the green east cart at etch, in the east zone. The blue west cart waits at the amber dock.

Play the animation of the demo (13 seconds, repeats)

Animation of the cross-zone transport in MuJoCo. The blue west cart carries the pink parcel from stock to the amber dock. West offers custody to east, and east accepts it. Then the green east cart carries the parcel to etch, and the checker confirms the parcel at etch, owner east.

The demo: two zones. The animation replays the commands of a live run in the MuJoCo world of the example: the same robots, commands, and order. It leaves out the time that the agents use between the steps. The Results section shows an extended demo with three zones.

How CAO memory helps you and your agents keep context

· 17 min read

With Agentic context engineering, how an agent uses memory is critical in many aspects. It helps you increase code quality, be more token efficient, and keep consistency across a long-running session or session handoff.

Memory is not just giving the next session the conclusion or summary of the previous one. CAO memory saves conclusions that make the next task faster. It is more than conversation history. It can hold project decisions, user preferences, reusable instructions, document findings, and workflow lessons.

The result is closer to a scoped project wiki than a transcript archive. The identity of CAO memory is human readable markdown files. Search runs over an index backed by a SQLite database, and a knowledge graph projects the relationships between memory nodes, both in the CAO UI and in Obsidian.

CAO gives every supported agent the same memory tools. An agent can remember a fact with one CLI provider and recall it later with another. The memory belongs to CAO, not to a specific model or CLI, so your context (and code quality) survives handoffs.

This post explains how that shared layer works. For commands and configuration, see the original CAO memory reference.

Can a CAO agent show its evidence? Yes, with one profile and no code

· 13 min read
Serply
Serply Inc.

Can a CAO agent answer a research question with real evidence, meaning a citation count for every paper and a publication date for every news claim, without you writing any code? Yes. It takes one agent profile with a six-line mcpServers entry that points at a remote MCP server and passes an API key in a header. CAO resolves the key from its managed environment at launch, the provider connects to the server, and the agent gets fourteen search tools it did not have before. This post shows the result first, then how the wiring works, then the parts that did not go smoothly.

Welcome to the CAO blog

· 2 min read
CAO Maintainers
CLI Agent Orchestrator team

The reference documentation tells you what CAO does. It's a poor fit for the other half of the story — the walkthrough that takes an hour, the design decision that needs three diagrams to justify, the write-up of an orchestration that worked on real work and the two that didn't. This blog is where that goes.

Anyone who contributes to CLI Agent Orchestrator can publish here. Posts live in docusaurus/blog/ and ship through the same pull request review as the rest of the repository.