axiomstudio/cortex repository overview

⁠Cortex

The governed runtime for AI agents, teams, and skills.

Cortex is Axiom Studio's Kubernetes-native control plane for building and operating governed AI workforces. It brings agent definitions, teams, skills, model providers, credentials, conversations, durable runs, human approvals, and execution infrastructure into one tenant-aware platform.

The runtime is built around the portable OpenSeal⁠ kernel. Every request—whether it starts in Studio, an API client, Slack, an embedded chat, a schedule, or an external event—enters the same durable execution and governance model.

⁠What Cortex provides

⁠Agents and workforces

• Author versioned agents and multi-agent teams from manifests or natural-language workforce requests.
• Compile, review, approve, apply, activate, amend, export, and remove deployments through a durable lifecycle.
• Assign model providers, execution targets, skills, credentials, objectives, and collaboration rules without baking infrastructure details into an agent definition.
• Retain activity, run, turn, action-call, artifact, and execution-audit records.

⁠Durable work

• Organize work into projects, objectives, runbooks, schedules, and agent runs.
• Pause for dependencies or approvals and resume from persisted state instead of restarting a task.
• Route source observations, Kubernetes events, callbacks, and provider events into governed runs.
• Support document artifacts, retained outputs, outreach threads, and auditable delivery attempts.

⁠OpenSeal Skills and marketplace

• Install agents, teams, and canonical Skills directly from the marketplace lifecycle.
• Discover native and repository-backed capabilities, preview compatibility, and validate required actions, prompts, resources, and credentials before installation.
• Pin Skill versions, inspect upgrade plans, apply reference upgrades, and reconcile deployed Skill services per tenant.
• Execute local, prepared-runtime, resource-staging, conversation, and governed HTTP-action adapters through Atlas.

⁠Chats and external channels

• Run first-class chats with threads, mentions, participant cursors, presence, progress, and streaming updates.
• Connect Slack through managed Socket Mode and carry replies, approvals, and run state back to the originating conversation.
• Publish isolated website-chat embeds with opaque installation routes and per-session capabilities.
• Receive signed callbacks and provider events through tenant-resolved conversation gateways and endpoints.

⁠Governance and security

• Isolate tenant data at the API, service, repository, runtime, and database boundaries.
• Apply Casbin-backed member and resource permissions, role groups, SSO, manual users, impersonation controls, and user-attributed API tokens.
• Classify actions as read, write, external, production, or destructive, with environment-specific limits and approval thresholds.
• Restrict approval decisions to eligible tenant owners, admins, or configured role groups and preserve immutable decision evidence.
• Authenticate service-to-service calls with scoped workload identities and signed, replay-resistant execution grants.

⁠Vault and model providers

• Store tenant-owned credentials encrypted at rest and expose only the exact fields authorized for an action.
• Lease model, action, and workspace credentials to runtimes without placing secrets in agent definitions or Skill manifests.
• Manage built-in and OpenAI-compatible model providers, including model selection, output limits, thinking behavior, structured-output mode, and image-input support.
• Govern OAuth connection, refresh, and revocation lifecycles alongside API keys, databases, cloud credentials, and integration credentials.

⁠Kubernetes execution

• Read resources, logs, and events across authorized clusters through Kubelink-backed operations.
• Govern mutations, patches, workload restarts, and deletions as explicit Skill actions.
• Run short-lived work in isolated Atlas workspaces and long-lived coding-agent sessions on Nimbus runners.
• Continue to support Kubernetes application, Helm, GitOps, deployment, topology, and policy workflows through the same tenant and RBAC boundaries.

⁠Architecture

flowchart LR
    Inputs[Studio · API · Slack · embeds · events]
    Control[Cortex + Sentinel<br/>identity · tenancy · governance]
    Kernel[(OpenSeal<br/>durable state)]
    Atlas[Atlas<br/>isolated execution]
    Nimbus[Nimbus<br/>persistent runners]
    Targets[Skills · model providers<br/>integrations · Kubernetes]

    Inputs --> Control
    Control <--> Kernel
    Control --> Atlas
    Control --> Nimbus
    Atlas --> Targets
    Nimbus --> Targets

⁠Install

Release tags publish versioned Cortex, Sentinel, Atlas, and Nimbus images together with packaged Axiom and Nimbus Helm charts. Use a packaged chart from GitHub Releases⁠ so the chart and application images stay aligned.

Prerequisites:

• Kubernetes 1.21 or newer
• Helm 3.8 or newer
• kubectl access to the target cluster
• GitHub CLI access to this repository
• At least 4 CPU cores and 8 GiB of available memory for a default installation

VERSION="$(gh release list --repo axiom-studio/cortex --limit 1 --json tagName --jq '.[0].tagName')"
CHART_VERSION="${VERSION#v}"

gh release download "${VERSION}" \
  --repo axiom-studio/cortex \
  --pattern "axiom-operator-${CHART_VERSION}.tgz"

helm upgrade --install axiom "./axiom-operator-${CHART_VERSION}.tgz" \
  --namespace axiomcd \
  --create-namespace \
  --wait \
  --timeout 10m

kubectl get pods --namespace axiomcd

For external PostgreSQL, ingress, object storage, workload identity, resource sizing, and production overrides, see the Helm chart guide⁠.

⁠Develop

The repository vendors its Go dependencies and provides focused build and test targets:

make build
make build-sentinel
make build-atlas
make build-nimbus-controller
make test-unit
make check-migrations

Create a disposable k3d installation with:

make up

Remove it with:

make down

Important paths:

Read the tenant and RBAC governance guide⁠ before adding a user-facing resource or administrative capability. Contribution workflow and coding guidance are in CONTRIBUTING.md⁠.

⁠Security

Please report vulnerabilities privately through GitHub Security Advisories⁠. Do not open a public issue for a suspected vulnerability.

⁠License

Cortex is licensed under the Apache License, Version 2.0⁠.