GuardianAI
Architecture

Two paths through
every request.

A security path that decides in milliseconds whether traffic is safe — and a trust path that turns an agent's history into evidence nobody can quietly rewrite.

Off-chain · the request path

Screened both directions.

Every prompt is inspected before your model sees it. Every response is inspected before your user does.

01INTAKE

Request intake

The gateway accepts prompts from your app, or from any OpenAI-compatible client pointed at its universal auth proxy (Ollama, vLLM, LocalAI, llama.cpp). Tenants are identified and metered per API tier.

02FAST PATH

Fast-path screen

A regex and heuristic layer sheds obvious injection patterns at zero ML inference cost — high-volume attack traffic never reaches the classifier.

03SEMANTIC

Semantic firewall

An embedding-based classifier judges the subtle cases. Three operating modes trade recall against false positives: strict blocks first, balanced loosens thresholds, permissive flags without blocking.

04DE-OBFUSCATION

De-obfuscation pass

Morse, Braille steganography, Base64, hex, binary, ROT13, homoglyphs — inputs are normalized before classification so payloads can't hide behind an encoding layer.

05EGRESS

Response guardrails

Model output is scanned for PII (redacted before egress), XSS/SQL/shell fragments, and system-prompt leakage, with optional watermarking for downstream tracing. Fail-closed rate limiting bounds everything.

On-chain · the trust path

Identity first. Evidence second.

The on-chain suite doesn't secure execution — it makes an agent's identity and track record independently verifiable.

06IDENTITY

Register identity (ERC-8004)

Your agent is registered in the Trustless Agents ecosystem with a transferable identity token — ownership hands off with the agent, not with us.

07PASSPORT

Mint a soulbound passport (ERC-5192)

A non-transferable passport carries trust tiers (UNVERIFIED → SILVER → GOLD → DIAMOND) and a 0–10000 trust score derived from scan history.

08ANCHOR

Anchor evidence roots

Security events are hashed into a Merkle tree; periodic roots are anchored as tamper-evident timestamps. Anchoring runs simulated-by-default with Monad testnet submission as an opt-in mode — see the note below.

09CERTIFY

Issue insurance evidence certificates

GuardianInsuranceLedger anchors signed certificate packages summarizing an agent's verified history for underwriters. It records evidence — it does not automate payouts or slashing.

What's real today — stated plainly.

Merkle anchoring defaults to simulated mode; live submission targets Monad testnet. The canonical ERC-8004 registries are mainnet ecosystem infrastructure — testnet registrations use a stand-in registry. The insurance ledger anchors certificates only; no payout or slashing automation exists. We'd rather lose the hype than the trust this page asks you to place in us.

The trust suite

Nine contracts. Each one job.

[01]

CortexAnchor

Batches security-event hashes into Merkle roots and anchors them as tamper-evident timestamps.

[02]

PassportSBT

ERC-5192 soulbound agent identity with trust tiers and score.

[03]

InterlockRegistry

Explicit agent-to-agent authorization — no silent handshakes between machines.

[04]

InsuranceLedger

Anchors signed insurance evidence certificates for underwriters.

[05]

ThreatFeedRegistry

Publishes threat intelligence on-chain for cross-organization consumption.

[06]

RiskAttestation

Records third-party risk attestations against registered agents.

[07]

Timelock

Administrative changes wait out a public delay before taking effect.

[08]

CircuitBreaker

A kill switch that can halt the trust suite when something goes wrong.

[09]

ProtectedVault

Escrow-style custody for value touching the trust suite.

Integrate

Two calls. That's the integration.

The Python SDK wraps the gateway API with JWT auth, retries, and typed results. A JavaScript SDK mirrors it.

app.pypython sdk
from guardianai import GuardianAI

guardian = GuardianAI(api_url="https://your-guardianai-host")
guardian.login("username", "password")

# 1. Screen every prompt before it reaches your model
check = guardian.scan_prompt(user_input)
if check.blocked:
    raise RuntimeError(f"Blocked by policy: {check.reason}")

reply = call_your_llm(user_input)

# 2. Screen every response before it reaches your user
out = guardian.scan_response(reply, system_prompt=SYSTEM_PROMPT)
if out.blocked:
    raise RuntimeError(f"Response withheld: {out.reason}")

return reply

Point your existing stack at it

The universal auth proxy sits in front of Ollama, vLLM, LocalAI, and other OpenAI-compatible endpoints, so unmodified clients get guarded without code changes.

Managed platform

The whole platform runs as a managed cloud service — no setup, no maintenance. Onboarding opens soon. See pricing status.

Read the receipts next.

Benchmarks, latency under attack, test counts, audit status — each figure cited to its dated artifact.