Actions Aren't Content.
We Built the Credit Bureau That Prices Them.
When tokens become actions -- accessing data, making purchases, delegating tasks -- the trust requirement changes categorically.
Content can be wrong and you re-prompt. Actions can be wrong and you lose money, leak data, or violate compliance. SuilaAI determines which agents are qualified to operate — deployed today on Vercel Passport + eve, not a diagram.
This is the act half of the bureau — agents that spend, delegate, and transact, scored on signed outcomes. For how brands and content are scored as entities, see the seen half: how scoring works or what it means for brands.
How it runs on Vercel Passport + eve
Not a diagram — the deployed integration. Passport supplies verified identity, eve supplies the extension points, the bureau supplies the verdict. Zero forked platform code: every snippet below is from the production agents.
Every agent enters behind verified identity. The OIDC subject maps deterministically to a bureau id — and identity is load-bearing: a witness with no verified identity has credibility zero.
Three drop-in rails: the approval policy is the verdict, the route-auth walk scores inbound callers, and an observe-only hook reports outcomes. A2A delegation rides defineRemoteAgent — identity travels, ESCALATE parks durably.
Neutral third party: cross-runtime evidence graph, fixed-point solve offline, O(1) verdicts on the wire — under 50ms, with reasons, both directions.
// merchant/agent/lib/suila.ts — verbatim
// Vercel OIDC subject:
// owner:<team>:project:<name>:environment:<env>
export function principalToAgentId(auth) {
const sub = auth.subject ?? "";
if (sub.startsWith("agent://")) return sub;
const oidc = sub.match(
/^owner:([^:]+):project:([^:]+):/);
if (oidc) return `agent://${oidc[1]}/${oidc[2]}`;
return null; // unmapped machine principals fail closed
}// buyer/agent/tools/order_from_merchant.ts
import { defineTool } from "eve/tools";
import { mutualHandshakeApproval } from "../lib/suila";
export default defineTool({
description: "Order from the merchant agent",
approval: mutualHandshakeApproval({
stakes: (i) => i?.amountUsd ?? 1,
}),
async execute({ item, amountUsd }) { /* ... */ },
});
// REFUSE never runs · ESCALATE parks on eve's
// native approval gate and resumes on answer// merchant/agent/channels/eve.ts export const auth = [ suilaGate(jwtHmac(process.env.DEMO_JWT_SECRET)), suilaGate(vercelOidc()), // Vercel-to-Vercel localDev, ]; // the inner auth proves WHO the caller is; // suilaGate asks the bureau whether to TRUST it. // Below threshold -> 403 with the scored reason. // Bureau unreachable -> fail closed.
// hooks/report-outcomes.ts (observe-only)
await reportOutcome({
subject: MERCHANT_ID, reporter: BUYER_ID,
outcome: 1, stakes: amountUsd,
grade: "counterparty",
});
// schedules/weekly-kaizen.ts
export default defineSchedule({
cron: "0 6 * * 1", // Mondays 06:00 UTC
async run() {
await fetch(`${BUREAU_URL}/v1/kaizen/run`, {
method: "POST",
body: JSON.stringify({ holdout: 0.3 }),
}); // promote only through statistical gates
},
});How the Suila Index Integrates
Four integration points where the Suila Index becomes infrastructure — not just a score, but a runtime primitive.
Policy Gateway Signal
Any external policy engine can query the Suila Index as a first-class input — gating data access, tool permissions, and delegation authority by trust score.
# Suila Trust Gateway Policy
rules:
- name: financial-data-access
condition:
suila_index: { gte: 700 }
pillar_provenance: { gte: 0.80 }
action: ALLOW
scope: [read_financial, write_orders]
- name: default-deny
condition:
suila_index: { lt: 550 }
action: DENY
log: audit_trailToken Budget Allocation
Higher-trust agents waste fewer tokens on hallucination, retry loops, and failed delegations. The Suila Index becomes a resource optimization signal — trust directly translates to compute efficiency.
Where is the base token allocation and is the task complexity multiplier.
Agentic Commerce Protocol
Agent A checks Agent B's Suila score before delegating a task. Post-transaction, the score updates based on outcome fidelity. Trust becomes the currency of the agent economy.
Scores improve with successful outcomes and degrade with failures — a self-correcting trust system.
# Agentic Commerce Protocol
async def delegate_task(agent_a, agent_b, task):
# Pre-delegation trust check
score = await suila.get_score(agent_b.id)
if score < task.min_trust:
raise DelegationDenied(
f"{agent_b.id} score {score} "
f"< required {task.min_trust}"
)
result = await agent_b.execute(task)
# Post-transaction score update
await suila.update_score(
agent_b.id,
outcome=result.fidelity,
expected=task.baseline
)AaaS Quality Assurance
When SaaS becomes Agent-as-a-Service, buyers need continuous quality evaluation. The Kaizen Loop provides machine-readable, composable, and verifiable trust ratings that improve with every transaction.
Time-weighted quality score with exponential recency bias — recent transactions matter more.
Collect behavioral telemetry from agent execution traces
Compute 26-signal TrustRank using the Universal Trust Equation
Identify weakest signals via gap analysis and impact ranking
Generate machine-readable recommendations via Cortex LLM
Platform Evolution: The Trust Primitive
Each era multiplies the stakes. The agentic era demands trust infrastructure that didn't exist before.
- Agents autonomously execute transactions — spending budgets, signing contracts, accessing sensitive data.
- Multi-agent delegation chains mean one untrustworthy agent can compromise an entire pipeline.
- The cost of error is measured in dollars, compliance violations, and data breaches.
- Human-in-the-loop verification is impossible at agent-speed (milliseconds per decision).
The Trust Equation
Every score is decomposable, transparent, and actionable — reproducible from signed outcomes, not asserted.
Provenance
Identity proof, code signing, registry verification, dependency integrity, supply chain depth, model card completeness, license compliance.
Temporal
Uptime reliability, response latency P95, version stability, drift detection, recovery time, update frequency.
Semantic
Output accuracy, hallucination rate, citation validity, reasoning coherence, task completion, specification adherence, safety alignment.
Context
Scope boundary respect, permission compliance, data handling, delegation integrity, context retention, environment awareness.
Three-Phase Scoring Pipeline
Telemetry in. Trust score out. Certificates issued. All in real-time.
Telemetry Harvester
Captures tool-call traces, MCP events, smolagents execution spans, and reasoning entropy. Native Langfuse and Arize observability exports.
Fidelity Judge
Computes behavioral fidelity via KL-divergence between stated plan and actual execution. Flags Credit Watch when drift exceeds threshold.
Advisory Gateway
Issues Trust Certificates as W3C Verifiable Credentials. ECDSA-signed, cross-cloud portable, audit-ready.
Real-Time Credit Decisions
One API call. Sub-50ms server-side scoring. Before every agent delegation. Bands are continuous across the full 300-850 range — the same four tiers used by the Suila Index everywhere on the ledger.
| Rating | Score Range | Decision | Action |
|---|---|---|---|
| Elite | 800-850 | APPROVE | Full autonomous delegation |
| Trusted | 700-799 | APPROVE | Standard delegation |
| Established | 600-699 | MONITOR | Delegate with trace logging |
| Developing | 300-599 | REVIEW | Human approval required |
Never Static. Continuously Watching.
The patented Kaizen Loop monitors every agent in real-time. Drift detection, anomaly flagging, and auto-blocking happen before any agent acts.
All signals nominal. Agents: proceed.
Price anomaly emerging. Agents: monitoring.
Review clustering detected. Agents: FLAGGED.
Transaction $18,200 blocked. Loss prevented.
"Your engagement_authenticity is 0.28 because 43% of comment activity clusters in 90-second bursts. Audit your comment section."
"Your trace_accountability is 0.31 because 60% of tool calls lack output logging. Enable OpenTelemetry instrumentation."
Enterprise Use Cases
From agent governance to regulatory compliance. TrustRank powers trust at every layer.
Cortex Agent Governance
Sub-50ms server-side inline credit-check per Cortex function call. Agents below threshold require human approval. Credit Watch agents blocked from sensitive tables.
Marketplace Agent Vetting
26-signal scorecard for every marketplace listing. Batch credit-check filters unqualified agents before they reach your pipeline.
Regulated Data Compliance
W3C Verifiable Credentials per agent action for SOC 2, HIPAA, and SOX audit trails. Scoring runs inside Snowflake. Data never leaves your warehouse.
Multi-Agent Pipeline Trust
Delegation pre-auth verifies trust chain integrity in Snowpark pipelines. Recursive trust propagation with weakest-link detection under 100ms.
Trust Is Computable. Start Scoring.
Try the live TrustRank demo, explore the API, or talk to our team about enterprise integration.