{{ reviewHdrCrumb }}
{{ session.agentId }} / {{ session.id }}
{{ modeBadgeLabel }} {{ sessModel }} {{ sessRbChip }} {{ liveLabel }}
{{ c.label }} {{ c.value }}
{{ offlineBannerText }}
{{ suCrumb }} · {{ suProject }}
Enforcement plane
Enforce your agents
Every tool call is checked before it executes. Pick where you start; the rules grow from your traces.
{{ suProject }} / v1 {{ suArmedChip }} {{ suWatchChip }} Open Rulebook → adjust rules clear rulebook
Already in production
“I have an agent running”
Keep it where it is. Paste one prompt into your coding agent; enforcement and tracing wire themselves in, and every run streams here live.
Building something new
“I’m building a new agent”
Bring a policy document and one line about the flow. Sponsio generates the agent and its safety rules together, and you watch them fire before writing any code.
Shipping every week
“I keep changing my agent”
Every push gets checked: outdated rules, broken references and known violations fail the build. Anything that needs judgment lands as a PR comment, never a failure.
Prefer the manual route? 1 · pip install --pre sponsio==0.2.0a7 2 · create an API key 3 · sponsio login · sponsio push sponsio.yaml
Building for your own users? The API plane ships with sub-tenant keys, metering and webhooks. talk to us
Guard your pipeline
Three deterministic gates fail the build; anything that needs judgment becomes a PR comment. Your API key goes in the repo secrets, so CI usage bills to your account.
.github/workflows/sponsio.yml paste in your coding agent {{ ciCopyLabel }} 
{{ ciPromptText }}
The gates
1 · Drift
Repo rulebook behind the cloud version fails the build.
2 · Compile
Every rule still parses; every referenced tool still exists in the code.
3 · Replay
Recorded violations must still be caught; clean traces must still pass.
4 · Scan
New tools or policy lines with no rule become a PR comment, never a failure.
Checking your rules
Parsing the uploaded policy and grounding it against your repo. Nothing arms without your review.
✓ {{ xl.t }}
Connect your agent
Built your agent with Claude Code or Cursor? Paste one prompt there and it wires Sponsio in. Enforcement runs inside your process; traces stream here.
project owns the rulebook · sponsio://{{ suProject }}@vN
API key {{ suKeyMasked }} copy The key ties usage to your account: rulebook pull, trace streaming, cloud checks. Local offline runs are free and never metered.
Python TypeScript
paste in your coding agent {{ cnPromptToggleLabel }} {{ cnCopyLabel }} 
{{ cnPromptText }}
What happens next
1
Paste the prompt in your coding agent and let it wire the SDK in.
2
Run your agent. Deterministic checks enforce in-process, microseconds per call. Works offline, free forever.
3
When you are online, traces stream here. Watch runs live in Sessions. Sponsio mines gaps from every trace; cloud checks bill to your key.
New guarded flow
One prompt in, two artifacts out: Sponsio reads your policy and your description, then generates the agent flow and its contract rulebook together.
project
Policy document (your rules of record: SOP, compliance manual, runbook)
{{ suFileName }} {{ suFileMeta }} browse…
What should this agent do? (one prompt: Sponsio plans the flow from it and binds the extracted rules to every tool call)
generation makes two model calls on Sponsio cloud · metered to your workspace
Generating rules & flow…
Reading your policy and your prompt. Rules compile to deterministic patterns; the flow is planned around them. Nothing arms without your review.
✓ {{ xl.t }}
Run the generated flow
Built from your flow description, with the safety layer attached: every tool call is checked before it executes. Watch your rules fire before any real agent is connected. Once yours connects, this bench replays your actual traces.
✓ {{ gl.t }}
generated flow · 4 agents · 13 tool calls · safety layer attached
orchestrator delegates to market-data, research-runner and reporting. The run opens in Sessions, the same screen every real run uses. Come back to Setup afterwards to deploy.
Deploy v1
Version v1 is immutable. The SDK pulls it by key; enforcement runs inside your process, microseconds per check, no network on the hot path.
{{ suProject }} / v1 {{ suArmedChip }} {{ suWatchChip }}
API key
{{ suKeyMasked }} copy
Keep iterating here · the flow and its rulebook live in this project
swap the planner model, rerun, then "⇄ vs previous run" shows what changed
Take it home · your API key authorizes the pull, and local runs stream traces back to this console
pip install --pre sponsio==0.2.0a7
export SPONSIO_API_KEY={{ suKeyMasked }}
sponsio pull {{ suProject }}   # → flow.py + {{ suProject }}.sponsio.yaml (v1)
Protecting an agent you already run instead? That path is on the Setup landing ("I have an agent running") and wires the same rulebook into your own loop.
⚠ In the test run, t10 http_get passed with no rule matched. That is the deferred R7 gap: the runtime watches live traces and proposes it back with evidence when it fires for real.
The rulebook joins The Rulebook screen; runs appear in Sessions the moment your agent connects.
Enforcement plane · {{ suProject }}

