pip install veriswarm. That's the hard part.

Everything after it — registering an agent, sending its behavior as events, and getting back an allow / review / deny decision before it does something sensitive — is about twenty lines of code. That gap, between how hard teams assume agent trust is to add and how little code it actually takes, is the reason most agents in production have no trust layer at all. Not apathy. The quiet assumption that instrumentation is a quarter-long platform project, so it never wins the prioritization fight against shipping the next feature.

This is a getting-started guide that tries to kill that assumption.

The chasm isn't the model. It's the plumbing.

The distance between an agent that demos well and an agent that runs in production is mostly infrastructure. IDC's 2025 research with Lenovo found that 88% of AI proof-of-concepts never reach widescale deployment — for every 33 a company launches, only four graduate. The authors are blunt about the cause: "a low level of organizational readiness in terms of data, processes and IT infrastructure." Not model quality. Readiness. The unglamorous plumbing of running something real — monitoring, accountability, the ability to answer "what is this agent doing, and should it be?" — is exactly what pilots skip and production demands.

Trust instrumentation is part of that plumbing. And the thing standing between most teams and adding it is the same thing standing between developers and any API: friction. Postman's 2025 State of the API report found 55% of developers struggle with inconsistent or incomplete documentation, and 93% of teams hit blockers like poor discovery and duplicated work. The same report found one in four developers now design APIs for AI agents — agents have become first-class consumers of infrastructure. If the trust layer is the part that's hard to wire in, it loses to whatever's easier. So it can't be hard to wire in.

Here's the whole thing.

Twenty lines, end to end

Install the SDK and point it at the API with your workspace key:

from veriswarm import VeriSwarmClient

client = VeriSwarmClient(
    base_url="https://api.veriswarm.ai",
    api_key="vsk_your_workspace_key",
)

Register an agent. You get back its ID and a per-agent API key:

agent = client.register_agent({
    "slug": "support-triage",
    "display_name": "Support Triage Agent",
})
agent_id = agent["agent_id"]

Send a behavioral event whenever the agent does something worth scoring — a tool call, a completed task, a flagged response:

client.ingest_event(
    event_id="evt_8f21",
    agent_id=agent_id,
    source_type="platform",
    event_type="task.completed",
    occurred_at="2026-06-30T15:04:00Z",
    payload={"task_type": "ticket_resolution", "duration_ms": 1840},
)

Then, before the agent does anything you'd want to gate, ask whether it's earned the right:

decision = client.check_decision(
    agent_id=agent_id,
    action_type="post_public_message",
    resource_type="feed",
)

if decision["decision"] == "deny":
    halt(agent_id)          # kill-switched or below threshold
elif decision["decision"] == "review":
    escalate_to_human(...)  # borderline — route for approval
# "allow" → proceed

That's the loop. Register once, stream events as the agent works, and check a decision at the moments that matter. The response comes back allow, review, or deny, with the policy tier that produced it — so a kill-switched agent returns deny at tier_x and your code halts, without you hand-writing the threshold logic. The decision is the output you act on; the scoring that produced it happens on the other side of the wire.

The line that makes it not a generic quickstart

Most trust quickstarts stop at "send an event, get a score." VeriSwarm scores a dimension the others don't: whether the agent knew what it didn't know. Report the agent's own confidence going into a task, then the outcome coming out:

client.ingest_event(
    event_id="evt_8f22",
    agent_id=agent_id,
    source_type="platform",
    event_type="agent.confidence_reported",
    occurred_at="2026-06-30T15:05:00Z",
    payload={"task_id": "task_4417", "predicted_confidence": 0.91},
)

Pair that with the matching agent.task_outcome, and the platform pairs them by task_id and computes a rolling Brier score — the calibration dimension. An agent that's confident and right scores well. An agent that's confident and wrong gets caught, even when its raw task-success rate still looks healthy. That's a behavioral signal you can't reconstruct from latency and token counts, and it's two events to start collecting it. A generic quickstart never sends it; this one does.

The same five calls in Node

The Node SDK is the same surface with camelCase and await:

import { VeriSwarmClient } from "@veriswarm/sdk";

const client = new VeriSwarmClient({
  baseUrl: "https://api.veriswarm.ai",
  apiKey: "vsk_your_workspace_key",
});

const agent = await client.registerAgent({
  slug: "support-triage",
  display_name: "Support Triage Agent",
});

await client.ingestEvent({
  eventId: "evt_8f21",
  agentId: agent.agent_id,
  sourceType: "platform",
  eventType: "task.completed",
  occurredAt: new Date().toISOString(),
  payload: { task_type: "ticket_resolution", duration_ms: 1840 },
});

const decision = await client.checkDecision({
  agentId: agent.agent_id,
  actionType: "post_public_message",
  resourceType: "feed",
});
console.log(decision.decision); // "allow", "review", or "deny"

Both SDKs are zero-dependency — the Python client is standard library only, the Node client uses native fetch (Node 18+). Both refuse to send your key over anything but HTTPS. There's nothing else to stand up.

What those twenty lines buy you

One integration, and the same event stream does quadruple duty: multi-dimensional scoring (identity, risk, reliability, autonomy, plus calibration), the allow / review / deny decisions you just saw, a hash-chained audit trail, and compliance-ready exports. You pick which event type matches each behavior — the full 24-type behavioral taxonomy is the vocabulary — and the scoring, tiering, and recording happen server-side. You don't rebuild any of it.

All of it runs on the free Gate tier: unlimited event ingestion, no credit card, and enough trust decisions a day to put most teams into production. pip install veriswarm or npm install @veriswarm/sdk, grab a workspace key, and the agent you ship today can be scored before it ships tomorrow. The SDK is on GitHub — Python, Node, the full method reference, and the rest of the taxonomy.

Twenty lines. The hard part really was the install.