Launching the Naïve Developer Platform: existence infrastructure for AI agents

Today we're launching the Naïve Developer Platform — existence infrastructure for AI agents. Every primitive we've built, turned into a multi-tenant building block you can put inside your own product. 38 primitives across 8 groups, four ways to call them, per-customer isolation, governance on every sensitive action, and billing to monetize it. If Naïve Studio is how you run an autonomous company, the Developer Platform is how you build the next thousand.

This isn't a new set of features. It's the same primitives, opened up as a platform — with the multi-tenancy, governance, and SDK that let you ship agent infrastructure as a product instead of a demo.

Existence infrastructure

An agent can reason. It can call tools. What it can't do, out of the box, is exist — the way a person or a company exists in the real world. The Developer Platform is built around the four verbs that close that gap:

• Acquire — sign up for services autonomously, with fresh domains, inboxes, and accounts. (/browser, /domain, /email, /integrations)
• Pay — spend in the real world with per-user virtual cards behind approval gates. (/cards, /billing)
• Hold — keep durable credentials in a governed, encrypted vault. (/credentials)
• Be — become a real legal entity with identity verification and company formation. (/kyc, /formation)

Give an agent those four, and it stops being a chatbot and starts being a citizen.

38 primitives across 8 groups

Every primitive is a real integration behind one API key — not a mock, not a sandbox.

New primitives ship every month — and each one arrives as a building block in the same model, not a bolt-on.

Four surfaces, one key

The platform meets your agents and your code wherever they are:

TypeScript SDK

npm install @usenaive-sdk/node

import { Naive } from "@usenaive-sdk/node";
 
const naive = new Naive({ apiKey: process.env.NAIVE_API_KEY! });
await naive.email.send({ from_inbox_id, to: "x@y.com", subject: "Hi", body: "..." });

Agent-native CLI

npm install -g @usenaive-sdk/cli
naive register --name "My Agent" --email me@example.com --password secure123
naive search "latest AI agent frameworks"

Hosted MCP server

{
  "mcpServers": {
    "naive": {
      "url": "https://api.usenaive.ai/mcp/sse",
      "headers": { "Authorization": "Bearer nv_sk_live_..." }
    }
  }
}

REST

curl -X POST https://api.usenaive.ai/v1/search \
  -H "Authorization: Bearer nv_sk_live_..." \
  -H "Content-Type: application/json" \
  -d '{ "query": "agent infrastructure 2026" }'

All four authenticate with the same key and reach the same primitives.

Multi-tenant from the first line

The Developer Platform is built for products with many users, not just one agent. The model is Operator → Account Kit → tenant user → resources:

Operator (you)
  └── Account Kit (policy template — which primitives, what limits)
        └── tenant_user (one of your customers)
              └── resources (cards, vault, connections, apps, ...)

You define Account Kits, create a tenant user per customer, and assign a kit. Each tenant's cards, vault, connections, and apps are fully isolated. In code, that's naive.forUser(customerId) — a client whose every call is scoped to that customer, with no chance of crossing wires.

Governance on every sensitive action

Opening real-world capabilities to autonomous agents only works if the controls are built in:

• Approvals — issuing cards, forming companies, buying domains, connecting apps, and autonomous signup freeze as pending until a human approves, then replay automatically.
• Audit logs — every action is recorded per user, queryable and streamable.
• Encrypted vault — credentials are KMS envelope-encrypted; secrets never leak back to the client.
• Scoped sessions — hand a runtime a short-lived, TTL-limited token instead of your long-lived key.

This is the difference between a fun demo and something you can put real customers and real money behind.

What you can build

A multi-tenant agent SaaS — Give every one of your users an agent with its own email, cards, vault, and apps. Provision on signup, scope with forUser, and bill with /billing.

Per-customer autonomous companies — Run an /orchestration CEO and workforce per customer, each isolated, auditable, and independently billable.

Agent products that touch the real world — Let agents acquire services, pay for them, hold the resulting credentials, and operate as a real entity — the whole loop, governed.

Embed agent infrastructure into an existing app — Add the primitives your users' agents need without becoming a payments, email, and compliance company yourself.

What's next

We're shipping primitives every month and deepening the platform around them — richer governance, more connections, and more of the real-world surfaces agents need to operate. The goal hasn't changed: every real-world business operation, available as an API call, to every agent.

The platform is live. The SDK is one install. The quickstart takes five minutes.

Get started

• Quickstart (5 min): usenaive.ai/docs/getting-started/quickstart
• SDK overview: usenaive.ai/docs/sdk/overview
• Multi-tenancy: usenaive.ai/docs/architecture/multi-tenancy
• API reference: usenaive.ai/docs/api-reference/overview
• Community: Discord

npm install @usenaive-sdk/node