How OwnCharter works

One action, end to end: the intent, the gate that denies before execution, the signed capability behind it, and the record it all lands on.

The Gate

INTENT   export customer table to external endpoint
GATE     no capability: denied before execution
INTENT   update CRM record: mark invoice 1042 paid
GATE     capability granted: crm.write
RESULT   done. hash-chained to the permanent record.

The first thing the Gate does on this page is say no. The export intent had no granted capability, so it was denied before execution: not caught in review, not flagged in a dashboard after the data was already gone. Every action an agent takes passes through this one chokepoint, and the chokepoint fails closed. Not granted means denied. Not verified means denied. Errored means denied. Tools that watch agents and report afterward are selling you a trace of the disaster, and a trace of the disaster is not a gate in front of it. Prevention, not detection. The rest of this page walks those two intents through the whole machine.

The intent layer

Both intents in that transcript are plain business language, and that is deliberate. You describe work in the terms the business already uses: update the CRM record, issue the refund, send the renewal notice. Workflows are written against these intents, never against a vendor API. Swap the CRM, swap the model, swap the whole vendor underneath, and the intents do not move; only the tooling behind them is retooled. That cuts both ways on purpose: it is what makes a vendor swap a retooling instead of a rewrite, and it is what makes leaving a supported operation. A platform that governs your agents has no business holding your workflows hostage.

Where capability comes from

crm.write did not come from nowhere, and it did not come from the agent. Only the operator grants capability: a human decision, every time. Capabilities ship as signed packs and are verified against a pinned root before the Gate will honor them; unsigned, unverified, or tampered gets the same fail-closed answer as everything else. And the grant moves in one direction only. An agent cannot grant itself a capability, cannot widen one it already holds, and cannot reach the mechanism that decides, because the gate is not writable by the thing it gates. A signature alone is a badge you take on faith. A signature checked at a fail-closed gate is a control.

The permanent record

Both decisions in that transcript, the allow and the deny alike, landed in the same place: a permanent record, written after the Gate ruled and never before. Authorized before, recorded after. The record is hash-chained: each entry folds the hash of the entry before it into its own, so the chain is tamper-evident by construction. Rewrite one entry and its hash stops matching, and every entry after it inherits the break. Most audit trails are log files that whoever holds root can quietly edit into a nicer story. This one cannot tell a nicer story. Try to make it lie.

Try to break it

Rewrite one entry. Watch the chain tell on you.

Below is a slice of the record: four Gate decisions, each entry's hash folded into the next. This time you are not the operator, you are the intruder. Rewrite an entry, the way an agent covering its tracks would, and watch every hash downstream of the edit fail verification.

A slice of the record

Tap any entry to rewrite it.

Chain intact. Every entry folds the hash of the one before it into its own, so every hash verifies.

An honest simulation: the hash in this demo is a toy, kept short so you can read it. The construction is the real invariant. The production record chains entries exactly this way, and breaks exactly this way when touched.

Running it: deployment and the Control Information Center

One governed agent is a machine. Fifty are an operation. A deployed agent is wired into a business's real tools through the capabilities it was granted, and deployment is the start of the job, not the end of it: packs get rebuilt, grants get revoked, tools get swapped underneath standing intents. All of it reports into the Control Information Center, the operator's single pane and the piece of the machine being built in the open right now: order lifecycle from request to signed delivery, fleet health, and the hash-chained record behind every agent, in one place. A business running one agent sees its own. An operator running fifty sees all fifty. Same pane, same rules, same Gate under every one of them.

Built in the open, heading for early alpha

Fair question by now: is this real? The invariants hold today, exactly as this page walked them. The Gate fails closed, capability comes only from the operator, packs verify against a pinned root, the record is hash-chained, and the founder runs his own agent operation on that construction while he builds it. The rest, the fleet-scale Control Information Center included, is roadmap and is stated as roadmap: OwnCharter is being built in the open, heading for early alpha, with the build record public, commits and mistakes included. The early cohort gets the machine while the decisions are still being made, and gets a say in them. If you want it shaped around your workload instead of someone else's, this is the window.

Request early access