Skip to main content
The brain of every AI agent is where its decisions are made. In most agents, that brain is closed — a black box that takes suggestions and produces outputs. You can talk to the agent. You can’t talk to it about how it thinks. Apollo-1 is different. Its brain is symbolic, structured, and open. You can see how it thinks. You can change how it thinks. You can ask it why it did what it did and get a real answer. You can tell it to behave differently and know that it will — deterministically, permanently, in every conversation where that situation arises. This is what it takes to trust an agent with real responsibility.

Messaging API

Send messages to AI agents and receive responses via REST or WebSocket streaming.

Agent Builder API

Create and configure AI agents with tools, knowledge bases, rules, and integrations.

CLI

Build and manage agents from your terminal. Local-first development workflow.
Two different things are emerging under the name “agent.”Open-ended agents work for users. Coding assistants, computer-use agents, personal AI. You’re the principal. If the agent interprets your intent slightly differently each time, that’s fine. You’re in the loop. You’ll correct it. Flexibility is the point.Task-oriented agents work on behalf of entities. An airline’s booking agent. A bank’s support agent. An insurer’s claims agent. A dental clinic’s scheduling assistant. A SaaS company’s onboarding flow. These agents serve users, but they represent the entity. The entity is the principal.The entity could be a Fortune 500 or a five-person company. It doesn’t matter. What matters is that when the agent gets something wrong, there’s no user in the loop to catch it. Money moves. Appointments break. Policies are violated. The agent is the loop.So the entity needs more than an agent that works. It needs access to how the agent thinks — so it can direct it, inspect it, debug it, and improve it. It needs an agent whose brain is open.
Every AI agent has a brain — the thing that makes its decisions. The question is whether you can get to it.A closed brain takes suggestions. You write a prompt. You hope the agent follows it. When it doesn’t, you rewrite the prompt and hope again. You can see what the agent did but not why. You can’t point at a specific decision and change how it’s made. You can’t ask the agent why it refused a refund and get a real answer. You can’t tell it “stop asking about budget” and know it will stop. The brain is doing something in there. You just can’t reach it.An open brain is transparent, conversational, and programmable. You can see every decision the agent made — which rules fired, what state it was in, why it acted or refused to act. You can talk to the agent about how it behaves, not just use it. And you can change how it thinks, in natural language, with changes that are deterministic and permanent.This isn’t a feature. It’s a property of the architecture. And everything follows from it.Control. The entity defines constraints — the payment won’t process without confirmation, the refund won’t issue without documentation — and they hold absolutely. Not because the agent was asked nicely. Because the brain enforces them architecturally. Control is the most immediate thing an open brain provides, but it’s only the beginning.Debugging. Something goes wrong. You open the brain. You see what happened — not a log of inputs and outputs, but a structured record of the reasoning itself. You see which constraint fired incorrectly, or which one didn’t fire when it should have. You fix it. You verify the fix in the trace. Done. This is engineering, not guesswork.Optimization. You read traces from hundreds of conversations. You see exactly where users drop off or convert. You see which decisions led to which outcomes. You adjust — not by A/B testing prompts and correlating at the aggregate level, but by pointing at specific decisions and changing them, with measurable effects.Evolution. Policies change — describe the new policy, the brain updates. Edge cases appear — read the trace, describe what should happen instead. New workflows are needed — describe them, the brain generates the configuration. Each cycle makes the agent more precise. Each improvement is verifiable. The system converges toward whatever the entity needs it to be.These aren’t separate products bolted onto an agent. They’re all consequences of one property: the brain is open. You have access. Everything else follows.
Most AI agents today have closed brains. The industry has converged on two main approaches for building task-oriented agents, and a third is emerging. None of them open the brain. And the reasons are architectural — not temporary limitations waiting for better models.

​
LLM Agents

Function-calling agents give an LLM access to tools and let it decide when to call them. Flexible conversation. Natural handling of unexpected inputs.But the brain is closed.When an LLM makes a decision, it samples from a probability distribution over tokens. It doesn’t compute from explicit state. It doesn’t evaluate constraints against a symbolic representation. It predicts the most likely next output. You can see what it decided. You cannot see how or why — because there is no structured decision process. There are weights.So control is approximate. You can make unwanted behaviors less likely. You cannot make them impossible. Debugging is hope — you modify the prompt, it seems to work, it fails differently next week. Optimization is correlation, not causation — you can’t point at a specific decision and know why it went one way. Improvement doesn’t converge — each fix might break something else, and you can’t verify otherwise.This is not a temporary limitation. A transformer generates outputs by sampling from a probability distribution. That is the mechanism. No amount of scaling changes it. The mechanism that makes LLMs brilliant at open-ended conversation is the same mechanism that keeps their brains permanently closed.

​
Orchestration

Orchestration wraps LLMs in workflow systems — state machines, routing logic, branching conditions. The state machine provides control. The LLM provides flexibility.The brain isn’t closed. It’s scattered.The state machine has explicit logic you can read. But it’s fragmented across hundreds of branches, coded per-workflow, per-tool, per-condition. When the user goes off-script, the system either breaks or hands off to the LLM — at which point you’re back to a closed brain. Control and flexibility live in separate systems. You have access to part of the brain, part of the time.Improvement means more branches. More branches means more complexity. More complexity means more fragility. The brain gets harder to access as it grows.

​
Stateful Runtimes

The newest approach — including OpenAI’s Stateful Runtime Environment — adds persistent state management around LLM agents. Memory carries forward. Tool state persists. Permission boundaries hold across steps.This is better infrastructure around a closed brain. The LLM is still the decision-maker. The state is managed around it, not within it. Guardrails check what the model decided after it decides — they don’t prevent the decision from being made. The brain is still closed. The room around it is just nicer.This is neural and symbolic: two separate systems, layered. Not neuro-symbolic: one system, unified.

​
Why They Can’t Open

These architectures can’t open the brain because there’s no brain to open. The LLM has weights — not a structured decision process you can inspect or modify. The orchestration framework has a flowchart — explicit but fragmented, and mute the moment it hands off to the LLM. The stateful runtime has infrastructure — state management, persistence, permissions — but the thing making decisions is still a black box at the center.An open brain requires structured symbolic reasoning that is native to how the agent thinks. Not layered around it. Native. The reasoning must be symbolic so it can be inspected and modified. It must be deterministic so changes produce guaranteed outcomes. And it must be unified with neural language understanding so the agent can still handle real conversations.You can’t open a brain that doesn’t exist. LLMs have weights. Orchestration has flowcharts. Stateful runtimes have furniture.Apollo-1 has a brain. And it’s open.

​
Get Started

Quickstart

Understand the products and send your first message.

Authentication

Learn how to authenticate your API requests.

Changelog

Latest updates and API changes.