Naïve Inside Your Agent Framework (Governed Tools, Any Orchestrator)

Naïve inside your agent framework means keeping the orchestrator you already chose and adding a governed tool layer underneath it. LangGraph runs the graph; Vercel AI SDK runs generateText; CrewAI runs the crew — Naïve is autonomous company infrastructure that handles what happens when the model tries to spend money, send email, connect an app, or read a vaulted secret.

This post is the map, not a per-framework tutorial. The docs integrations index holds the step-by-step guides; here is the mental model that makes every guide the same story with different adapter code.

What does each layer own?

The split matters because teams often try to bolt payment and OAuth onto the framework. That duplicates work and leaves policy in prompts. Naïve keeps orchestration in your stack and moves real-world authority to a governance gateway that checks every tool call server-side — the same model described in The Governed Agent Profile.

How does the pairing work?

  Your framework (orchestration)          Naïve (governed tools)
  ─────────────────────────────          ───────────────────────
  model picks a tool
        │
        ▼
  framework invokes tool  ──────────▶  gateway checks Account Kit
                                              │
                                         execute · 202 pending_approval · forbidden
                                              │
                                         audit log · revocable session

Two wiring patterns cover every guide in the index:

1. In-process agentTools() (TypeScript)

Best when the agent runs in a backend you control:

import { Naive } from "@usenaive-sdk/server";
 
const naive = new Naive({ apiKey: process.env.NAIVE_API_KEY! });
const user = await naive.users.create({ email: "customer@acme.com" });
const kit = naive.forUser(user.id).agentTools();
 
// Adapt kit.tools into LangGraph / AI SDK / OpenAI Agents format;
// dispatch with kit.handle(name, input) — AccountKit-gated server-side.

See LangGraph or Vercel AI SDK for the exact adapter.

2. Scoped MCP session (any language)

Best for Python stacks, edge runtimes, and untrusted hosts:

const client = naive.forUser(user.id);
const session = await client.session({ ttlMs: 15 * 60 * 1000 });
// session.mcp.url + session.mcp.headers → your framework's MCP client

Python guides (CrewAI, Pydantic AI, AutoGen, …) mint the session over REST and attach it to the framework's MCP transport. Details: delegated, revocable MCP sessions.

Which guide matches your stack?

Every row follows the same control-plane setup (Account Kit + user) and differs only in adapter code:

The full table — Mastra, Cloudflare Agents, AutoGen, Google ADK, Semantic Kernel, LlamaIndex, Claude Agent SDK, Agno, DSPy, smolagents, Letta — lives on the integrations overview.

Where does the runtime run?

Framework choice and runtime hosting are separate decisions. Hosted vs bring-your-own runtime compares both paths; the default recommendation is BYO: inject governed tools into the loop you already ship. Naïve-hosted microVMs are optional when you want managed compute with credentials injected at boot.

What stays enforced?

No matter which framework or transport you pick:

• Identity — every action runs as a specific tenant user.
• Policy — the Account Kit bounds primitives and apps.
• Spend — cards and credits respect kit limits; the model cannot raise its own ceiling.
• Human-in-the-loop — sensitive actions freeze as approvals until a human decides.
• Revoke — suspend the agent profile or kill an MCP session in one call.

Where to start

1. Read Building AI Agents Into Your SaaS if you have multiple customers — forUser(id) is the isolation boundary every framework guide assumes.
2. Pick the integration guide that matches your orchestrator.
3. Wire one gated action end to end — connect an app, issue a capped card, or send from a per-user inbox — before widening the kit.

For a full tutorial using MCP, see Build a bring-your-own-agent platform.