Inside your walls
Moji runs on your own machine or private network, inside your security boundary.
The control runtime under every Moji swarm
Moji scopes each agent to a step, checks every output as the step completes and recovers the failed step with the rest of the work intact.
We wrote this page for engineers, researchers and the coding agents that work with them. Read it as Markdown.
- Cost so far
- $0.00
- Checks
- none yet
- Attempt
- 1
The job is waiting for an agent.
Deterministic control around every agent.
Agents make their own choices inside a step. Moji moves the job between steps only by the rules in your swarm file, which name the agent for each step, what counts as done and what happens when a step fails.
- id: implement from: [backlog] to: implemented lanes: - {agent: claude, weight: 50} - {agent: codex, weight: 50} retry: {max_attempts: 2} - id: test from: [implemented] to: tested performer: {kind: ci, workflow: test.yml} - id: review from: [tested] to: reviewed parallel: branches: [claude, codex] merge: claude gate: when: "result.metrics.score >= 70" on_reject: {to: implemented, reason: "fix review comments"}
lanes:Moji splits this step between Claude and Codex by weight.parallel:Two reviewers work side by side, and a merge step combines their verdicts.gate:A score below 70 sends the job back to Implement with the review comments.
A job keeps the version of the swarm it started on, and Moji can rewind it to any step it passed.
Monitoring, runtime and budget in one system.
Moji keeps each job’s state, cost, checks and attempts with the job at every step. Because the job carries its own state, Moji can send it back for a fix or redo one failed step without losing the rest of the work.
Moji prices every step before your agents start.
Moji prices each step from jobs it has measured and adds the step prices into a budget for the whole job. You commit that budget before the job starts, and the report shows how many jobs finished inside it.
- Moji counts each step’s reported usage against the budget and starts no step that would cross it. Steps already running finish, and new work waits until you raise the budget.
- Each swarm also has a daily budget, such as $60 a night for a security swarm, and every job’s spend counts toward it.
- Each step has a time limit in your swarm file, and Moji treats a step that runs past it as a failed step.
- Further reading: Inference is part of the job cost and The bill should follow the work.
- Implement$2.10 to $3.40
- Test$0.20 to $0.30
- Review, two agents$3.10 to $4.60
- Merge$0.10 to $0.20
When a step fails, Moji redoes only that step.
Moji checks each step’s output as soon as the step finishes. Moji retries a failed step in place or sends it to the repair step your swarm names, and work that depends on it waits until the fix passes.
- If a worker machine stops during a step, Moji hands that step to another worker and keeps every earlier step.
- If Moji itself restarts, every job resumes from its last finished step, because Moji records each change on disk as it happens.
- When Moji cannot tell whether a step already changed something outside Moji, such as a deployed service, Moji pauses the job for a named person.
The retry added $1.01, and the job kept everything it had done before the failure.
Your team defines what good output means.
Checks live in your repository beside the swarm, as rules on a step’s result, a score from a separate reviewing agent, files that must exist, your own CI tests or a named person’s approval. You switch on Autopilot once the report shows the swarm meeting your thresholds.
- First-pass yieldJobs finished correctly with no human help86%target 80%
- Budget reliabilityJobs delivered inside their budget98%target 95%
- Exception rateJobs that needed a person, and at which step7%limit 10%
- Time to finish19 in 20 jobs finish within this time38 minlimit 45 min
Moji keeps slow steps from holding up the job.
Moji runs independent steps side by side, and a failure costs you one step’s time because Moji redoes only that step. When every agent is busy, Moji suggests how many more agents would clear the queue.
Every agent is busy and nine jobs are waiting. Two more agents would clear the queue by 16:40.
Every step is on the record with who did it.
Moji writes each step’s result, attempts, cost and approvals to an append-only event log, with the names of the files each agent read and the tools it used. You can replay the day to any moment, search who did what and export it.
- Moji sends the same traces into your own tools through OpenTelemetry.
- You watch an agent’s progress live while its step runs.
- Moji records the person and the tool behind every change to a swarm.
- Implement · Codexpassed$2.31
- Test · CIfailed$0.18
Read
src/export/csv.ts,test/export.test.tsRan
npm test -- export, 2 of 41 tests failedSent back to Implement with the failing output
- Implement · attempt 2passed$0.84
- Test · CIpassed$0.17
- Review · approved by youreleased$1.92
Your code and your agent logins stay on your machines.
Moji runs inside your own security boundary, so your SOC 2 and vendor reviews stay simple.
Your own logins
Your agents work under their own Claude or Codex logins, and you enter no model key in Moji.
No keys for agents
Moji gives agents no GitHub or cloud credentials, and Moji keeps an append-only log of who accessed what.
Moji makes the decisions while the job runs.
Your gateway, tracing tools and agents each see one call or one session. Moji sees the whole job, so it can stop a job at its budget and redo one failed step with the rest intact. You keep your agents and tools, and Moji sends its traces into them through OpenTelemetry.
| Kind of tool | Priced before it starts | Checked at every step | One failed step redone, the rest kept | Sent back when a check fails | Stops new work at the budget |
|---|---|---|---|---|---|
| Gateways and routers | No | No | No | No | Yes |
| Tracing and evals | No | In part | No | No | No |
| Durable workflow engines | No | No | Yes | In part | No |
| Agent platforms | No | In part | No | No | In part |
| Moji | Yes | Yes | Yes | Yes | Yes |
YesIn partNo
How does Moji work with a durable workflow engine?
A durable workflow engine replays code you write against its SDK, so a job survives a crash. Moji runs the Claude Code and Codex agents you already use from a swarm file in your repository, and Moji also prices each job, checks each output and stops new work at your budget.
Do I keep my tracing and eval tools?
Yes. Moji sends every step to them as OpenTelemetry traces, and Moji acts on the job while it runs.
How is this different from a gateway or a model router?
A gateway or model router works at the request boundary and may choose a model for one call. Moji works across the whole multi-step job, and it keeps the job’s budget, checks, recovery state and record together while the job runs.
How is this different from an agent platform?
An agent platform hosts agents you build on it, and permissions what an agent may use and spend before it acts. Moji runs the agents you already use on your own machines and controls the work while it moves. Moji checks every step, fixes failures in place and keeps the job within its budget.
How is this different from a provider’s own agent platform?
Provider harnesses run one lab’s agents on one lab’s models. Moji runs Claude and Codex agents side by side under your own logins, with the same checks, recovery and budget across both.
How is this different from an open-source agent harness?
A harness runs one person’s agents in one session. Moji runs many agents across many workflows for a team, with checks on every step, recovery in place, a spending cap and one record for each job. Your agents keep their own harness, and Moji runs the workflow around them.