AI agents can read your site, write your code, and take real actions. Frontier Infra builds the open pieces that make that trustworthy: a way for sites to speak to agents, discipline that keeps coding agents honest, signed proof of what an agent actually did, a blueprint for running agents for days unattended, and the gates their work ships through. Every piece works alone. Together they fit — and no single company owns the picture.
As agents start doing real work online, three plain questions decide whether you can trust them: can an agent read a site the way its owner meant — not a scraped guess? can you prove what it actually did, afterward, without taking its word for it? and does it stay honest while it works? Today the companies answering these own the answer — you depend on their server, their boundary, their say-so.
Frontier Infra answers them as open standards instead — portable, checkable with a public key, owned by whoever publishes the site or signs the record, not a central server. Three standards (declare, prove, behave) with real enforcement behind them, plus The Machine — the blueprint for agents that run for days on their own — and the repo governance that lands their work safely. Each is useful alone; together they're the foundation of an agent web no single company controls.
Three families, one system: open standards for how an agent reads, proves, and behaves on the web — with the enforcement that makes the rules real; The Machine, the blueprint for running agents like that over long jobs, plus the repo governance that lands their work safely; and Builder tools you run while building with frontier models.
Three open standards for letting agents use the web safely — declare, prove, behave — plus the enforcement engine that makes “behave” stick. Each stands alone; together they compose.
Make a website agents can read on purpose — so they act on what you meant, not a scraped guess.
A site emits a text/agent-view companion for each page so AI agents read intent, state, and actions directly — no scraping, no guessing.
Spec + validator · live at agentviewlayer.org
A receipt that proves what an agent actually did — checkable by anyone, owned by no vendor.
The Agent Attestation Record binds an agent's claim to an independently-verified, evidence-committed verdict — checkable with a public key, no central server.
AAR v0.02 · spec + zero-dep verifier, public
Keep a coding agent honest — and make it prove its work before it calls it done.
Universal coding discipline + role overlays (Forge / Quill / Scout / Warden), plus a /goal contract that Warden checks against ground truth — not the transcript — and signs. The contract & proof semantics are a published spec any enforcement engine can implement; Proctor (below) is the machine-level one. Ships for Claude Code today; Grok, Codex CLI, and Pi engines are the roadmap.
v1.1 · spec + per-project Warden gate · Claude Code today
The gate that won't let a coding agent say “done” until reality agrees — installed once, supervising every session.
Proctor reads what the agent's tools actually did — never what the agent says — witnessing failing tests, errors, and stubs as they happen, and blocks the session from ending until the contract's checks pass against reality or a human signs off. Genuinely human calls land in an operator inbox; every block path is bounded and loud, never silent. Conforms to ADL's contract & proof spec.
Live · Claude Code · L3 Enforced
A blueprint (and working code) for agents that run real work for days on their own — the reference drivers that prove it runs, and the repo governance that agent-driven work ships through.
The blueprint for AI agents that run real work for days without going off the rails.
A contract up front, a dumb driver that never sleeps, fresh disposable workers, verification against reality (never self-grading), and an autonomy dial you earn. A published standard with an executable kit that scores any deployment from its code, not its claims.
Spec + conformance kit · public
A ready-to-adapt example of The Machine: agents that triage and prep work on their own, then pause at a single human yes/no.
A deterministic, token-free control loop that drives fresh workers through triage → verify → propose, pausing at one human approval gate. The reference ops driver of The Machine.
Reference impl · Python · public
The Machine's driver for code work — keeps a coding agent on task to a verified finish.
A ~160-line, zero-token, deterministic loop that drives long-running code work to a verified definition of done: contract-gated, budget-governed, fail-closed, with tamper-evident receipts. Conductor's shape, pointed at repos.
v0.1 · L3 Enforced · public
The operating model for a repo where AI agents work in parallel — so the right work merges and regressions don't.
An installer stamps any repo with patrol loops, PR quality gates, machine-checkable handoff packets, and two deterministic guards — a prod-database gate and a tenant-isolation CI check — that enforce policy whether or not the agent reads a runbook. Nothing lands on main on an agent's word alone.
v1.0.0 · installer + 10 runbooks + gates · public
Sharp instruments you run while building with frontier models — not standards, just tools.
Ask many frontier models at once and get one decided answer — a cross-model gut-check before a call you can't easily undo.
Fan a question to Grok, Codex/OpenAI, GLM, MiniMax, Claude, and Gemini in parallel — advisory, or a chaired deliberation to consensus. Ships as a CLI, an MCP server any harness can call, a one-command installer, and a Claude Code plugin.
v0.1.0 · CLI + MCP + Claude Code plugin · live at roundtable.sh
Open standards and tools for letting AI agents use the web safely — without any one company owning the controls. Three standards (AVL, AAR, ADL) plus The Machine, a blueprint for agents that run real work on their own. Everything is free and MIT-licensed at github.com/frontier-infra.
Three families, covering the lifecycle of an agent doing real work. The standards: AVL lets a site declare itself so agents read it the way you meant; the Agent Discipline Layer (ADL) keeps a coding agent honest while it works — with Proctor as its machine-level enforcement engine, gating every session's “done” against reality; and AAR proves what an agent actually did, afterward, with a receipt anyone can check. The Machine is the blueprint for stringing those into agents that run reliably for days — Conductor and machine-driver are working examples, and the Maintainer Gate Blueprint governs the repo their work ships through: patrol loops, PR quality gates, and deterministic guards. And the Builder tools are sharp instruments you run while building — Roundtable convenes a council of frontier models (Grok, Codex/OpenAI, GLM, MiniMax, Claude, Gemini) for a cross-model gut-check before a decision you can't easily undo. Each piece is useful on its own.
Most agent infrastructure routes trust through one vendor's servers — leave, and the proof of what your agents did can leave with you. Frontier Infra's standards are checkable with a public key tied to your own domain, so whoever publishes a site or signs a record stays in control, and the proof holds even outside any one vendor. They work alongside the login and permission tools you already use, not instead of them.
Yes — the specs, the reference code, and the tools are MIT-licensed at github.com/frontier-infra. These sites are even built to our own AVL standard, so they're their own working demo.
Publishing a site and want agents to read it right? Start with AVL (agentviewlayer.org). Running agents and need provable outcomes? Start with AAR (agentscontrolplane.org). Building with a coding agent? Install the Agent Discipline Layer (ADL) in the repo and Proctor on the machine — same contract, enforced at both altitudes. Running AI agents against a real codebase in parallel? Stamp the Maintainer Gate Blueprint into the repo. Want the big picture of agents that run on their own? Read The Machine.