Unleash the agent.
Leash the action.

Not IAM. Not OPA. Not a workflow.
The execution boundary.

Existing tools identify, evaluate, approve, or log. You have five tools that almost do this — and "almost" is where the incident lives. Veritrellis creates the signed, action-scoped permit your execution layer must verify before any risky action runs.

Most actions never meet a human. That's the point.

Approval isn't the product. It's one of three exits — and the rarest one.

Your agents keep drafting, deciding, doing. Veritrellis only shows up at the exact moment a guess is about to become a consequence.

The permit is real.
Not a flag. Not a lookup. A signed artifact.

Every authorized action produces a short-lived ES256 JWT. Your backend verifies the signature, the action type, the payload hash, and the expiry before execution. If any check fails — execution is blocked.

{
  "jti": "permit_01HZ8K2M",
  "iss": "veritrellis.ai",
  "sub": "agent:support-v2",
  "act": "refund.create",
  "payload_hash": "sha256:a3f2c8...",
  "policy": "refund-policy@v7",
  "policy_rule": 2,
  "approver": "finance@acme.com",
  "workspace": "acme-production",
  "iat": 1746451321,
  "exp": 1746451621,
  "aud": "api.acme.com"
}

Short-lived. Action-scoped. Cryptographically signed. Your gateway verifies this — not a flag, not a database lookup, not best-effort.

Two calls. Your architecture doesn't move.

authorizeRequest() before the risky path. verifyPermit() before the write. Express, Fastify, queue workers, webhook handlers, MCP tools — the gate goes where your writes actually happen, which is rarely where the diagram pretends they happen.

import { createClient } from "@veritrellis/sdk-node";

const client = createClient({
  apiKey: process.env.VERITRELLIS_API_KEY,
});

// Authorize before the agent acts
const result = await client.authorizeRequest({
  actionType: "refund.create",
  actor: { id: "agent:support-refund-agent" },
  payload: {
    amount: 350,
    currency: "USD",
    customer_id: "cus_456",
  },
});

if (result.status === "allowed" && result.permit) {
  await verifyPermit(result.permit);
  await executeRefund(result.permit);
}

// Your execution boundary — verify before
// any risky action runs

import { verifyPermit } from "@veritrellis/sdk-node";

app.post("/refunds", async (req, res) => {
  const permit =
    req.headers["x-veritrellis-permit"];

  const result = await verifyPermit(permit, {
    action: "refund.create",
    payload: req.body,
    audience: "api.acme.com"  });

  if (!result.valid) {
    return res.status(403).json({
      error: "execution_blocked",
      reason: result.reason
    });
  }

  await processRefund(req.body);
});

Fail-closed. Always.

What breaks when we break.

You're considering putting us in front of refunds and production writes — so here's the table other vendors put behind an NDA, including the row about our own outage.

Every blocked execution writes an audit event. Nothing fails silently.