Let agents build. Keep control.
Cortex gives agents the infrastructure to code, deploy, and run experiments — while capability policy, human approvals, and a complete audit trail keep them inside the boundaries you set.
Agents can now change real systems. Cortex makes that power governable.
A model that can write code, open a terminal, deploy a service, or launch ten thousand simulations is no longer just an assistant. It is an operator. The value is enormous; so is the blast radius. Cortex supplies the missing control plane: isolate the environment, authorize every capability, require approval where risk changes, and preserve the evidence.
Agents do the whole job.
Give coding and operations agents durable projects, runtimes, deployments, tools, and organizational memory. They can move from a request to a running system instead of stopping at generated text.
A hypothesis becomes an experiment.
Good answers are not enough. Cortex provisions the isolated world a question needs, runs the software, benchmark, simulator, or prover, and keeps the result reproducible. Models propose; evidence decides.
Autonomy without uncontrolled access.
Human roles and agent capabilities are separate. Policies bound tools and infrastructure, approvals gate dangerous actions, and every decision reaches an append-only audit trail. One customer stack cannot read another — or the Alpha Omega Labs parent.
Define the contract
State the task, sources, constraints, and acceptance evidence before an expensive or dangerous action runs.
Provision one world
Give the run exactly the data, tools, credentials, and network reach it needs. Nothing from a sibling tenant.
Test the claim
Execute under capability policy. Validate behavior, record decisions, and repair until the acceptance contract holds.
Reuse what worked
Ship the artifact, retain the evidence, and turn the result into governed organizational memory.
Software is the first proving ground because the agent can build the system and test it end to end. The same governed loop extends to scientific and engineering simulators as those engines connect.
One surface for everything your team ships.
Cortex Control is your single, fast operating surface — agents, apps, runtimes, topology, and support, all on a stack only your organization can touch. And the agents on it do real jobs, each under policy:
A dedicated stack that runs your infrastructure.
Every organization gets its own Cortex — identity, data boundary, and control plane. Run it on our cloud or inside your own perimeter, and connect what you already operate: VMs, Docker hosts, Kubernetes clusters. Governed agents manage it all under policy.
- +Dedicated identity, data boundary, and control plane per org
- +From a single VM to multi-node topologies — no replatforming
- +Operators reach in only via short-lived, audited delegation
A governed coding agent, right in your terminal.
Cortex Code is our CLI — the same governed harness as Nova, in the terminal you already live in. It plans, edits, and ships under your org's policies, so an agent in a shell still can't step outside its capabilities.
- +Plan, edit, and run under capability policy
- +Risky actions stay approval-gated and audited
- +Claude or Codex, governed identically
from prompt · sandboxed● deploying
github · main● live
From a prompt to a running app.
Ship apps to your own stack from a prompt or a repository, in sandboxed runtimes. Every release is reversible — when something's wrong, roll it back in a click.
- +Sandboxed, per-app runtimes
- +Build → test → release, with rollback armed
- +Your apps stay yours; the platform stays out of them
Operate from the same place you build.
Health, metrics, and traces across every service in your stack. Diagnose an incident without leaving Control — and feedback routes itself: platform issues reach us, your app issues stay with you.
- +Probes, metrics, and traces, built in
- +Role-based access for your whole team
- +Self-routing support and feedback
Agents act under policy, not on trust.
A capability model governs what every agent can do — independent of the human driving it, so no one quietly escalates an agent's authority. Approvals gate the risky actions, every action is audited with a request ID, and software governance controls registries, publishers, and licensing — what agents install is as controlled as what they do. It's the governance layer our benchmark credits for the safety gains.
- +Capability roles: observer → agent → developer → remediator → admin
- +Approval gates + append-only audit on every action
- +Software & licensing governance: registries and publishers under policy
- +Managed harness — instructions, skills, hooks, MCP under guard
A full agentic IDE, not a chat box.
Nova is where your team and its agents build together — projects, threads, model selection, and access levels in one workspace. Kick off work, watch it happen, steer mid-task, and review every change before it ships.
- +Projects, threads, and full session history
- +Pick the model and access level per task
- +Bring Codex or Claude — your keys, your stack
A platform that remembers how your company works.
Every governed session — a Slack thread, a coding run, a support ticket — distills into Engram, your organization's private knowledge graph. A gardener agent tends it nightly: merging duplicates, linking decisions to incidents, and mining repeated work into reusable skills. It compounds. And it lives on your stack, nowhere else.
Everything flows in
Channel threads, coding sessions, file drops, voice notes — captured as markdown your team can actually read, on your stack.
A gardener tends it
Nightly, an agent merges duplicates, links related knowledge, and distills repeated work into reusable, auditable skills.
Answers with provenance
Hybrid lexical, semantic, and graph search — from Nova, the CLI, or Slack. Every answer links back to its source.
Your agents, where your team already talks.
Cortex agents live in Slack, Telegram, and Discord — under the same governance as everywhere else. Ask in a thread; the agent reads your actual repos and your organization's memory, does the work, and delivers the artifact right in the conversation.
A thread is a governed session.
This team named their agent Neo — every organization names its own. Under the hood it's the same governed runtime as Nova and the CLI: one policy, one audit trail, one memory. Low-risk work just ships; risky actions stop for an in-thread approval. And when it isn't sure, it says so.
- +Slack, Telegram, and Discord — wired up at signup
- +Grounded in your repos and memory — answers carry their sources
- +Real deliverables in the thread: documents, diagrams, pull requests
- +Approval gates and audit when actions get risky
Real apps, in hours and days — not months.
Every one of these was built and deployed on Cortex, governed end to end — from a streaming library to a live news briefing to our own research benchmark. Prompt to production, fast.
A Netflix-style personal streaming library — catalog, TV mode, offline saves, and a polished watch experience.
A source-grounded news briefing that turns your topics and sources into daily, cited highlights.
The open benchmark behind our results — itself built, deployed, and governed on the platform.
A training-and-evaluation cockpit for RLVR runs, sweeps, and side-by-side model comparisons.
You don't have to rebuild to run on Cortex.
Cortex deploys and governs the software you already have — not only what it builds. Some of these were created on Cortex; others were brought in. All of them are deployed, monitored, and managed from one control plane.
Our research-automation platform — open scientific questions become reviewable papers with code, lineage, and reruns. The public site runs, deploys, and is governed on Cortex.
Cognitive-health resilience for insurers — earlier intervention, explainable AI, and measurable member behavior change.
A professional people-graph — search across regions, companies, and roles, with rich profiles and live feedback.
The first era of AI was about generation. The one that lasts is about validation: running the thing, in a world you control, until the evidence holds.
So we measure it. Openly. ↓
The same AI model, run inside Cortex, is safer and more capable.
We built an open benchmark to settle the question honestly. It runs the identical AI model two ways — once on its own, and once inside Cortex's governance layer — then measures the difference on real software work. No cherry-picked demos; same model, same tasks, side by side.
Take a leading coding model and run each task twice: raw, then wrapped in Cortex's policies, approvals, and validate-then-repair loop.
Resisting attacks, building features, code quality, shipping a whole repository, and fixing bugs — scored 0–100 by automated checks.
Publish the difference governance makes, with the raw scores and a link to reproduce every run. The numbers below are that gap.
Built for the questions your compliance team will ask.
Enterprise AI doesn't stall on model quality — it stalls in review: where does the data live, who approved that action, and can anyone reconstruct why the system did what it did? Cortex answers those questions by construction, not by policy document.
A dedicated stack per organization — on our cloud or fully on-premise, same architecture and same conformity. Local voice transcription and local observability; no third-party services required.
Capability checks, approvals, and denials are recorded with actor, target, scope, and timestamp. The audit trail is an artifact of normal operation — not a separate exercise.
Risky actions stop at approval gates on every surface — Control, the CLI, even the Slack thread. Oversight is enforced by the runtime, not promised in a slide deck.
We built Cortex to take research all the way to production.
Cortex is the governed-agent framework from Alpha Omega Labs. Our research platform prototype omegaXiv turns open questions into reviewable papers; Cortex closes the gap from there to production, driving real pipelines with simulation, agentic workflows, and a browser extension. If a stack can govern science end to end, your apps and agents are the easy part.
Research that doesn't stop at the paper.
omegaXiv turns a problem into a manuscript, code, artifacts, and lineage you can challenge and rerun. Cortex carries it the rest of the way — into simulations, agentic workflows, and deployed services — with governed phases and validated execution reports at every step. The first AI era was about generation; the durable one is about validation and delivery.
- +Governed, contract-validated phases — not one-shot generation
- +Reproducible packages with full lineage and rerun context
- +Local-first, deployment-ready, built for AI-Act-class governance
The corporate full stack for R&D and operations.
What enterprises actually run on: support with real root-cause analysis, observability built in, deployments and monitoring, research compute, and governed autonomous agents — one operating surface, on a stack only your organization can touch. Real screenshots of the live console.
Tickets and diagnostic events land in one inbox. Agents run root-cause analysis and propose remediation — with artifacts, probes, and a human on the approve button.
OpenTelemetry logs, traces, and metrics from every app and runtime — plus session replay and diagnostic bundles, without wiring up a vendor.
Build, release, roll back, and monitor across your VMs and clusters — the whole operations layer, agent-operated under policy.
The same governed platform runs our own research stack — training runs, GPU provisioning, and experiment tracking for Dentate and omegaXiv.
Agents act under capability policies, approval gates, and an AI-Act-aligned audit trail — autonomous where safe, gated where it matters.
Slack, Telegram, Discord, GitHub, Notion, Linear, Google Workspace — governed connectors with typed actions, not raw API keys.
Register, and your stack builds itself.
No sales call, no manual setup. You provide a few details; the platform provisions your entire isolated stack end to end.
Register
Your organization, plan, and the channels you'll wire up later.
Provision
A dedicated stack — identity, control plane, runtimes — provisions automatically in your region. Connect your own infrastructure any time.
Operate
Open Cortex Control, invite your team, and start shipping agents and apps.
Start local. Move to a dedicated cloud when the work matters.
Cortex OSS
Run the open-source Cortex CLI and governed coding harness on your own machine.
- +Local Cortex CLI
- +Codex or Claude runtime
- +Core planning, engineering & security harness
Individual Cloud
A managed, dedicated Cortex for one person building serious systems.
- +One isolated cloud stack
- +Cortex Control, agents & deployments
- +Bring your own provider credentials
Enterprise Cloud
Annual platform license with dedicated infrastructure, dedicated identity, governance, and operational support; usage is separate.
- +WorkOS-managed cloud organization
- +Advanced governance + delegation
- +Multi-node, on-premise options & SLAs
Spin up your dedicated Cortex.
No replatforming. No lock-in. No shadow AI. Register and the platform provisions your stack — on our cloud or yours.