Introducing /integrations: Connect your agent to any SaaS

🚧 Capabilities evolving — roadmap preview. /integrations is not yet generally available in the public Naïve API. The surfaces, names, and parameters described below are illustrative of the direction the platform is heading and may change before launch. For what's live today, see usenaive.ai/docs.

Today we're launching /integrations — the Naïve primitive that connects an AI Employee to 100+ SaaS tools and CMS platforms. One auth flow per integration. One discovery call to enumerate actions. One execute surface to run them. The fastest path from Employee to working SaaS automation, without re-implementing each integration by hand.

The problem: every autonomous business eventually needs SaaS

A real autonomous business needs to act on real tools. Post to Slack, open Linear issues, push code to GitHub, update a Webflow page, sync a Shopify catalog, log to HubSpot. The status quo is two bad options:

• One-off integrations, hand-built per service — six months of integration work, a perpetual maintenance tax, and the constant feeling that other teams' agents have a bigger surface than yours.
• General-purpose tool registries (Composio, Pica, Pipedream) — strong integration coverage, but you're now bridging two runtimes (your agent's tool surface + their tool surface) and credential models.

The reason it's stayed hard is that integration coverage and runtime-native binding are usually trade-offs. Tool registries optimize for coverage; runtime providers optimize for binding. With /integrations, both are runtime calls in the same surface — coverage from the underlying registry, binding from the Naïve runtime.

How /integrations works

The workflow is three steps:

1. Authorize — get_integration_auth_url returns a hosted OAuth page. The operator clicks through. Tokens land in /credentials, scoped to the Company.
2. Discover — check_integrations lists what's connected. get_integration_tools returns the schema for actions on a specific integration.
3. Execute — execute_integration runs an action with structured parameters. Returns are typed runtime objects.

Two ways to call: prompt or code

1. Natural language

naive integrations exec slack post-message \
  --channel "#launches" \
  --prompt "Announce the /integrations launch with a link to the docs"

The CLI resolves the integration, picks the right action, structures the parameters, and posts.

2. Code

const headers = {
  Authorization: `Bearer ${process.env.NAIVE_API_KEY}`,
  "Content-Type": "application/json",
};
 
// Discover what's available
const tools = await fetch(
  "https://api.usenaive.ai/v1/integrations/slack/tools",
  { headers },
).then((r) => r.json());
// tools[i].name, tools[i].description, tools[i].parametersSchema
 
// Execute an action
const result = await fetch(
  "https://api.usenaive.ai/v1/integrations/slack/execute",
  {
    method: "POST",
    headers,
    body: JSON.stringify({
      action: "post_message",
      params: {
        channel: "#launches",
        text: "We just shipped /integrations 🚀",
      },
    }),
  },
).then((r) => r.json());

Every execution is logged against the calling Employee. The audit trail is queryable per-Employee, per-integration, per-action.

Runtime tool discovery

The reason check_integrations and get_integration_tools exist as primitives is that integration coverage changes weekly. New services are added; existing services ship new actions; deprecated actions are removed. Hard-coding the tool list into the Employee's prompt freezes the Employee's capabilities at deploy time.

Instead, Employees discover available tools at runtime. The agent loop:

# Step 1: see what's connected
naive integrations list
# → slack, github, linear, shopify, webflow
 
# Step 2: pick one and learn its actions
naive integrations tools linear
# → create_issue, list_issues, update_issue, ...
 
# Step 3: execute
naive integrations exec linear create_issue \
  --team ENG \
  --title "Investigate /integrations error rate"

This is the same pattern Naïve uses for its own primitive catalog — the meta-tool naive_search discovers, naive_tool_help describes, naive_execute runs. The two surfaces are uniform, which means the same agent loop works for native primitives and third-party integrations.

API-first when available, /browser fallback when not

For services with public APIs (Slack, GitHub, Linear, Notion, Shopify, Webflow, etc.), /integrations calls the API directly. For services without a useful API but a clean web UI, the runtime falls back to /browser:

# Runtime auto-falls back to /browser if no API path exists
naive integrations exec vendor_portal_x download_invoice \
  --invoice-id INV-2026-0418

The agent doesn't need to know which path is being taken. The runtime picks the cheaper, faster, more-reliable option when both work.

What you can build with /integrations

Build agent-native team tooling — Employees post to Slack, open Linear issues, push code to GitHub, update Notion docs — all from one runtime call. Compose with /email for cross-channel workflows.

Run autonomous ecommerce ops — Compose /integrations with Shopify, Webflow, and /cards so a storefront Employee can update inventory, change pricing, fulfill orders, and pay vendors — without a person in the dashboard.

Sync customer data across CRMs and analytics — Pull from HubSpot, push to Snowflake, mirror to Mixpanel. Every action audit-logged per-Employee.

Run autonomous content ops on existing CMSes — Pair /integrations (Webflow / Ghost / WordPress) with /research, /image, and /social to publish, distribute, and measure — across the same CMS your human team uses.

Bridge to the long tail via /browser — When the right tool isn't on the supported list, the runtime falls back to /browser with /credentials — the same execute surface, different underlying path.

Get started

Drop this starter prompt into any coding agent to wire up Naïve:

Read https://usenaive.ai/skill.md and use it to set up Naïve in my project.

• Read the docs: usenaive.ai/docs/getting-started/connections
• Quickstart: usenaive.ai/docs/getting-started/quickstart
• Background reading: Composio, Pica, and Pipedream for context on the agent-tool-registry landscape.
• Join the community on Discord