> ## Documentation Index
> Fetch the complete documentation index at: https://docs.sudont.xyz/llms.txt
> Use this file to discover all available pages before exploring further.

# DEMO FLOW

# Sudont Solana Demo — Pitch Flow

## One-Line Setup

```bash theme={null}
# Pre-requisite: Install Solana CLI
sh -c "$(curl -sSfL https://release.anza.xyz/stable/install)"

# One-time devnet setup (generates wallets, funds them, builds transaction fixtures)
./scripts/demo-setup.sh

# Start the demo
make demo-solana

# Open http://localhost:3000
```

## The Pitch

> "Sudont is a Solana execution firewall sidecar for AI agents. Agents submit transactions through our SDK, Sudont simulates and judges them against operator policy, and only approved transactions are forwarded to the network."

## Demo Walkthrough (3 scenarios, \~2 minutes total)

### Scenario 1: ALLOW — Routine Rebalance (30 sec)

**Setup**: "This is Vault Rebalancer, an AI agent managing a Solana treasury. It's been given a Constitution — a policy that defines what it's allowed to do autonomously."

**Click**: "Clean Transfer (ALLOW)"

**Narrate**: "The agent wants to move 0.5 SOL to Treasury Vault A — an approved recipient, within its 1 SOL autonomous limit. Watch what happens:"

* Sudont decodes the transaction
* Simulates it in LiteSVM (our in-process Solana VM)
* Evaluates it against the Constitution
* Verdict: ALLOW — forwards to devnet
* **Click the Explorer link** — "That transaction just landed on-chain. Real SOL, real network."

**Key point**: "Sub-50ms evaluation. The agent never even knew there was a firewall in the path."

### Scenario 2: INTERROGATE → Self-Correct → ALLOW (60 sec) ⭐ THE MONEY SHOT

**Setup**: "Now watch what happens when the agent pushes its boundaries."

**Click**: "Unknown Recipient (INTERROGATE)" — or if using the over-limit variant: "Over-Limit Transfer"

**Narrate**: "The agent tries to send 2.5 SOL — over its 1 SOL autonomous limit. Sudont doesn't just block it. Watch:"

* Sudont evaluates: transfer exceeds autonomous limit
* Verdict: INTERROGATE — not a hard deny, a *challenge*
* "See the challenge? 'Transfer exceeds autonomous limit of 1 SOL.' With actionable feedback."
* "Now watch the agent reason about it..."
* Agent panel shows: analyzing challenge → reducing amount → resubmitting
* Second attempt: 0.9 SOL → ALLOW → lands on-chain

**Key point**: "This is the difference between a firewall and a kill switch. Sudont doesn't just block agents — it teaches them to stay in bounds. The agent self-corrected in real time. No human in the loop."

### Scenario 3: BLOCK — Forbidden DEX Swap (30 sec)

**Setup**: "But some things are non-negotiable."

**Click**: "Forbidden Swap (BLOCK)"

**Narrate**: "The agent tries to execute a Raydium CPMM swap. But that program isn't on the allowlist."

* Sudont evaluates: program not in sol\_program\_allowlist
* Verdict: BLOCK — hard deny, no broadcast
* "Nothing hit the network. The agent's attempt was stopped before it ever reached Solana."

**Key point**: "Three tiers of response: ALLOW for routine ops, INTERROGATE for boundary cases, BLOCK for forbidden actions. All policy-driven, all sub-100ms."

## The Constitution

Point to the policy card on screen:

"This is the Constitution — the entire policy surface. Two allowed programs, two allowed mints, three approved recipients, and a 1 SOL autonomous limit. That's it. An operator writes this once, and every transaction the agent ever sends gets evaluated against it."

## Closing

"Sudont is an RPC sidecar. Agents don't need to change their code — they just point their SDK at our endpoint instead of a raw Solana RPC. Today it's localhost:8080. In production it'll be rpc.sudont.xyz. Same interface, same policy, same firewall."

## Architecture (if asked)

```
Agent (SDK) → Sudont Sidecar (:8080) → Solana DevNet
                    │
              ┌─────┴──────┐
              │   LiteSVM   │  ← simulation
              │  (in-proc)  │
              └─────┬──────┘
              ┌─────┴──────┐
              │   Judge     │  ← policy evaluation
              │ Constitution│
              └────────────┘
```

## FAQ Prep

**"What if the agent keeps retrying?"** — Rate limiting + escalation. After N interrogations, the agent gets hard-blocked and the operator is notified.

**"How fast is it?"** — Sub-50ms for the evaluation loop. Simulation is the bottleneck, and LiteSVM is in-process so there's no network hop.

**"What about MEV / frontrunning?"** — The sidecar can enforce private route requirements (require\_private\_route in the Constitution). Not in this demo, but it's on the roadmap.

**"Mainnet?"** — Same architecture, just change the egress RPC URL and tighten the Constitution. We're devnet-only for the demo.

**"How is this different from a multisig?"** — Speed and autonomy. Agents operate in real-time within delegated boundaries. A multisig requires human approval for every action. Sudont only intervenes when the agent exceeds its authority.