Integrations

Drop-in wrappers for the stack you already run. One rulebook, the same pre-execution check at every tool boundary. Full onboarding lives in Setup — these are the wiring points.
{{ fc.n }} {{ fc.chip }} copy
{{ fc.d }}
{{ fc.s }}
API key {{ suKeyMasked }} copy spans: OTLP → this console · local det checks are free and offline
Enforcement plane · {{ suProject }}
MCP servers
Your agent talks to MCP tool servers you don’t control. Put Sponsio between them: the proxy speaks MCP on both sides, and every tool call is checked against your rulebook before it reaches the server.
Wrap a tool server
The proxy speaks MCP on both sides. Your agent client connects to the proxy instead of the raw server; contracts decide what goes through. Ships in the SDK today (sponsio.integrations.mcp).
from sponsio.integrations.mcp import MCPContractProxy

proxy = MCPContractProxy(mcp_client=client,
                         system=system,          # your rulebook
                         agent_id="assistant")
result = await proxy.call_tool("process_refund", {"order_id": "123"})
shared across concurrent clients det checks, in-process
Once wrapped, every call your agent makes through the proxy shows up in Sessions like any other guarded run — same rulebook, same verdicts, same trace.
Enforcement plane{{ projectCrumb }}

Sponsio Console

Every agent session, checked at the action boundary
{{ homeMeta }}
{{ hg.value }} {{ hg.label }}
Sessions ⌕
click a row to open the trace
Agent Session Mode Agents Steps Enforcement State
{{ hs.agent }} {{ hs.id }} {{ hs.mode }} {{ hs.agents }} {{ hs.steps }} {{ hs.violLabel }} {{ hs.state }} →
Session telemetry

The Session

Every run of your agent, streamed and checked at the action boundary

Listening for your first trace

Run your agent wherever it lives. The moment it makes a tool call, the run streams here and plays live. Deterministic checks enforce in your process either way.
OTLP endpoint · {{ cnOtlpHost }}/v1/traces
browse existing sessions instead
⌕ {{ matchCount }}
{{ sg.label }}
compare this session against…
{{ traceEyebrow }}

Agent Session

↻ {{ replayNote }}
CONTRACT LAYER {{ rail.armedN }}enforcing {{ rail.checksN }}checks run {{ rail.fires }} {{ rail.last }}
Waiting for first event…
Sponsio is on guard at the action boundary. The trajectory will stream here.
Session compare
aligned by tool sequence · differences highlighted
{{ d.l }}{{ d.v }} {{ ac.label }}{{ ac.sub }} {{ rc.label }}{{ rc.sub }}
{{ cmp.aTag }}{{ cmp.aId }}{{ cmp.aSub }}
{{ cmp.bTag }}{{ cmp.bId }}{{ cmp.bSub }}
{{ cr.l.name }} {{ cr.l.chip }} {{ cr.l.args }}
{{ cr.markTxt }}
{{ cr.r.name }} {{ cr.r.chip }} {{ cr.r.args }}
{{ cmpCard.status }} {{ cmpCard.srcLabel }} {{ cmpCard.id }}
{{ cmpCard.label }}
{{ cmpCard.ltl }}
bound: {{ cmpCard.bound }} enforcing since {{ cmpCard.armed }}
{{ cmpCard.mined }}
Fired in this session
{{ f.tool }} {{ f.act }}
Execution path
{{ timelineMeta }}
waterfall · {{ traceTotal }}
Span Elapsed → Dur
{{ r.chev }}
{{ r.name }} {{ r.chip }} {{ r.detail }} rule → {{ r.ckTxt }}
{{ r.dur }}
⏸
Checkpoint: this action needs your sign-off. The run is paused.
{{ r.escRule }}
Approve once Always allow Keep blocked Open in workbench
✦
{{ r.calloutText }}
Sponsio proposes: {{ r.calloutLabel }}
off observe enforce
details
watching · logs only {{ r.calloutLabel }} enforce
✓ enforcing as {{ r.coContractId }} · guards every future run
No spans match "{{ query }}" · clear filter
0ms {{ axisMid }} {{ axisEnd }}
Session ended · {{ timelineMeta }}
Cross-agent execution path
call handoff
Each agent is an independent OTEL trace. Click a node to solo it.
{{ g.id }} {{ g.violLabel }}
{{ g.serviceName }} · {{ g.traceId }}
{{ st.tool }} {{ st.tag }}
Click to solo trace →
Swimlanes · shared time axis
Each lane is one agent's independent trace on a common clock. Click a lane label to solo it.
{{ ln.id }}
{{ ln.violLabel }}
↳ {{ ln.delegated }}
{{ ch.tool }}
t+0ms {{ swimMid }} {{ swimEnd }}
Contract governance

The Rulebook

