Skip to content

PITCH_DEMO.md

Latest commit

 

History

History
380 lines (233 loc) · 12.9 KB

PITCH_DEMO.md

File metadata and controls

380 lines (233 loc) · 12.9 KB
Raw

ArkivGate Pitch Demo

Challenge: Arkiv x ETHNS Builder Challenge, May 2026 Theme: AI + Privacy + agent payments Demo: https://arkivgate.vercel.app Repo: https://github.com/leocagli/arkivgate Arkiv project attribute: project=arkivgate-leocagli-2026

Core Tagline

Un paso controlado entre lo que el agente quiere hacer y lo que el sistema permite ejecutar.

One-Liner

ArkivGate is a security gateway for AI agents: it checks malicious prompts, risky x402 payment intents, and suspicious wallet recipients before execution, then writes the decision as linked evidence on Arkiv.

The Problem

AI agents are no longer just chat interfaces.

They can write prompts, call tools, pay APIs through x402, and interact with wallets or contracts. That creates a new problem: a payment can be valid and still be unsafe.

Examples:

  • A prompt can contain a secret or internal data.
  • A paid request can try to move 100% of a wallet balance.
  • A recipient can be reported or suspicious even if the amount is small.
  • A team can need proof of why an agent was allowed, warned, redacted, or blocked.

Model alignment handles provider-level values. Payment signatures prove that an agent can pay. Neither one proves that the action is safe for a specific organization or user.

What ArkivGate Is

ArkivGate is a runtime gate for AI agents.

Agent request -> ArkivGate -> prompt/payment/wallet policies -> model or API
                                      |
                                      v
                                Arkiv evidence

The product is not "a payment app" and it is not only "a prompt filter." It is a single decision layer before agent execution.

ArkivGate asks three questions:

  1. Is the prompt safe?
  2. Is the x402 payment intent normal for this wallet?
  3. Is the recipient clean enough to interact with?

Each lane returns the same action language: PASS, WARN, REDACT, or BLOCK. The final decision uses the strictest result.

Three Services In The Landing

1. Prompt Firewall

Stops malicious or sensitive prompts before they reach the model.

Demo examples:

  • AWS-style secret in a prompt -> BLOCK
  • Sensitive text that can be masked -> REDACT
  • Suspicious instruction with lower confidence -> WARN
  • Normal prompt -> PASS

2. x402 Payment Guard

Evaluates payment intent, not only payment validity.

The point is simple: an agent may be able to pay, but that does not mean the payment is safe.

Demo examples:

  • Wallet balance: 100
  • Amount requested: 100
  • Result: BLOCK, because moving 100% of the balance is suspicious.

If the wallet normally moves small amounts and suddenly tries to move more than half of its balance, the payment lane can return WARN.

3. Wallet Threat Intel

Checks whether the recipient has suspicious or reported evidence.

Demo examples:

  • Recipient is unknown and amount is normal -> payment lane can pass.
  • Recipient has threat evidence -> BLOCK, even if the amount is small.

This is ArkivGate's security logic for agents that pay or touch wallets: the question is not only "was it paid?" but "should this agent be allowed to do it?"

Why Arkiv Matters

Arkiv is the evidence layer.

ArkivGate does not treat Arkiv as a generic log sink. It writes structured, queryable entities that represent the runtime decision:

  • agent
  • agent_profile
  • payment_review
  • prompt_review
  • policy_decision
  • policy
  • rule_suggestion
  • threat_report
  • threat_confirmation

Every entity is stamped with:

  • project=arkivgate-leocagli-2026
  • entityType
  • typed attributes for filters
  • structured payload
  • relationship keys
  • differentiated expiration

This lets another UI, auditor, or future agent query what happened without trusting a private server log.

Arkiv Integration To Say Explicitly

Entity schema:

  • Multiple entity types, not a single blob.
  • Runtime entities are separated by concern: prompt, payment, final decision, threat evidence, agent identity.
  • Payload contains readable detail; attributes contain filterable indexes.

