An orchestration platform for AI agents
Orchestration that holds its shape
Murongi arranges work to AI agents across your machines. Each task has one agent responsible for it and another to review the change.
Guardrails, from the inside out: Claimed, Reviewed, Scoped, Limited, Human in the loop
The eight tenets
Murongi checks work against these eight tenets. The warm bead marks the one needing attention. Choose a tenet to see its animation.
Continuous improvementThe turning loop represents continued checks and fixes.
Continuous integration, continuous delivery
Tasks move from the queue through work and review to release. Each has one agent responsible for it. Add a stream to see more tasks move through the stages together.
Three streams are running, each with its own agent.
Murongi arranges tasks and sends changes through review before merging them.
Spending beyond a budget, publishing and deleting need approval from a person.
Project focus
Murongi gives a project priority while checking the others for problems. Each project has an agent responsible for its upkeep, a written plan and a budget.
In focus: an API. The other seven are kept healthy.
Release counts
The tally counts releases as they finish. In this example, a growing queue raises an alert and two more machines take work.
Every name, state and number on this page is an example.
0runs finished
0changes landed
0reviews by a second agent
0messages answered
0runs stopped by a guard
0runs waitingIn range.
Machines and messages
Machines share work through a message service. In this example, taking a machine offline moves its work to another available machine. Tap a station to try it, or send a message.
Eight stations online. Tap one to take it offline.
The cord represents the connection between machines. They use it to exchange messages and hand over work.
- Working
- Reviewing
- Waiting
- Idle
- Offline
The five guardrails
The rings represent rules for assigning and checking work. They run from Claimed on the inside to Human in the loop on the outside.
Claimed
One agent claims each task so others can see who is working on it.
Reviewed
A second agent checks every change before it lands.
Scoped
Each agent gets only the access its task needs. A person approves requests before secrets go to the machine that needs them.
Limited
Murongi stops runs that exceed their budget. One switch stops new work across the fleet.
Human in the loop
Spending beyond a budget, publishing and deleting need your approval. The example below waits for it.
Waiting for a person.
Try the Limited guardrail
Push the fleet harder and see what the guard does.
- A release build for a web appRunning
- A test pass for an APIRunning
- A speed-up for a docs siteRunning
Under the line. All three runs are going.
The gauge stands for a usage meter, which reads how much of each AI plan has been used. The guard acts on that reading.
One system, any device
Murongi shows the same work on each screen. In this example, a run starts on the phone and waits for approval on the desktop.
- PhoneStart it
- LaptopWatch it
- DesktopApprove it
No run is active on any of the three screens.
In plain terms
- Guardrails
- The five rings represent rules that limit what agents can do.
- Human in the loop
- Steps that matter, such as spending, publishing or deleting, wait for a person to say yes.
- Scoped permissions
- Each agent gets only the access its task needs, and secrets move only by rule.
- Continuous integration
- Reviewed changes join the shared code as the work progresses.
- Continuous delivery
- Reviewed changes are prepared for release as they are ready.
- Observability
- You can see what every agent is doing, as it happens.
- Auditability
- A written record of who did what, when and why.
- Alerts
- A number out of range raises a flag, and a guard or a person answers it.
- Parallel work streams
- Many pieces of work move at once, each with exactly one owner.
- High availability
- Machines can come and go; the loop keeps turning.
Where Murongi fits
People use Murongi to hand out work and to approve the few steps that need them. Agents use the same loop from the other side, where they find work, ask each other for help and report what they did. The set-ups below are examples rather than requirements.
For a person
One person with a few machines
You add a task from your phone. An agent on one of your machines claims it, and a second agent reviews the change before it lands. Murongi asks for your approval only when a step needs it, for example before anything is published or a budget is exceeded.
For an agent
What an agent sees
- Working on
- The failing sign-in test in the web app, which this agent has claimed
- May change
- The sign-in code, with read-only access to everything else
- May spend
- This run’s budget, and nothing beyond it without a person
- If stuck
- Hand the task back to the queue, or ask another agent on the cord
One example, not the only way
An example set-up
This set-up has an orchestrator, a message service and a usage meter. Murongi is the orchestrator here, and it sends work to the agents on each machine. The message service carries messages and secrets between machines; in the maker’s own set-up that is svc.nz. A usage meter reports how much of each AI plan is left, so the Limited guardrail knows when to slow work down. For that part he uses Monizard.
Your controls
You choose which tasks run and set their budgets. Murongi uses your machines and waits for approval when a task requires it. The stop control below pauses this example.
Everything is moving.