{{ rbScopeLine }}
API {{ rbApiRef }} {{ rbCopyApiLabel }}
ships with the SDK cloud-ref loader
file {{ rbPullCmd }} {{ rbCopyLabel }}
Downloads the reviewed rulebook over your repo's sponsio.yaml. Your next run enforces exactly what you set to enforce here.
{{ rbDriftLine }}
{{ contractsMeta }}
pending review ✓ review complete 8/8 policy clauses mapped 1 ambiguous reading {{ suReviewMeta }}

Waiting for your rules

They land here the moment your coding agent pushes, or a policy upload parses. Nothing arms without your review.
POST /v1/rulebook/push
browse the current rulebook instead
✎
{{ rbNlErr }}
Templates {{ tp.label }}
{{ tk.txt }} ✕ {{ rbTplGloss }}
⌕
Status set all
Rule Source Pipe Enforced since Violations Decision
No rules match “{{ ruleQuery }}” · clear search
{{ c.label }}
{{ c.stateChip }}
{{ c.sourceLabel }} {{ c.pipeline }} {{ c.armedSince }} {{ c.violLabel }}
—
{{ c.sourceLabel }} {{ c.srcLabel }} → {{ c.exPattern }} confidence {{ c.exConf }} {{ c.exEnf }}
{{ c.exRisk }}
{{ c.exJust }}
Compiled LTL
{{ c.compiledLtl }}
self-evolved · {{ c.minedNote }} · enforcing {{ c.armedSince }} →
Fired in this session
{{ f.at }} {{ f.tool }} {{ f.action }}
Agent overview

{{ ao.id }}

{{ ao.meta }}
{{ k.value }}{{ k.label }}
Contract friction · what keeps firing across runs
{{ fx.label }} {{ fx.act }} {{ fx.trend }}
{{ fx.sess }} via {{ fx.tools }} {{ fx.hint }}
Tools that drew interventions
{{ tx.label }}
Workspace

Settings

API keys, access and workspace configuration
API keys
 {{ keyCreateErr }}
{{ mintedPanel.name }} · copy it now
{{ mintedPanel.key }}
shown only once · the server stores a hash and can never display it again
Name Key Scope Created Last used
No keys yet · create one to connect your agent
{{ k.name }} {{ k.masked }} {{ k.scope }} {{ k.created }} {{ k.lastUsed }}
Rulebook
Pushed rulebook {{ setRbLine }}
Members
who can sign in to this workspace
Name Email Role Joined
{{ m.initial }} {{ m.name }} {{ m.email }} {{ m.role }} {{ m.joined }}
Workspaces are single-owner today · team invites arrive with org workspaces · talk to us if you need one sooner
Human in the loop

Approvals

Actions held by EscalateToHuman wait here for your sign-off · the full audit trail stays in Sessions
{{ vs.label }} {{ vs.value }}
Waiting on you · {{ escOpenCount }} {{ escScopeCrumb }}
{{ eg.chev }} {{ eg.tool }} {{ eg.args }} waiting in {{ eg.count }} Approve all once Always allow Keep all blocked
{{ eg.rule }}
{{ ei.sess }} → approve once keep blocked
{{ eq.tool }} {{ eq.args }} {{ eq.sess }} → Approve once Always allow Keep blocked {{ eq.decLabel }}
{{ eq.rule }}
Standing approvals
{{ ea.tool }} never escalates under {{ ea.rule }} revoke
Nothing waits on you{{ escEmptyScopeNote }} · resolved items are below

Approvals arrive with your first run

When a rule escalates a call to a human, the held action lands here for your sign-off. Run your agent and this becomes your work queue.

Nothing waits on you{{ escEmptyScopeNote }}

Actions held by EscalateToHuman wait here for your sign-off. All clear right now.
History
{{ eh.tool }} {{ eh.args }} {{ eh.sess }} → {{ eh.decLabel }}
{{ eh.rule }}
Session report

Report

Session health at the action boundary

Waiting for your first run

Session health lands here the moment your agent makes its first guarded tool call.

No steps in this run yet

The report builds itself from the run's guarded tool calls. Pick a finished run in the rail, or wait for this one to stream.
Session report

Report

Session health at the action boundary
{{ session.id }} {{ overviewSub }}
Pass rate
{{ passPct }} {{ passDetail }}
{{ t.label }} {{ t.value }} {{ t.sub }}
Trace statistics by tool
{{ statsMeta }}
Tool P95 latency Calls P50 P95 Max Checks Blocked
{{ t.tool }}
{{ t.calls }} {{ t.p50 }} {{ t.p95 }} {{ t.max }} {{ t.checks }} {{ t.blocked }}
Agent × time violation heatmap
{{ hr.agent }}
t=0 t={{ heatEnd }}
Riskiest
{{ rk.rank }}
{{ rk.name }}
{{ rk.kind }}
{{ rk.value }}
✦ Sponsio {{ copilotBadge }}