Back to Home
THE AGENTIC BUREAU — LIVE ON VERCEL PASSPORT + EVE

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.

$450B / $3.6T
Agentic Value
Realized vs. potential by 2028 (Capgemini)
27%
Trust Fully Autonomous
Down from 43% a year prior (Capgemini)
25%
High-Autonomy Processes
Share of enterprise processes by 2028 (Capgemini)
300-850
Suila Index
FICO-style trust scoring

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.

02

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.

Layer 1 · Vercel Passport

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.

Layer 2 · Vercel eve

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.

Layer 3 · The bureau

Neutral third party: cross-runtime evidence graph, fixed-point solve offline, O(1) verdicts on the wire — under 50ms, with reasons, both directions.

Passport identity → bureau identity
// 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
}
Outbound — the approval policy IS the verdict
// 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
Inbound — the mutual half, at the door
// 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.
Evidence + Kaizen — as side effects
// 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
  },
});
403 refused-at-door  ·  735/709 mutual connect  ·  $1,500 escalate parked→resumed  ·  −33% prediction error in one gated cycle
npm install https://suilaai.com/sdk/suila-trustrank-0.1.0.tgz  ·  live bureau: suila-bureau-vercel.vercel.app
03

How the Suila Index Integrates

Four integration points where the Suila Index becomes infrastructure — not just a score, but a runtime primitive.

Integration 01

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.

trust-gateway-policy.yaml
# 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_trail
Integration 02

Token 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.

800–850
100% budget
Elite
700–799
75% budget
Trusted
600–699
50% budget
Established
300–599
10% budget
Developing
Integration 03

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.

acp-handshake.py
# 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
    )
Integration 04

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.

Kaizen Loop Cycle
01Observe

Collect behavioral telemetry from agent execution traces

02Score

Compute 26-signal TrustRank using the Universal Trust Equation

03Diagnose

Identify weakest signals via gap analysis and impact ranking

04Improve

Generate machine-readable recommendations via Cortex LLM

04

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).
Implication: Trust is a must-have. Automated, real-time trust scoring becomes essential infrastructure — this is where SuilaAI operates.
05

The Trust Equation

Every score is decomposable, transparent, and actionable — reproducible from signed outcomes, not asserted.

TRUSTRANK FORMULA
Provenance
Temporal
Semantic
Context
Behavioral Fidelity
Freshness Decay
Stability

Provenance

25%7 signals

Identity proof, code signing, registry verification, dependency integrity, supply chain depth, model card completeness, license compliance.

Temporal

20%6 signals

Uptime reliability, response latency P95, version stability, drift detection, recovery time, update frequency.

Semantic

35%7 signals

Output accuracy, hallucination rate, citation validity, reasoning coherence, task completion, specification adherence, safety alignment.

Context

20%6 signals

Scope boundary respect, permission compliance, data handling, delegation integrity, context retention, environment awareness.

Pillar Weight Distribution
Provenance 25%Temporal 20%Semantic 35%Context 20%
30% collusion cap  ·  deception costs 10×  ·  contraction-proven  ·  102 automated tests  ·  US 12,505,169 B2 · TW I892115
06

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.

RatingScore RangeDecisionAction
Elite800-850APPROVEFull autonomous delegation
Trusted700-799APPROVEStandard delegation
Established600-699MONITORDelegate with trace logging
Developing300-599REVIEWHuman approval required
07
CONTINUOUS MONITORING

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.

vendor_id_12345 -- Suila Index Live
KAIZEN ACTIVE
STABLE-- 9:00 AM724

All signals nominal. Agents: proceed.

DRIFT DETECTED-- 11:30 AM698-26 pts

Price anomaly emerging. Agents: monitoring.

SYNTHETIC SIGNAL-- 2:15 PM641-83 pts

Review clustering detected. Agents: FLAGGED.

AUTO-BLOCKED-- 2:47 PM581-143 pts

Transaction $18,200 blocked. Loss prevented.

Creator at 520 -- Cortex Recommendation:

"Your engagement_authenticity is 0.28 because 43% of comment activity clusters in 90-second bursts. Audit your comment section."

Agent at 580 -- Cortex Recommendation:

"Your trace_accountability is 0.31 because 60% of tool calls lack output logging. Enable OpenTelemetry instrumentation."

08

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.

US 12,505,169 B2 · TW I892115Protected scoring methodology. W3C Verifiable Credentials. Snowflake Native App.
Learn more
09

Trust Is Computable. Start Scoring.

Try the live TrustRank demo, explore the API, or talk to our team about enterprise integration.