The control plane agents run through.

Not a dashboard bolted on after deployment — policy declared in code, enforced on every primitive before money moves or a tool fires.

Get your API keyRead the docs
Audit logenforced · $250 cap
  • 10:01browser.search$0.01Allowed
  • 10:14cards.create—Allowed
  • 10:22payment.charge$48.00Allowed
  • 10:23payment.charge$612.00Revoked

Paste and ship

Drop this into Cursor, Claude Code, or any agent. It reads the skill manifest and wires up Governance for you.

Agent prompt

Read https://usenaive.ai/skill.md and set up Naïve for Governance in my project.

Declare · Enforce · Revoke

Observability tells you what happened. Naïve blocks what isn't allowed — at the boundary where agents actually spend, call tools, and touch data.

01Declare

Identity, budget, and permissions in your repo.

Version agent.config.ts beside your code — hard caps, allow/deny lists, and approval thresholds. Every agent provisions from the same declarative source of truth.

  • defineAgent — identity, wallet, budget, approvals
  • defineSystem — multi-agent orchestration in one file
  • Re-runnable IaC — the millionth agent matches the first
vs Discover

Inventory agents after they're already running.

Shadow-AI scanners find what slipped past IT. Naïve provisions every agent through the control plane — you declare before anything deploys.

02Enforce

Block at the primitive boundary — in real time.

Every API call passes through Naïve first. Spends over policy wait for approval. Denied primitives never hit the wire. MCP tools scoped per session — zero standing access.

  • Hard spend limits enforced at card authorization
  • Sensitive primitives pause until a human approves
  • MCP + A2A sessions carry scoped identity per hop
vs Observe

Trace prompts and tool calls after the fact.

Log viewers replay what an agent did. Naïve is the layer agents run through — policy fires before data moves, before a tool executes, before a dollar leaves.

03Revoke

Kill access mid-flight — not in the next audit cycle.

Freeze a virtual card, terminate an MCP session, or deny a pending charge while the agent is still running. One audit log replays every primitive call with full context.

  • Revoke cards, sessions, and vault secrets instantly
  • Denied charges show as blocked — not silent failures
  • Unified log across payments, tools, and primitives
vs Secure

Authorize data access with standing roles.

Warehouse PBAC grants persist until someone revokes them. Naïve enforces purpose-bound, auto-expiring scopes at the moment of action — on real-world primitives, not just Snowflake rows.

Governance primitives that enforce — not just log.

Approvals, scoped sessions, encrypted vault, and spend-capped cards — every control enforced at the API boundary, per end-user.

Declare policy. Enforce on every call.

Agent infrastructure as code — budgets, allow/deny, and approval rules versioned in your repo, enforced by the same bearer token as every other primitive.

agent.config.ts

Declare Policy as Code

Define identity, wallet, budget, approvals, and capability allow/deny lists in a single declarative file. Provision one agent or a million from the same config — versioned beside your application code.

defineAgent
Identity · wallet · budget · approvals.
allow / deny
Primitive capability whitelists.
defineSystem
Multi-agent orchestration.
Versioned
Same policy for agent #1 and #1M.
import { defineAgent } from "@usenaive-sdk/iac";

export default defineAgent({
  wallet:    { limit: "$2,500/mo" },
  budget:    { hardCap: "$5,000" },
  approvals: { over: "$500", via: "slack" },
  allow:     ["email", "search", "payments"],
  deny:      ["wire_transfer", "trading"],
});
GET /v1/approvals

Enforce with Approvals

High-risk primitive calls block until a human approves or denies. The agent waits — denied actions never execute. Every decision streams to the unified audit log.

Policy thresholds
Over $X, require approval.
Pending queue
Slack, email, or your UI.
Block at boundary
No silent bypass.
Audit trail
Who approved, who denied.
# List pending approvals
$ naive approvals list

# Approve or deny a blocked action
$ naive approvals approve <approval-id>
POST /v1/sessions

Scope MCP Sessions

Hand agents a per-user MCP endpoint with an allow-listed tool surface. No shared master API key. Kill any session instantly while agents are running.

Per-user MCP
SSE transport per session.
Tool allow-lists
Account Kit whitelists.
Zero standing access
No shared keys.
Kill mid-flight
Revoke while agents run.
# Create a scoped MCP session for an end user
$ naive sessions create --user alice

# Revoke instantly
$ naive sessions revoke <session-id>

Build on an enforcement layer, not a log viewer.

Declare identity, money, and permissions as code — then govern every action from zero to scale with one API.

Get your API keyRead the docs