Launching the Naïve Agent SDK: Identity, payments, and standing for every agent

Agents can reason. They still cannot sign up for a service, hold a payment method, or file paperwork on their own. Every "autonomous" demo quietly keeps a human in the loop for the parts that touch the real world. Naïve is the autonomous company infrastructure built to close that gap — and today we are launching the Agent SDK, a unified developer interface that lets you give any agent identity, money, tools, and the standing to act, without building that infrastructure yourself.

The SDK is one layer above the models. Reasoning gets cheaper every quarter; identity, payments, compliance, and distribution do not. The Agent SDK unifies what agents actually need to operate — sign up, pay, incorporate, email, search, post, and orchestrate — on one credit balance, with spend limits, approvals, and a single audit log.

Four capabilities, one interface

The developer platform is organized around four ideas that map directly to how you integrate agents:

Identity — KYC-backed personas with real email, phone, and credentials. Your agent is a verified principal, not an anonymous API key.

Primitives — 100+ real-world capabilities across 14 categories. Search, comms, payments, signup, formation, orchestration, and more — each one a single call instead of a separate vendor integration.

Compute — Pick any model (text, image, video, audio) or attach a hosted runtime. Hermes, Claude Code, Codex, and Cursor each get isolated compute, memory, and browser context per agent.

Standing — The legal and financial footing an agent needs to act: a registered US company, scoped virtual cards, custom-domain email, and autonomous signup on third-party services.

The Company → Employee → Primitive model still applies. A Naïve Company is a first-class runtime object — not a PDF in someone's email. Employees (your agents) act on its behalf, and every primitive call attaches back to verified identity and governed spend.

One API for any model, any runtime

Models are interchangeable. Standing is not.

The SDK lets you route generation through any provider while keeping agent identity, cards, and accounts on the Naïve layer. Swap from one text model to another; the inbox, the card limit, and the audit trail stay put. Attach a hosted runtime when you want an agent that runs continuously — with its own memory, browser session, and tool access — rather than a single-shot completion.

That separation is the point. You choose the reasoning layer. Naïve owns the layer everything else rides on.

Give agents real-world standing

An agent without standing can draft copy. It cannot open a bank account, verify a phone number for a vendor portal, or file an LLC.

Through the SDK you can:

• Verify identity — KYC-backed personas tied to a human principal, per the /kyc primitive.
• Form a company — US LLC formation via /formation for a published $249 fee (per published docs) covering Doola formation, state filing, registered agent, and the EIN application. See the formation guide.
• Issue scoped cards — prepaid or managed virtual cards with hard spending limits, funded through checkout. See introducing cards.
• Provision email — custom-domain inboxes with DNS handled through /email.
• Sign up autonomously — one-call account creation on third-party services, so agents can register where humans would.

Standing is what turns "an agent that can talk" into "an agent that can operate."

100+ primitives, one credit balance

Every primitive your agent needs — search, comms, payments, distribution, orchestration — runs through one interface and one credit balance. No subscription stack of ten SaaS tools. Pay per call, with spend limits and approvals on every charge.

Featured primitives you can drop into any agent with a single call:

Naïve exposes 100+ primitives across 14 categories. Social distribution connects to 10 platforms per the documented enum: Twitter, LinkedIn, Instagram, Facebook, TikTok, YouTube, Threads, Pinterest, Reddit, and Bluesky. Web search is powered by Tavily when configured; Brave Search is used when Tavily is not configured.

Browse the full library at usenaive.ai/docs.

See everything. Revoke anything.

Agents that can pay and sign up need governance, not blind trust.

Every action your agents take streams to one audit log. Define custom policies for budgeting and approvals before a card charge or signup executes. Scope identity, money, and accounts per user so one tenant cannot touch another's inbox or card. When a session should stop, revoke it — the standing and the spend controls are yours, not the model's.

This is the layer between "give an agent a tool" and "let an agent run a business." Operators stay in control; agents stay in bounds.

Featured autonomous companies

The SDK ships with templates for full autonomous companies — multi-agent teams that run incorporation through operations, not single-shot tasks.

AI media channel — a faceless content operation that researches topics, produces assets, posts across platforms, and manages distribution. Pull the template and inspect the skill file:

naive pull ai_media_channel

AI automation agency — delivers client work, bills for completed tasks, and reports status without manual handoffs between tools.

AI trader — opens a brokerage connection, executes a configured strategy, and manages positions within the limits you set.

Each template includes CLI commands and a skill file your runtime can read to onboard itself. They are starting points, not guarantees — you define the budgets, approvals, and human checkpoints.

Multi-tenant agent apps

The SDK is built for products that give each end user their own agent with real-world capabilities — not one shared agent for everyone.

Three patterns we see often:

AI SEO platform for SMBs — each customer gets an agent that signs up for tools, researches keywords, and publishes content under their own identity.

AI outbound agent for SaaS companies — per-tenant domains, inboxes, and sequencer accounts. No shared card across customers.

AI voice agent for car dealerships — each location provisioned, scoped, and billed on its own.

The multi-tenant pattern is a few lines of SDK code:

npm install @usenaive-sdk/server

const alice = await naive.users.create({
  external_id: "alice_db_uuid",
  email: "alice@example.com",
});
 
const client = naive.forUser(alice.id);
await client.cards.create({ spending_limit_cents: 25000 });
await client.connections.connect("gmail", { callbackUrl });
const session = await client.session(); // per-user MCP session

Map external_id to your database user. Everything downstream — cards, connections, MCP — stays scoped to that tenant.

Get started: SDK or CLI

Two paths, same primitives:

Server SDK — embed Naïve directly in your backend. Install @usenaive-sdk/server, create users, scope clients, and open per-user MCP sessions from application code.

CLI — operate agents from the terminal or hand the CLI to a runtime. Install globally:

npm install -g @usenaive-sdk/cli

Then register, create identity, and call any primitive:

naive register
naive identity create --user usr_8f2a
naive search "latest developments in agent infrastructure"

Both paths authenticate against the same API (https://api.usenaive.ai), draw from the same credit balance, and respect the same spend limits and audit policies. Deep API reference and quickstarts live at usenaive.ai/docs.

Want a head start? Pull a business template with naive pull <template>, or browse starter projects on Vercel Templates.

How this fits the Naïve stack

The Agent SDK is the developer-facing surface of the same autonomous company infrastructure that powers Naïve Studio. Studio is the managed runtime for operators who want a CEO agent, kanban board, and chat-first control. The SDK is for builders embedding agent standing into their own products — multi-tenant SaaS, internal automation, or agent-native apps.

Naïve is partially open source. The agent harness (Hermes, MIT) and lineage from Paperclip (MIT) are open. The Naïve Platform — API, billing, primitives, Studio, and managed runtime — is proprietary. You can run orchestration components locally; production primitives are accessed through Naïve Platform.

If you are new to the category, start with What Is an Autonomous Company? A Founder's Guide — then wire your first agent with the SDK.

Every agent starts Naïve

Give it identity, money, and standing — plus the guardrails to act safely. One CLI. One SDK. One audit log.

Install the SDK, create your first user, and call a primitive. The docs are at usenaive.ai/docs. The templates are one naive pull away.