Install Cognitive Workflows Into Any Surface Area With a Few Lines of Code

Now Any Developer Can Install Cognitive Workflows Into Any Surface Area With a Few Lines of Code

We just shipped External API V1.

It's the Twilio moment for AI employees.

Any developer can now invoke Cerebrals programmatically with a few lines of code.

No enterprise sales calls. No custom integrations. No months-long implementations.

Just an API key and a simple HTTP request.

What We Built

An external API that lets third-party developers embed Cerebrals into their own applications.

Think Twilio's model:

• One clean endpoint
• API key authentication
• Developer controls sessions and identity
• Usage-based billing

But instead of sending SMS, you're invoking AI employees.

The Code

const response = await fetch('https://api.cerebralos.com/v1/cerebrals/cerebral_abc123/message', {
  method: 'POST',
  headers: {
    'X-API-Key': 'sk_live_your_api_key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    message: "What's the status of order 1234?",
    session_id: "user-abc-123",
    customer_id: "cust_8f2a"
  })
});

const data = await response.json();
console.log(data.data.message); // "Order 1234 shipped on Feb 23..."

That's it.

A few lines to add a customer service Cerebral to your app. A few lines to add a medical billing Cerebral to your EMR. A few lines to add a data analyst Cerebral to your dashboard.

Why This Matters

Before External API V1: You had to use Cerebral OS to use Cerebrals. Which meant hosting on our infrastructure, using our UI, following our workflows, and enterprise deployment cycles.

After External API V1: Cerebrals work wherever you need them — in your mobile app, website chat widget, Slack workspace, internal tools, customer portal, support desk, CRM, or anywhere with internet access.

Developers control where the Cerebral appears, what UI wraps it, how users authenticate, what context gets passed, and when to invoke it.

We provide the AI employee infrastructure, action execution across integrations, memory and context management, governance and safety rails, and usage tracking and billing.

How It Actually Works

Step 1: Get an API key

Log into Cerebral OS → Developers → API Keys → Create Key

Step 2: Choose a Cerebral

Pick which AI employee you want to invoke and get its ID: cerebral_abc123

Step 3: Make the call

POST /v1/cerebrals/:cerebralId/message
X-API-Key: sk_live_...

{
  "message": "user's question or request",
  "session_id": "unique session identifier",
  "customer_id": "your customer ID",
  "identity": {
    "email": "user@example.com",
    "name": "Jane Doe",
    "role": "customer"
  },
  "metadata": {
    "order_id": "1234",
    "source": "mobile-app"
  }
}

You get back:

{
  "success": true,
  "data": {
    "message": "The Cerebral's response",
    "session_id": "user-abc-123",
    "execution_id": "exec_xyz",
    "metadata": {
      "model": "gpt-4o-mini",
      "tokens_used": 312,
      "actions_executed": 1,
      "governance_status": "approved"
    }
  }
}

What Developers Can Build

Shopify Store Widget

async function handleCustomerQuestion(question, orderId) {
  const response = await fetch('https://api.cerebralos.com/v1/cerebrals/cerebral_cs/message', {
    method: 'POST',
    headers: {
      'X-API-Key': process.env.CEREBRAL_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      message: question,
      session_id: `shopify-${orderId}`,
      metadata: { order_id: orderId }
    })
  });
  return await response.json();
}

Healthcare EMR Integration

async function processClaim(claimData) {
  const response = await fetch('https://api.cerebralos.com/v1/cerebrals/cerebral_billing/message', {
    method: 'POST',
    headers: {
      'X-API-Key': process.env.CEREBRAL_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      message: "Process this insurance claim",
      session_id: `claim-${claimData.id}`,
      customer_id: claimData.patient_id,
      metadata: { claim: claimData }
    })
  });
  return await response.json();
}

Slack Bot

app.message(async ({ message, say }) => {
  const response = await fetch('https://api.cerebralos.com/v1/cerebrals/cerebral_support/message', {
    method: 'POST',
    headers: {
      'X-API-Key': process.env.CEREBRAL_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      message: message.text,
      session_id: message.user,
      identity: { email: message.user_email, name: message.user_name, role: "employee" }
    })
  });
  const data = await response.json();
  await say(data.data.message);
});

Session Management

Sessions are stateful. The Cerebral remembers context within a session:

// First message
await cerebral.message({ message: "What's my order status?", session_id: "user-123" });
// Response: "Which order? You have 3 recent orders."

// Follow-up in same session
await cerebral.message({ message: "The most recent one", session_id: "user-123" });
// Response: "Order #5678 shipped yesterday..."

Each session maintains conversation history, user identity, metadata context, action results, and execution state.

Identity and Permissions

You control who the Cerebral is serving:

{
  "identity": {
    "email": "jane@example.com",
    "name": "Jane Doe",
    "role": "customer"
  }
}

The Cerebral uses this for permission checks, data access, personalization, and audit trails.

The Developer Experience

No SDKs required — just HTTP requests. Standard REST. Bearer auth. JSON everywhere. Stateful sessions. Rich metadata. Standard HTTP error codes.

Pricing

Pay per usage: per message sent, per action executed, per token consumed. No minimums. No seat licenses. No enterprise contracts. Start with $0. Scale to millions of requests.

The Twilio Parallel

Twilio did this for communications. Before Twilio, you needed telecom infrastructure, carrier agreements, and months to send one SMS. After Twilio: twilio.messages.create(to="+1234567890", body="Hello") — every app could send SMS.

We're doing this for AI employees. Before External API, you needed AI infrastructure, LLM integrations, action execution layers, governance and safety, and months to deploy one AI employee. After External API V1: a few lines of code, and every app can have AI employees.

Getting Started

1. Create a Cerebral in Cerebral OS
2. Get an API key from Developers → API Keys
3. Make your first call:

curl -X POST https://api.cerebralos.com/v1/cerebrals/YOUR_CEREBRAL_ID/message \
  -H "X-API-Key: sk_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"message": "Hello", "session_id": "test-123"}'

4. Integrate and ship.

The infrastructure is ready. Start building.