Agentic orchestration
you can hold to account.
Inflara coordinates real coding agents — Codex, Claude Code, Antigravity — on your own machine, inside your own git history, with verification-gated success, typed failures, hard budgets, and an audit trail for every decision. This page explains how it works and which engineering practices it is built on. The complete setup and operating guide now lives in one dedicated place.
The system
A control plane for agents, a data plane on your machine.
Inflara splits orchestration the way infrastructure does. The server holds the plan: projects, tasks, workflow graphs, run state, and structured evidence. The runner on your machine holds the work: it spawns real agent CLIs in isolated git worktrees, streams bounded events back, and keeps your source code local. A supervisor agent sits between them, turning goals into validated workflow graphs through the Inflara MCP server — the same typed action layer any MCP client can use.
The run lifecycle: plan → scope → dispatch → execute → verify → learn.
White paper · Part I
Ten practices the industry converged on.
Inflara ships them as engine guarantees.
The last two years of agent research settled a few hard lessons: use the simplest workflow pattern that fits, feed agents bounded context, verify instead of trusting, budget everything, and keep humans on irreversible decisions. Most stacks leave these as advice. Inflara implements them as runtime behavior.
Scope before you orchestrate
Workflow patterns, not improvised graphs
Every dispatch is classified first — task class, blast radius, ambiguity, production and external-action risk, budget tier — and mapped onto five named primitives: Single Worker, Planner-Implementer, Planner Vote-Synthesizer, Evaluator-Optimizer, and Orchestrator-Workers. The supervisor adopts a named template or states why it deviated. A bigger team is never a substitute for missing evidence.
Deterministic context first
Bounded retrieval over whole-repo scans
Before an agent reads a single file, the runner builds a compact, ranked repo map — exported symbols, import fan-in, change hotspots, test ownership — cached by commit and injected into every worktree. Agents are instructed map-first: consult the map, fetch only what the task justifies. Semantic search exists but stays opt-in until telemetry proves the deterministic layer misses.
Artifacts, not chat transcripts
Typed handoffs as the coordination substrate
Workers end every step with a machine-parsed emission: keyed artifacts, decisions, risks, blockers, a 0-100 confidence score, retrieval provenance, and failing-test identity. Large outputs go to a per-run exchange directory and travel by file path. Downstream steps route on structured fields — summaries are for humans, artifacts are for the engine.
Verification-gated success
Evaluator-optimizer as an engine invariant
Verify loops make “done” mean “verified”: a tester reports failures only and emits a machine-readable fix plan, a fixer applies exactly that plan, and the same gate re-runs. With requireStopFlag set, the done branch is only reachable through the passing test gate — exhausting the budget fails the run loudly with the final fix plan preserved. Not a prompt convention; a runtime guarantee.
Typed failures, owned repairs
Failure taxonomy with escalation ladders
One shared classifier types every failure — environment, retrieval gap, test failure, merge conflict, timeout, budget, permission, scope, contract violation, logic — and names the repair owner: re-run the original step with fix context, hand to a recovery agent, reroute via the supervisor, or stop for the user. Repeated identical failure signatures escalate instead of burning retries. Environment and permission failures never waste code-fix attempts.
Bounded autonomy
Hard budget envelopes with typed codes
Every run carries an enforced budget: node runs, agent spawns, total recovery attempts, wall-clock minutes. Overruns fail with structured codes, never silent truncation. Diffs that exceed the changed-file budget escalate for review while the run continues. Honest split: what the engine can enforce is hard; what it can only observe is metered and reported.
Memory that compounds
Four layers, each in its right home
Procedural and semantic memory live in the repo (AGENTS.md, charter, architecture, ADRs) where every CLI reads them natively. Episodic memory distills each terminal run — outcome, failure classes, failing tests, key decisions — and the next dispatch retrieves the relevant episodes under a strict byte cap. Working memory is the run's own artifact trail.
Routing that stays explainable
Benchmark priors + verified outcome calibration
Agent and model selection starts from editable benchmark priors. Verified outcomes calibrate comparable task strata only after 20 samples, using conservative lower credible bounds while cost and latency stay separate. Sparse evidence remains shadow-only, and manual pools always win.
Evaluate everything
A local eval flywheel
Replayable eval specs run real agent CLIs in scratch git worktrees at a pinned ref — your working tree is never touched — with deterministic success checks and trend reports (improved / steady / regressed). Orchestration changes get measured, not vibed.
Humans stay in command
Least privilege plus explicit gates
Per-tool MCP scopes, sandboxed execution tiers per agent, and a local-git-only policy — no push, no PR, no deploy without explicit authorization. Approval requests, supervisor-answers-first question routing, pause/resume, and manual gates keep irreversible decisions with people.
White paper · Part II
How Inflara differs from agent frameworks.
Agent frameworks give you excellent primitives for wiring LLM calls — and leave the harness, the isolation, the verification, the budgets, and the audit trail as your problem. Automation platforms chain SaaS steps but have no concept of code. Inflara is a third thing: an orchestration product for real coding agents, attached to real project management, running on your own hardware.
| Dimension | Agent frameworks (LangGraph, CrewAI, AutoGen) | Automation platforms | Inflara |
|---|---|---|---|
| Unit of execution | LLM API calls you wire together in code | SaaS actions and webhooks | Full coding-agent CLIs (Codex, Claude Code, Antigravity) with their native tools |
| Where code lives | Wherever your harness runs; often cloud | In the vendor cloud | On your machine. The server orchestrates; it never sees your repo — only bounded artifacts |
| Isolation | Build it yourself | None (no code concept) | A git worktree per run, branch merge plans, changed-file evidence on every step |
| Definition of done | Whatever your loop decides | The step ran | A passing test gate — verify loops make unverified success unreachable |
| Failure handling | try/except and custom retries | Retry the step | Typed failure classes with named repair owners and escalation ladders |
| Cost control | Token counters you add | Per-task pricing | Hard engine-enforced budget envelopes with structured overrun codes |
| Learning loop | DIY | None | Episodic memory, damped routing posteriors, and a local eval harness |
| Project management | Out of scope | Separate tool | Native — tasks, milestones, and calendars are the dispatch surface |
Your source never leaves your machine. The orchestration server receives bounded, size-capped artifacts — summaries, handoffs, changed-file lists — not your repository. That is a deployment property, not a policy promise.
Budgets that can’t be enforced are metered and labeled soft, never faked. Overruns produce typed codes, not silent truncation. Failed runs say why, name the repair owner, and preserve the evidence.
Setup and operation
One guide, from install to verified run.
Runner installation, background services, updates, optional configuration, and AI Agent Center orchestration are now organized in a single walkthrough.
Open the getting started guideOrchestrate agents you can audit.
Plan the work, dispatch the agents, and hold every run to a passing test gate — without your code ever leaving your machine.