Developers

Two APIs. One afternoon.

Ask whether an action is allowed before it runs, and keep balanced books for what did. REST, JSON, idempotency keys, dry runs, and a test mode that is the real engine rather than a demo.

Get API keys Read the reference

No card
No demo call
No time limit

Ask before it happenscontrol

curl https://api.kordio.io/control/v1/agent/actions \
  -H "Authorization: Bearer $KORDIO_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d action_type=payment.create \
  -d resource=api.openai.com \
  -d cost_cents=12000 \
  -d currency=USD

Record what did happenledger

curl https://api.kordio.io/ledger/v1/transactions \
  -H "Authorization: Bearer $KORDIO_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d 'postings=[
        {"account_id":"acc_ops","amount":-12000,"currency":"USD"},
        {"account_id":"acc_vendor","amount":12000,"currency":"USD"}
      ]'

Quickstart

From nothing to a real decision.

Four steps, none of which involve talking to us.

01
Create a sandbox workspace
Email and password. No card, no call, no waiting list. Test-mode keys are issued immediately.
02
Write a policy
Policy is data, not deployed code. It validates when you write it rather than when an agent is waiting on it.
03
Send an action
Get allowed, requires approval, or denied, with the rule that decided and the headroom left on every limit.
04
Verify the signature
Check the JWS against the public JWKS in whatever executes. No callback, no shared secret.

Policy as data

Rules you can diff in review.

Typed rule kinds cover caps, windows, rate limits, monthly ceilings, approval thresholds and allowlists. The condition rule is the open one: a boolean expression over the action, combined with all of, any of and not.

policy.jsonvalidates on write

{
  "mode": "allowlist",
  "imports": ["vendor-allowlist"],
  "rules": [
    { "kind": "cost_cap", "max_cents": 50000,
      "action_types": ["payment.create"] },

    { "kind": "spend_window", "max_cents": 200000,
      "window_seconds": 86400 },

    { "kind": "rate_limit", "max_actions": 100,
      "window_seconds": 60, "action_types": ["tool.invoke"] },

    { "kind": "condition", "effect": "require_approval",
      "rule_name": "new_counterparty",
      "when": { "all_of": [
        { "field": "action_type", "operator": "starts_with",
          "value": "payment." },
        { "not": { "field": "resource", "operator": "in",
          "value": ["stripe.com", "api.openai.com"] } }
      ] } }
  ]
}

It always terminates, it never depends on a deploy, and a change to it shows up in a pull request like anything else.

What you can rely on

The parts that matter at three in the morning.

Guarantees, not intentions. Each one is something the API does on every call.

Errors carry the next step: Every error has a hint saying what to do about it, not just what went wrong. An unbalanced transaction tells you which currency is short and by how much.
Idempotency in the header or the body: Take the key wherever it is convenient. Scripting against the API with shell variables stops being annoying.
Dry run everything: Simulate a decision without reserving budget or recording an intent. Validate a transaction without writing it. Same code path, no side effects.
Test mode is the whole engine: Not a crippled sandbox. Every policy kind, cosigning, approvals and the audit trail, against test-mode agents and test ledgers, with no card and no time limit.
Verify offline, in any language: Allowed decisions come back as an ES256 JWS on P-256. Any standard JWT library checks it against the public JWKS with no call back to us.
Request ids in the body: Not only in a header. The same value shows up in your logs and in a support conversation, so nobody has to reproduce anything.

Where to go next

Pick the half you need first.

Both halves are self-serve, and neither one requires the other.

Ledger: Double-entry books, reconciliation, period close and reports. Live today, with its own plans. Deciding whether to build instead? Read build versus buy.
Spend control use cases: Refund and payout authority, and hard limits on what an agent may spend on paid tools. Start where the money already leaks.
What a control layer is: The concept, what one has to do to count as one, and the honest limit: it only binds the paths you route through it.

Two APIs. One afternoon.

From nothing to a real decision.

Create a sandbox workspace

Write a policy

Send an action

Verify the signature

Rules you can diff in review.

The parts that matter at three in the morning.

Pick the half you need first.

The fastest way to judge this is to call it.