BUILD · THE GOVERNED COPILOT · HOW IT WORKS

Safety lives in the platform, not in the prompt.

The model can only propose. Every action is a typed tool on one governed gateway, and anything that would publish, delete or change a setting waits for a person's click, which the platform checks before it lets anything run. This page describes the gate as it behaves, step by step, as of October 2026.

On this pageThe mechanics
  1. The mechanics
  2. The rule
  3. One action, start to finish
  4. Plan, then apply
  5. The grant
  6. Risk classes
  7. Registration
  8. The only yes
  9. What pauses
  10. Where the chat and the screen differ
  11. Schedules and experiments
  12. Undo
  13. What it refuses
  14. The model
  15. The record
  16. What keeps it safe
  17. Common questions

The mechanics

The rule

  • "The model proposes; the platform authorizes." The AI model can only choose an action and fill in its inputs. Every action is a typed tool, registered on one governed gateway.
  • The checks that matter, who you are, what the request may do, and whether it needs your approval, live in that gateway. None of them depends on what the model was told.
  • The Composer's gestures travel the same gateway, with the same tools, so a person on the canvas and the copilot in the chat are governed by one set of rules.

One action, start to finish

  1. Propose.

    The model picks a tool your role holds and fills in its input.

  2. Plan.

    The gateway checks your rights, validates the input, dry-runs the tool and lists what would change. Nothing has changed yet.

  3. Show the card.

    If the tool is gated, a card says what will happen, whether it can be undone, and sometimes the values before and after.

  4. Click.

    Your approval creates a grant, bound to that exact request.

  5. Apply.

    The gateway checks the grant and runs the tool, or refuses if anything has drifted.

  6. Return the receipt.

    The result, and its undo where the tool has one.

  7. Record.

    Each phase is written down with a plain sentence.

Plan, then apply

  • Planning checks rights, validates the input, dry-runs the tool and builds a diff of what would change. The gateway's own description of it: "Mutates NOTHING".
  • Applying happens only after approval, and only against the grant that approval created.

The grant

What your click creates.

A grant that binds five things: the tool, the exact input, a fingerprint of the tool's contract, you, and a fingerprint of the target's state when the card was drawn.

How long it lasts.

Five minutes, and it is used once.

What it refuses.

If the tool or the target changed after the card was drawn, the change is refused rather than applied to something you did not see.

Who holds it.

The server, never the browser and never the model.

Risk classes

Every tool declares one of five classes. The class decides whether a card is required and how long an undo stays open.

Class (the gateway’s own name) A card before it runsIts undo stays open for
read never needed: it changes nothing nothing to undo
draft-write when the tool declares one 7 days
dangerous-write required: it cannot register without one 24 hours
admin required: it cannot register without one 1 hour
external required: it cannot register without one 15 minutes

A tool may shorten its undo window, never extend it.

Registration

  • The gateway refuses to register a dangerous-write, admin or external tool that declares no approval.
  • It refuses a gated tool that cannot fingerprint its target, because a grant would then have nothing to bind to.
  • It refuses a card that promises an undo the tool does not have, and a tool that cannot describe its own consequence.
  • So a risky tool cannot reach the copilot at all without its gate. The rule is checked when a tool is registered, before any model ever asks for it.

The only yes

  • The copilot's own default answer to every card is "deny".
  • Approval arrives through one door only, the approve route, and it is checked against the same signed-in person who saw the card.
  • Two enforced checks in our build fail if an automatic approval ever appears on a live path.
  • Saying no changes nothing, and the copilot says so: "Okay, I didn't" and the act it was asked to do. A card left waiting, or a closed tab, also counts as no.

What pauses

  • Publish and unpublish, every delete, schema and settings changes, the bot and AI-crawler policy, user and team changes, the consent policy, capture switches, exports, erasure, store and order acts, and more.
  • About 190 of the more than 370 tools a site's team can use, as of October 2026.

