Fewer Steps: the foundation essay
Delegus Request early access

Live demo · test environment

One order, verified by a stranger.

Acme’s purchasing agent, procurement-7, orders GPU time from ComputeCo, a seller that has never seen it. Press Place the order and watch it happen live: Acme signs what its agent may do, the agent signs the order, and ComputeCo checks with Delegus Check once before it books anything. The checks and the signed receipts are real, from the Delegus test environment. Acme, its agent and ComputeCo are sandbox stand-ins, not real companies.

Watch it start to finish: 96 seconds of the real product.
Checking the sandbox…

The handshake, step by step

Acmethe company procurement-7its agent ComputeCothe seller Delegusone check authority signed order is this allowed? signedreceipt
ReadyPress Place the order. Acme signs what procurement-7 may spend, the agent signs one order, and ComputeCo asks Delegus Check once.

33 checks, in a fixed order

  1. The grant is well-formed P1
  2. The issuing organization is registered T1
  3. The organization has verified its domain T2
  4. The organization's key isn't compromised T3
  5. The signing key is published P2
  6. The grant's signature is valid P3
  7. The grant has started P4
  8. The grant hasn't expired P5
  9. The grant hasn't been revoked P6
  10. The grant is meant for your app P7
  11. The agent's proof of grant is well-formed P8
  12. The proof of grant is signed by the agent P9
  13. The agent matches the grant P10
  14. The proof of grant names this grant P11
  15. The proof of grant is addressed to your app P12
  16. The proof of grant is fresh P13
  17. The proof of grant matches the action P14
  18. The proof of grant hasn't been used before T5
  19. The action is well-formed P15
  20. The grant covers this kind of action P16
  21. Every limit on the grant is understood P17
  22. The currency is allowed P18
  23. The amount is within the limit P19
  24. The resource is allowed P20
  25. The grant's budget has room for this P21
  26. Every earlier decision your app requires is declared D1
  27. Each earlier decision it relies on was issued by Delegus Check D2
  28. Each earlier decision's receipt is validly signed D3
  29. Each earlier decision was an approval D4
  30. The earlier decisions belong to the same transaction D5
  31. The grants behind them are still in date D6
  32. The grants behind them haven't been revoked, and their issuers are in good standing D7
  33. The budget was taken for this request T7

What was signed

waitingAcme’s grant and the agent’s proof of grant appear here as they are signed.

What happened

Nothing yet.

What was exchanged

Place the order to see the grant Acme signed.

Anyone can check the receipt is genuine, without Delegus: see the signature check.

Test your own agent

Give your AI agent some authority and a one-hour test server, then paste in tasks that push past it. Every tool call is checked by the Delegus engine, and you watch each decision arrive with a test receipt you can check in your browser. Try the agent test

A robot arm, checked step by step

An AI agent gives a robot arm its orders: pick, move, place. Before each step starts, the arm’s gate asks Delegus Check whether the company really allowed it. Six jobs, each decision a real signed receipt from the live API, checked in your browser. Try the robot cell

Watch a recorded run: a seller checks before it commits

Acme’s purchasing agent commits Acme to an $18,400 compute order on invoice terms. ComputeCo has never dealt with the agent, so it checks with Delegus Check before it books anything. An order over the limit, an order at a seller Acme’s delegated authority doesn’t name, and an order after Acme revokes are each refused, with a signed receipt and no invoice.

The check ran in the Delegus reference engine on the recording machine, not the production service. Recorded under v0.2 of the protocol. Full recording page. The earlier recording, one grant of authority with card and invoice in Stripe test mode: cross-rail demo.

How long it takes to integrate

The receiving service adds one call to its request handler. This is the whole relying-party integration as spec §15 gives it; the seller in our demo application, including its error handling, is 68 lines.

import { Delegus } from "@delegus/sdk";
const delegus = new Delegus({ apiKey: process.env.DELEGUS_API_KEY, publicBaseUrl: "https://seller.example" });

app.post("/orders", async (req, res) => {
  const d = await delegus.verify({
    grant: req.header("Delegus-Grant"),
    proof: req.header("Delegus-Proof"),
    action: { type: "commerce:purchase", resource: req.body.orderId, amount: req.body.amountMinor, currency: req.body.currency },
    request: { method: req.method, path: req.path },
  });
  if (d.decision !== "ALLOW") return res.status(403).json({ reason: d.reason });
  // proceed; persist d.receipt with the order
});

A note on the receipts above: on a revocation the receipt reports trust.result FAIL as well as protocol FAIL. No trust check failed; the replay check T5 is skipped once P6 fails, and the specification defines PASS as every check true. The per-check list shows exactly that.

Two headers come in with the agent's request. Your service forwards them with its own description of the action, gets ALLOW or DENY with a reason, and keeps the receipt. No keys, credential formats or revocation lists to handle. Read the integration guide or try the same calls yourself.

What it costs

Free to start: a sandbox with no card, then 14 days free in production.

Running agents across many sellers? Talk to us.