Deterministic
agent safety
for every
high-risk call.
Five execution layers.
One verifiable decision path.
Layer 1-2: Agent + Interceptor
Keep your existing agent. Before sensitive actions, send one HTTP POST to localhost. GuardMesh interceptor reads policy from 0G KV and broadcasts evaluate_intent over AXL.
Layer 3: Guardian Mesh
Three independent guardians run AXL binaries, evaluate intent using 0G Compute (TEE-backed), and vote approve or block via A2A messages.
Layer 4: 0G Memory
Intent, votes, and outcome are encrypted to 0G Storage. Merkle root is anchored to 0G Chain. Policies remain queryable in 0G KV.
Layer 5: Enforced Outcome
Majority approve executes the original action. Majority block stops execution and triggers review. Outcome is committed before release.
Agent, interceptor,
and guardian nodes.
Each guardian is identified by its AXL public key. No DNS, no broker, no central queue. Your app only speaks HTTP to localhost:9002.
Web & data research
Autonomously browses the web, extracts structured data, synthesizes reports from multiple sources with citations.
Code generation & review
Writes, refactors, and reviews code across 40+ languages. Runs tests, fixes bugs, opens pull requests automatically.
Data analysis & insights
Connects to your databases, runs queries, visualizes trends, and surfaces anomalies before they become problems.
Workflow automation
Takes actions across APIs: sends messages, creates calendar events, triggers webhooks, and manages third-party apps.
How one intent
flows through GuardMesh.
Capture
Agent sends intent payload to interceptor via HTTP POST localhost.
Broadcast
Interceptor loads policy from 0G KV and sends evaluate_intent over AXL A2A.
Evaluate
Guardians run LLM checks on 0G Compute (TEE-backed) and vote approve or block.
Anchor
Decision bundle is uploaded to 0G Storage and root hash is committed on 0G Chain.
Enforce
Majority verdict releases or blocks action, then emits review signal and audit receipt.
AXL as transport.
0G as trust layer.
AXL is a peer node with localhost HTTP interface, not a queue. 0G provides policy lookup, TEE inference, storage receipts, and chain anchoring.
A2A message dispatch
Your code posts structured evaluate_intent messages to localhost:9002. AXL handles routing and peer discovery.
axios.post(
"http://localhost:9002/a2a/send",
{type: "evaluate_intent", intent, policy}
)
TLS + Yggdrasil end-to-end encryption. Nodes exchange payloads privately, even across NAT, with no port forwarding.
Cryptographic evidence
for every verdict.
Every decision generates a replayable bundle: intent payload, guardian votes, consensus result, timestamps, and 0G receipt hash.
TEE-signed inference
Guardian evaluation from 0G Compute can be independently verified
Merkle-root receipts
0G Storage returns immutable hash for each decision bundle
Chain-anchored timeline
Smart contract records each root hash with final outcome
Built for developers.
Loved by teams.
Guardians evaluating
intents in real time.
Independent nodes exchange signed verdicts over AXL. No coordinator, no shared queue, no single point of failure.
Human-readable names
for every guardian.
Each guardian registers as a subname of guardmesh.eth, making agents discoverable, verifiable, and interoperable with the ENS ecosystem.
guardian-1.guardmesh.eth
Role
code_analysis_only
Model
qwen-2.5-7b
Version
v1.0.0
guardian-2.guardmesh.eth
Role
data_access_audit
Model
llama-3.3-70b
Version
v1.0.0
guardian-3.guardmesh.eth
Role
intent_verification
Model
qwen-2.5-7b
Version
v1.0.0