AI agents can read your site, write your code, and take real actions. Frontier Infra builds the open pieces that make that governable: a way for sites to speak to agents, discipline that keeps coding agents tied to reality, signed records of independently checked outcomes, a blueprint for long-running harnesses, 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 govern them: can an agent read a site the way its owner meant — not a scraped guess? can you inspect what was checked afterward, without taking the worker's word for it? and does the harness keep the worker honest while it works? Today many answers route through one vendor's server, boundary, and 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 enforcement patterns behind them, plus The Machine — the blueprint for agents that run long jobs under evidence — and the repo governance that lands their work safely. Each is useful alone; together they're a launch pad for agentic governance 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 binds a claim to independently checked evidence — 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. It proves record integrity and provenance; it does not make weak evidence magically true.
AAR v0.02 · spec + zero-dep verifier, public
Keep a coding agent honest — and make it prove its work before it calls it done.
Harness-neutral coding discipline + role overlays (Forge / Quill / Scout / Warden), plus a /goal contract that a conforming gate checks against ground truth — not the transcript — and signs. The contract and proof semantics are a published spec any enforcement engine can implement. A Claude Code adapter ships today; other host adapters can implement the same contract without changing the standard.
v1.1 · host-neutral spec + reference Claude adapter
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 · reference Claude adapter · ADL-L3 evidence in repo
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 ops pipeline: agents triage and prep work, then pause at a human gate.
A reusable fat-engine/thin-skill pipeline that drives fresh workers through triage → research → route → propose, pausing at one human approval gate. It is useful as a launch pad; its current conformance claim belongs in the repo evidence, not in marketing copy.
Reference impl · Python · public
The Machine's driver for code work — keeps a coding agent on task to a verified finish.
A deterministic code-work driver with durable goals, fresh workers, contract gates, budget controls, fail-closed verification, operator override, runtime-health checks, and tamper-evident receipts. Its current kit score is Machine-L2 Instrumented; L3 is blocked until live non-bypassability chaos/replay evidence is captured.
v0.1 · Machine-L2 Instrumented · L3 evidence pending
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
The implementation family for the Frontier standards: install the pieces of a governed agent harness instead of rebuilding them from scratch. Versioned code owns protocol and scoring semantics so results stay comparable across model and host updates.
· Core components on npm · MIT · public source
Choose an SDK or host adapter →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 under contracts, gates, and evidence.
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 a session's “done” against reality; and AAR records independently checked outcomes in a receipt anyone can inspect. The Machine is the blueprint for stringing those into agents that run reliably over long jobs — Conductor and machine-driver are working examples, and the Maintainer Gate Blueprint governs the repo their work ships through. Builder tools like Roundtable are optional instruments you run while building. 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.
The public specs, reference code, and tools are published in the Frontier Infra GitHub organization with repository-level license files and notices. Do not rely on a homepage sentence for licensing; use the license in the repository you are copying from. These sites are built to our own AVL standard, so they're also working demos.
Want to score an existing harness and produce checkable evidence? Start with the Frontier SDK and its Codex adapter on the SDK & plugins page. Publishing a site and want agents to read it right? Start with AVL (agentviewlayer.org). Running agents and need portable outcome records? 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.