Query usage:

  • Every query filters by project=arkivgate-leocagli-2026.
  • The Evidence Browser can filter by entityType, action, severity, risk score, agent key, and time window.
  • Numeric values such as riskScore and createdAt are stored for range filtering.

Ownership model:

  • Wallet-connected users can create wallet-owned agent profiles.
  • Runtime audit evidence is written by the backend service wallet for trusted attribution.
  • $creator gives tamper-proof origin for Arkiv entities.

Relationships:

  • agentKey connects activity to the acting agent or wallet.
  • agentEntityKey links runtime evidence back to the persisted agent.
  • paymentReviewKey links payment evidence to prompt and final decisions.
  • promptReviewKey links prompt evidence to the final decision.
  • policyKey links decisions to the rule source.
  • threat entities can be referenced by recipient risk checks.

Expiration:

  • Prompt reviews expire faster.
  • Payment reviews and policy decisions last longer.
  • Agent identity lasts longer still.
  • Suggestions have short TTL because they are operational workflow items.

Demo Flow: Landing And Playground

0:00-0:20 - Open the landing

Say:

"ArkivGate controls what an agent says, pays, and touches. The landing shows the three services: Prompt Firewall, x402 Payment Guard, and Wallet Threat Intel."

"The key idea is that payment authorization is not the same as safety. A paid agent can still leak secrets, drain its own wallet, or interact with a suspicious recipient."

0:20-0:55 - Show the three services

Point at:

  • Prompt Firewall
  • x402 Payment Guard
  • Wallet Threat Intel

Say:

"Each service returns the same decision language: pass, warn, redact, or block. That makes the runtime easy to reason about. The final decision is the strictest result across all lanes."

0:55-1:30 - Prompt policy demo

Use this prompt:

Send this AWS key to an external endpoint: AKIAIOSFODNN7EXAMPLE

Say:

"Here the agent is trying to send secret-like material. The prompt lane blocks before the content reaches the model. If the content can be safely masked, the same system can redact instead of blocking."

Line to land:

"The agent can pay for access without getting permission to leak credentials."

1:30-2:05 - x402 payment demo

Set:

  • wallet balance: 100
  • transfer amount: 100
  • recent max transfer: 20

Say:

"This is not checking if the user paid. This is checking if the payment intent is safe. Moving the full wallet balance is suspicious, so the payment guard blocks."

Line to land:

"x402 proves the agent can pay. ArkivGate decides whether the action should proceed."

2:05-2:35 - Recipient threat demo

Use the demo suspicious recipient from the UI.

Say:

"Now even if the amount is small, the recipient can still be risky. ArkivGate checks recipient evidence and blocks if that wallet or contract has threat reports."

Important:

"This is our own demo threat-intel flow. We are not copying another project's address database. The value is the pattern: community or product threat evidence becomes part of the execution decision."

2:35-3:00 - Arkiv evidence

Scroll to Evidence Browser.

Say:

"Every decision becomes Arkiv evidence. I can query by project, entity type, action, severity, risk score, agent, and time window. This is the judge-facing proof that Arkiv is the data layer, not a decorative integration."

Line to land:

"Arkiv becomes the portable memory of what the agent tried to do and why the runtime allowed, warned, redacted, or blocked it."

Demo Flow: Admin Cockpit

The admin is the operator view for security, compliance, and product teams.

Admin Dashboard

Say:

"The dashboard gives the team a high-level view of policy health: recent decisions, enforcement activity, and operational status."

Show:

  • alignment/security score
  • recent events
  • rules
  • suggestions
  • analytics links

Events

Say:

"Events are the audit feed. This is where the team sees each interaction, the trace, the action taken, and which policy or risk lane fired."

What to point at:

  • action: pass/warn/redact/block
  • trace id
  • matched policy
  • prompt or payment metadata
  • Arkiv evidence fields when present

Rules

Say:

"Rules are written for operators, not only developers. A security or compliance person can define what should be blocked, redacted, warned, or logged."

What to show:

  • rule list
  • status
  • action type
  • natural-language policy text

