Atested sits in front of governed AI operations. Every action is evaluated against the same logic a well-informed engineer would apply — then the evaluation and the decision are signed and provable.
The core flow is simple. An AI tool routes an action through Atested. Atested evaluates it against verifiable conditions — the scope, evidence, and constraints that any well-informed engineer would require. If the conditions are met, the action proceeds and the decision is recorded. If not, the action is denied and that denial is recorded too.
{
"tool": "fs_write",
"capability_class": "FS_WRITE",
"policy_decision": "ALLOW",
"timestamp_utc": "2026-03-30T13:12:00Z",
"operator_intent": "update README",
"organization_id": "acme-engineering",
"record_hash": "sha256:0a1b2c3d4e5f...",
"prev_record_hash": "sha256:f0e1d2c3b4a5...",
"signature": "ed25519:8f9c2ab1..."
}
Atested does not just log actions after the fact. It evaluates governed actions before they proceed. ALLOW means the action met the verifiable conditions — the evidence was sufficient, the scope was valid, the constraints were satisfied. DENY means something was missing, and the record shows exactly what.
A coding agent writes inside an approved project path using an allowed tool and the required execution context. The path resolves to a real location, the agent is authenticated, the scope is valid. Every condition is verifiable — no opinion required.
An agent tries to write outside the approved workspace, delete a production config, or modify the CI pipeline without authority. Something verifiable is missing — the record shows exactly what.
A battle-tested deployment script can't produce the evidence Atested requires — it's opaque to evaluation. An engineer grants a scoped approval pinned to the exact content hash. The script runs. The engineer's judgment is on the record alongside the deterministic decisions.
The same opaque script runs without an approval. Atested can't evaluate it deterministically and no engineer has vouched for it. The action is blocked, and the record shows it was flagged as requiring judgment — not that it failed a condition.
Atested governs every action routed through it. AI tools also have native capabilities outside governance — that's a structural reality. Atested makes the boundary visible: governed operations get full signed records, ungoverned operations are counted through observation hooks. You see exactly how much of your AI activity is actually under governance.
{
"governed_operations": 1842,
"observed_native_operations": 716,
"transparency_ratio": "72%",
"observation_mode": "hook-reported",
"manager_view": "governed vs observed"
}
Most governance systems rely on people deciding whether each action was appropriate. That doesn't scale, and it's inconsistent. Atested replaces opinion with verification: either the evidence is present or it isn't, either the scope is valid or it isn't. The result is governance you can check independently — not governance you have to trust someone's judgment about.
Your team has a deployment script that's been running for years. Battle-tested, reliable — but opaque to Atested's evaluation. It keeps getting DENY because it can't produce the evidence Atested requires.
You know this code is safe. You wrote it, you maintain it, it runs every day. So you grant a scoped approval: pinned to the exact content hash, the deployment context, and the current governance version. The script runs. If someone changes one line, the hash changes, and the approval expires automatically. Your judgment is on the record — signed alongside the deterministic decisions.
Approvals aren't blanket exceptions. They're pinned to a specific artifact at a specific hash. Change the artifact and the approval is gone. Grant or revoke — both are recorded in the governance chain. The system is honest about what it can prove and what required your judgment.
The Atested Dashboard gives your team a live view of governance activity, decisions, approvals, audit results, and system health — all backed by the same signed chain the governance engine produces.
No. Atested's governance logic reflects the conditions any well-informed engineer would apply. You configure scope and constraints for your environment, but the evaluation logic is built in. Most decisions are resolved deterministically without any rules to write.
If an AI agent requests to write a file, a well-informed engineer would check: is the target path within the project workspace? Is the agent authenticated? Has the action been requested through a governed channel? These aren't matters of opinion — they're verifiable conditions with definitive answers. Atested checks them the same way, every time.
We know because these are the same checks any careful engineer performs manually — Atested just performs them consistently, at scale, and signs the result.
The dashboard Configuration tab lets you view and edit the capability registry — the file that defines what every governed tool is allowed to do. No more manual JSON editing.
View mode is available to everyone. You can see every governed tool's allowed directories, constraint flags, and hard caps — plus the registry integrity hash that proves the configuration hasn't been tampered with.
Edit mode requires your license key. Add or remove directories, toggle constraints, and adjust caps. Every change goes through the governed reload process — schema-validated, hash-recorded, and integrity-protected.
Trial users can view the full configuration and make limited changes (up to 3 directories, basic toggles). Full editing requires an active license.
Registry Integrity Hash: sha256:a4e122f7... Status: OK Tools: 14 FS_WRITE HIGH Directories: project/, gov_runtime/ Deny hidden: yes Deny overwrite: yes Deny executable: yes FS_READ MEDIUM Directories: project/, gov_runtime/ Max bytes: 65536 Deny hidden: yes FS_DELETE HIGH Directories: project/, gov_runtime/ Recursive: no [Unlock Editing] requires license key
An AI agent overwrites a production config. Deletes the wrong file. Sends a message to the wrong channel. Everyone asks: "why wasn't this prevented?" That's the real pain — not reconstruction after the fact, but seemingly avoidable errors that AI causes in operations.
Atested is the guardrail. It stops many bad actions before they land — wrong path, missing authority, insufficient evidence. The audit trail is a side benefit. Prevent first. Prove second.