Where the chat and the screen differ

  • In the chat, five more acts wait for your approval: attaching media, discarding changes, setting who can read a page, and adding or removing a package's content. On their own screens, your own click is the decision.
  • On EmDash's own screens, your click is the decision, as EmDash designed it. The gate governs what the copilot does there for you.

Schedules and experiments

  • You approve a scheduled publish once, for its exact time. Edit the page in the Composer before then, and the schedule is cancelled.
  • A variation of an experiment reaches visitors only through the experiment's own approval-gated activation. An edit to a live experiment's version waits for your approval too.

Undo

  • A change that can be reversed returns a single-use undo grant, open for the window of its class.
  • Redeeming it runs the same governed steps as the change. If something newer has changed the same thing since, the old undo refuses rather than overwrite it.
  • Three doors share one implementation: the "Undo" button and "undo that"; an undo that visitors would see, which first shows its own card, "Undo this change?"; and our operators' own.
  • Undoing a page's first publish takes the page offline. Undoing a later publish puts the earlier version back.
  • Before you approve, the card tells you whether the change can be undone.
  • One-click undo on every change. Coming soon.

What it refuses

New powers for a plugin.

The copilot never accepts a plugin's request for them.

Secrets in the chat.

No copilot tool takes a Stripe key, a WordPress password or a plugin secret; two-factor, SCIM and billing open in your browser instead.

Made-up IDs and links.

The model never mints them.

Embeds.

Only a person can place one.

Pages someone else has open.

It never writes over them.

Tools beyond your role.

It never sees them. A room you switch off for your site is closed to it too. Coming soon.

The final step of closing an account.

That stays with a person.

A side door.

Every AI action on your site goes through one governed gate.

The model

  • Adapters for Anthropic and OpenAI. Every call outside our tests goes through the authenticated Cloudflare AI Gateway, with payload logging switched off, so only metadata is logged.
  • Which model runs is set by our team. Customers choose a tier where their plan includes the choice.
  • Copilot calls are written to a cost ledger, and the account's monthly AI allowance is checked on every call.
  • With your own keys switched on, every call uses your Anthropic or OpenAI key, or is refused. It is never quietly sent on ours.
  • Page copy is one structured call, validated against the sections' own fields, with up to two attempts at repair. If it still fails, nothing is invented: a section with no facts behind it is left out and named, or kept with a note asking for your facts, which blocks publishing until you fill or remove it. Any sample words left are named before you publish.

The record

  • Every phase is recorded: denied, dry run, pending approval, executed, rejected, rolled back, error. Each entry carries who acted, on which site and environment, and a plain-language line.
  • "Activity" shows these entries to your team, with an undo on each row whose window is open, and export to CSV or JSON.

What keeps it safe

Structure, not instructions.

The rules live in the gateway's code. A prompt cannot change them.

No by default.

The copilot's own default is to deny, and only your click says yes.

Consent to the exact thing.

Your click covers one tool, one input and one target as you saw it, for five minutes.

No silent drift.

A grant whose target has changed is refused, and so is an undo that would overwrite something newer.

No second route.

The Composer and the chat share one gateway and one set of rules.

Secrets stay in your browser.

No copilot tool takes a key, a password or an identity setting.

Common questions

Can a prompt injection make the copilot publish?

A prompt can change what the copilot proposes. It cannot approve anything: approval comes only from your click, through one door, checked against you. Read the card before you approve it.

What exactly does my click approve?

The tool on the card, with the input on the card, against the target as it was when the card was drawn, for five minutes.

What if someone changes the page while the card is open?

The grant no longer matches the page, and the change is refused.

How is a scheduled post approved?

Once, for its exact time: approving the schedule is approving the publish at that time. Edit the page in the Composer before then, and the schedule is cancelled.

Does the Composer go through the same gate?

Yes. Each gesture becomes a typed operation, planned and applied with the same tools, and publishing is the same approval-gated step.

Do your operators bypass it?

No. Our operators' copilot has tools of its own, and every one of their writes stops at a card that names the customer it touches. The final step of closing an account stays with a person.

Is every action logged?

Every phase is recorded with a plain sentence, and "Activity" shows the entries to your team.