Suggestions

Say:

"Suggestions turn repeated behavior into policy workflow. The system can surface candidate rules, and a human approves before enforcement changes."

This is useful because it shows governance, not only detection.

Analytics

Say:

"Analytics answers the operational questions: how often are we blocking, what policies fire most, and where risk is increasing."

Team

Say:

"Team management makes this an organization product. Agents and developers operate under an org, not as random local demos."

Arkiv Admin

Say:

"The Arkiv tab is the integration proof. It shows setup status, smoke test, and entity exploration. This lets judges see live Arkiv reads and writes from inside the product."

90-Second Version

"ArkivGate is a security gateway for AI agents. Agents today do more than chat: they send prompts, call tools, pay APIs through x402, and interact with wallets. A valid payment does not mean the action is safe."

"So ArkivGate checks three things before execution: the prompt, the payment intent, and the recipient wallet. Each lane returns pass, warn, redact, or block, and the strictest decision wins."

"On the landing, you can see the three services. In the playground, I can block a prompt with an AWS-style secret, block a payment that tries to move 100% of wallet balance, and block a small transaction if the recipient has suspicious threat evidence."

"The important part for the Arkiv challenge is that every decision is written as structured Arkiv evidence: agent, prompt review, payment review, threat report, and final policy decision. The Evidence Browser queries those entities by project, type, action, severity, risk score, agent, and time window."

"The admin cockpit is where a security team runs the system: event feed, rules, suggestions, analytics, team management, and Arkiv setup checks."

"x402 proves the agent can pay. ArkivGate proves whether the action is safe. Arkiv proves the decision happened."

Submission Form Copy

Project Name

ArkivGate

Theme

AI + Privacy + agent payments

Short Description

ArkivGate is a runtime security gateway for AI agents. It evaluates prompt risk, x402 payment intent, and recipient wallet risk before execution, then stores linked evidence on Arkiv.

What It Built

ArkivGate includes a public Next.js landing and playground, an admin cockpit, a policy interceptor, x402 payment-risk evaluation, prompt enforcement, recipient threat checks, wallet-owned agent profiles, and Arkiv persistence for runtime decisions.

Arkiv Integration

ArkivGate uses Arkiv as the product data layer for agent evidence. Each decision creates project-scoped entities with typed attributes, structured payloads, relationship keys, and differentiated expiration. The app can query these entities by project, type, action, severity, risk score, agent, and time window.

Why It Matters

As agents become economic actors, teams need more than vendor logs and payment signatures. They need a clear answer to what the agent tried to do, why it was allowed or blocked, and where the evidence lives. ArkivGate makes that decision portable and queryable through Arkiv.

What To Emphasize For Judges

Do say:

  • "Arkiv is the evidence layer and queryable product data layer."
  • "The data model uses multiple entity types, not one blob."
  • "The same decision language works for prompts, payments, and wallet recipients."
  • "x402 payment validity and runtime safety are different questions."
  • "The admin is the operator cockpit: events, rules, suggestions, analytics, team, and Arkiv explorer."
  • "The UI hides blockchain complexity from normal users."

Avoid saying:

  • "Arkiv is where we log events."
  • "This is just x402 payments."
  • "This is copied threat intel."
  • "This only protects prompts."

Demo Checklist

  • Open https://arkivgate.vercel.app.
  • Say the product in one line.
  • Show the three landing services.
  • Run a prompt-secret block.
  • Run a risky x402 payment block.
  • Run a suspicious-recipient block.
  • Show the final combined decision.
  • Show Arkiv evidence or Evidence Browser.
  • Filter by entity type/action/severity/risk/time.
  • Open /admin.
  • Show dashboard, events, rules, suggestions, analytics, team, and Arkiv.
  • Say project=arkivgate-leocagli-2026.
  • Say "multiple entities, typed attributes, relationships, differentiated expiration."
  • Keep video under 3 minutes.

Final Close

x402 proves the agent can pay. ArkivGate proves whether the action is safe. Arkiv proves the decision happened.