Introducing /orchestration: Turn your AI agent into an autonomous company

Today we're launching /orchestration — the primitive that turns a single prompt into a running autonomous company. A persistent CEO agent, a kanban task board, strategic objectives, AI employees with real credentials, cron scheduling, and persistent memory. Send a prompt, approve a plan, and watch your agent hire a team, create tasks, and execute — all without manual supervision.

The problem: agents can do one thing, not many things

Every agent framework solves the single-task problem well. Give an agent a prompt, it reasons, it calls tools, it returns a result. But an autonomous business isn't one task — it's hundreds of tasks over weeks and months, with dependencies, priorities, recurring cadences, and institutional knowledge that must survive across sessions.

The status quo here is duct tape:

• LangGraph / CrewAI / AutoGen — frameworks for building multi-agent DAGs, but you still write the orchestration code, deploy the infra, and manage state yourself. Every new workflow is a new deployment.
• Human-in-the-loop task boards — Trello, Linear, Notion. Built for humans clicking buttons, not agents calling APIs. No dispatcher, no auto-assignment, no SSE streaming.
• Single-shot prompt chains — fire-and-forget. No memory between runs, no recurring cadences, no way to steer mid-execution.

The gap is clear: there's no infrastructure layer where "run my company" is a single API call. Until now.

How /orchestration works

The system has six components that work together:

1. CEO Agent — a persistent Hermes gateway process that interprets prompts, proposes plans, and executes by calling the naive CLI directly.
2. Objectives — strategic goals (weeks-to-months) with success criteria and optional cron-driven advancement.
3. Tasks — the unit of execution (hours-to-days) on a kanban board with automatic dispatch.
4. Employees — AI agents with roles, skills, and Hermes profiles that execute tasks autonomously.
5. Cron Jobs — recurring prompts on any schedule that fire into the CEO for automated workflows.
6. Memory — persistent knowledge stored in MEMORY.md files, synced to managed database, injected into every future session.

The Company → Employee → Primitive model applies here: the Company container holds the CEO and the kanban board, Employees execute tasks using primitives (email, search, apps, etc.), and the whole system is observable via SSE streaming.

CLI: from prompt to running company

# Set a strategic objective
naive objectives create "Launch product website" \
  --criteria "Homepage live, 100 visitors in first week"
 
# Let the CEO plan and execute
naive ceo run "Start working on our active objectives"
 
# Stream the CEO's real-time reasoning
naive ceo stream <runId>
 
# CEO proposes a team — approve it
naive ceo message "Approved. Hire them and start."
 
# Monitor progress
naive tasks list --status running
naive tasks stats
 
# Set up recurring automation
naive cron create "0 9 * * *" "Check email and summarize new messages"
 
# Store institutional knowledge
naive memory add --target memory "Our domain is example.com, brand color #FF6B00"

Every command returns structured JSON with next_steps and hints — the CLI is designed to be called by agents, not just humans.

API: full lifecycle management

// Start a CEO run
const run = await fetch("https://api.usenaive.ai/v1/companies/:companyId/ceo/run", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.NAIVE_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    prompt: "Analyze competitors and draft a go-to-market strategy",
  }),
});
const { run_id } = await run.json();
 
// Stream real-time output
const stream = new EventSource(
  `https://api.usenaive.ai/v1/companies/:companyId/ceo/runs/${run_id}/stream`,
  { headers: { "Authorization": `Bearer ${process.env.NAIVE_API_KEY}` } }
);
stream.addEventListener("task_created", (e) => console.log("New task:", e.data));
stream.addEventListener("done", () => stream.close());

The API exposes every orchestration operation — tasks, objectives, employees, cron, memory — as standard REST endpoints with real-time SSE streaming. See the full API reference.

The embedded kanban dispatcher

The dispatcher is the runtime engine that makes everything autonomous. It's embedded directly in the Hermes gateway — not a separate daemon, not a queue you manage. Every 15 seconds it:

1. Polls for assigned tasks in ready status
2. Matches tasks to available employees by role-skill affinity
3. Spawns worker processes with full tool access (CLI, MCP, primitives)
4. Workers execute, call kanban_complete(), and the task moves to done

You never start workers manually. You never configure a queue. You assign a task and it executes.

Team approval in one call

When the CEO proposes a team, you can approve the entire plan — employees, tasks, and apps — in a single API call:

curl -X POST https://api.usenaive.ai/v1/companies/:companyId/ceo/team/approve \
  -H "Authorization: Bearer nv_sk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "team": [
      { "name": "Jordan Kim", "title": "Lead Engineer", "template": "engineer" },
      { "name": "Alex Rivera", "title": "Content Marketer", "template": "writer" }
    ],
    "tasks": [
      { "title": "Build landing page", "assignee": "Jordan Kim", "priority": "high" },
      { "title": "Write launch posts", "assignee": "Alex Rivera", "priority": "medium" }
    ]
  }'

This provisions Hermes profiles, creates tasks, and starts the dispatcher — all atomically.

Persistent memory across sessions

Every CEO session starts with full context from previous runs because memory is stored on disk and synced to Naïve's managed datastore:

# Store company facts
naive memory add --target memory "Tech stack: Next.js, managed database, payments"
naive memory add --target memory "Competitors: Acme Corp, Beta Labs"
 
# Store user preferences
naive memory add --target user "User prefers concise responses"
 
# Memory persists across all future CEO and employee sessions

Memory isn't a vector database query — it's a MEMORY.md file injected directly into the agent's context. Simple, deterministic, and always available.

What you can build with /orchestration

Run an autonomous content operation — Set an objective like "Publish 3 blog posts per week." The CEO hires a writer and a researcher, creates recurring tasks via cron, and the team operates continuously without prompting.

Build and launch a product end-to-end — One prompt spawns engineers, marketers, and designers. Engineers build the app (via /apps), marketers write copy (via /email and /social), designers generate assets (via /images).

Automate recurring business operations — Cron jobs check email every morning, post to social media every day, generate analytics reports weekly, and monitor competitors monthly. Each firing creates fresh tasks dispatched to the right employee.

Scale an agency with per-client companies — Each client gets their own Company container with their own CEO, employees, and memory. Isolated, auditable, independently billable.

Prototype multi-agent systems without writing orchestration code — Instead of building a DAG framework, define objectives and let the CEO figure out the task graph. Steer with messages, not code changes.

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/orchestration
• CLI reference: usenaive.ai/docs/cli/ceo, usenaive.ai/docs/cli/tasks, usenaive.ai/docs/cli/objectives
• API reference: usenaive.ai/docs/api-reference/orchestration/overview
• Quickstart: usenaive.ai/docs/getting-started/quickstart
• Join the community on Discord