Early access
Leave your email and we'll send your invite when your slot is ready.
Product updates only. Unsubscribe anytime.
Apollo is the LLM SDK that turns every provider into a multi-turn, reasoning-graph, session-aware agentic system. Switch between all major models and your own API keys — or your own agents — and never lose context. One API, over REST or MCP.
The Apollonian ideal
A dozen providers, each with its own interface, limits, and quirks, is noise. Apollo resolves that chaos into structure — every model working in harmony under one API.
Multi-agent routing places each request on the model best suited to it — scored on cost, quality, context fit, and latency, so the right model handles the right step every time.
Turn-looping and reasoning graphs wrap any model — even ones without native multi-turn — so plans, tool calls, and observations stay structured and auditable from first prompt to final PR.
One shared context follows the work. Switch between any agent and the reasoning graph, memory, and history come with it — no re-priming, no dropped threads.
Virtuo SDK
Virtuo is Apollo's model-agnostic, distributable engine for multi-agent orchestration. Every agent is wrapped in a turn-loop (if it isn't already loop-capable) and every agent reads and writes one shared reasoning graph — bound to your PM system (or whatever reasoning system the host product runs on), with human-in-the-loop approval gates tied to RBAC inside the graph itself.
Models with native multi-turn tool loops (like Claude) run as-is. For every model that lacks one, Virtuo drives the loop for it — planning, calling tools, observing results, and iterating — so any provider behaves like a first-class agent.
Every agent reads and writes the same graph — information extraction, strategy, tool execution, observation, decision, and reflection nodes. Models without built-in reasoning inherit one, so a whole team of agents plans against a single explainable, reproducible source of truth.
The graph is bound to your project-management or reasoning system — tickets, plans, and decisions map to graph nodes. Approval gates are human-in-the-loop tied to RBAC, built into the graph itself: the right role signs off on a node before work proceeds.
Switch between any agent you want — the context is always saved and reusable across all of them. The reasoning graph, session state, and history are tenant-scoped and portable, so handoffs never lose the thread.
A Neo4j knowledge graph plus Milvus hybrid search (BM25 + vectors) sit behind retrieval, so answers ground in your documents and code — not model memory.
Virtuo is extracted from Apollo as its own package — reusable across products, with governance invariants that keep policies from ever inventing out-of-graph actions.
Three ways to run a model
Point Apollo at a local model running on your machine, your private NUF (unclonable, part of the CC product ecosystem), or bring API keys for the providers you already use. Apollo routes across all of them and falls back gracefully — your choice, your bill.
Have a model on your machine? Apollo routes to it — private and offline-capable, no keys required. The Akashic desktop app ships a bundled local model, or point Apollo at your own Ollama / vLLM endpoint.
Your NUF (NUF Unclonable Friend) comes with the Colossal Capital product ecosystem — trained on your corpus, servable from self-hosted vLLM or Ollama endpoints. Unclonable, therefore the most private.
Bring keys for Anthropic, OpenAI, Google, and the rest. Shared platform keys or fully BYOK, scored and routed per request.
Default is Anthropic (Claude). Privacy mode surfaces only BYOK and on-device providers, so private-model traffic is always on your own bill. Reach Apollo the same way everywhere — REST/MCP API, the web portal, the Akashic desktop app, or the VS Code extension.
Continuity
Coordinate many agents on a single task — context flows through every handoff, so the next agent picks up exactly where the last left off. Nothing re-primed, nothing lost.
Virtuo scores providers and places the step on the best model — or the one you pin.
Native loop if it has one; Virtuo drives the multi-turn loop if it doesn't.
Every plan, tool call, and observation lands on the shared reasoning map.
The next agent reads the same context and continues — nothing re-primed.
Versioned snapshots and point-in-time rollback for tenant state, reasoning maps, and chat sessions. Audit the past without rebuilding it.
Isolated execution lanes keep concurrent agent workflows from colliding. Each run gets its own path, quota, and cleanup scope.
Organization-level Unclonable Friend models trained on your private corpus. Never shared across tenants, servable from self-hosted endpoints.
Real-time multi-agent session orchestration with shared graph state. Agents reason together, update the same map, and surface live progress.
Machine identity
Multi-agent orchestration only holds up if every agent is accountable. Apollo gives each one a distinct, revocable machine identity — no shared service accounts, and every outbound request is verifiable.
Apollo provisions each agent through Auth0 by default as a distinct machine identity with OAuth-scoped access. The Virtuo SDK lets you plug in your own identity provider, so machine identity stays agnostic and under your control. Outbound requests carry a Cloudflare Signed Agents profile (RFC 9421), so third parties can verify which agent made a request — and you can revoke one identity without disturbing the others.
Routing
Every inference request is scored on cost, availability, model quality for the task, context-window fit, and time-to-available. The winner gets the request; the decision is logged so you can audit why, and the router keeps learning from real outcomes.
Because the loop and reasoning graph live in the architecture — not the model — any combination of LLMs becomes a Claude-level system. Whatever ships on the market next, you get the same multi-turn, reasoning-graph performance through a model-agnostic layer that works with every provider.
| Provider | When the router picks it |
|---|---|
| Anthropic | The default — native multi-turn tool loops for the highest-quality agent work. |
| Together AI | Speed. Runs the ATLAS Turbo configs, roughly a 4x speedup on our workloads, plus LoRA hosting. |
| Groq / Fireworks | Low-latency open-model serving for fast, cheap turns. |
| HuggingFace TGI | On Kubernetes inside your VPC when data can't leave. Zero egress. |
| OpenRouter | Burst capacity for spiky workloads. |
| Self-hosted / NUF | Your private, unclonable model — vLLM, Ollama, or a Together adapter — driven through the same loop. |
// connect any MCP client { "mcpServers": { "apollo": { "command": "npx", "args": ["apollo-mcp-server"], "env": { "APOLLO_API_URL": "https://apollo-api.colossalcapital.co", "APOLLO_API_KEY": "..." } } } } // the same session works in Claude, Cursor, Windsurf, Cline: // chat, run_agent, route_model, session_state, reasoning_graph, ...
Training
By default, training is per-tenant and private: your data and conventions are tuned into LoRA adapters that only your account can load. No co-mingling.
If you opt in, anonymized policy traces can also feed the shared master model, which applies policy transfer and reward shaping across tenants and is only promoted when it beats baseline. Opting in earns ecosystem credits; opting out later leaves your private adapters untouched.
Your NUF (NUF Unclonable Friend) is the endgame — a private model trained on your data that eventually replaces a third-party key while plugging into the same multi-turn loop and reasoning graph, so your own model becomes just another agent in the session.
Membership
Added to any Colossal Capital tier. The tier (free and up) sets API limits, training budget, and team size; Apollo is the add-on that turns on the Virtuo SDK and multi-agent backend.
Get started