Agentic & Ecosystem Command-and-Control. Direct a team of specialized AI agents in plain English; they design, deploy, and operate real cloud infrastructure within governed boundaries — and you watch every outcome render live.
Most "AI agent" tools give you a chatbot. CortexObserver gives you a governed AI workforce and a command center to run it. You speak intent — "@allen deploy this CDK repo to dev", "@amy build a churn model from this dataset", "@charles analyze NVDA" — and a roster of specialized agents, each with its own reasoning graph, skills, and tool grants, does the work. Every action flows through Farms (managed AI services for tools, models, memory, knowledge, and budgets) and is bounded by Governance (policies, procedures, standards, risk budgets, human approval gates). The results — a deployed stack, a trained model, a trading thesis — render back as live truth you can see, audit, and adjust. Humans set the rules; agents do the work within them; the loop closes.
CortexObserver runs on one operating principle:
Humans define policies & budgets → Farms enforce them → Agents work within the constraints → Results flow back as live truth → Humans observe and adjust → repeat.
Neither side works alone. Policies without agents are unexecuted intent. Agents without policies are ungoverned risk. The Farms are the connective tissue that lets both operate on the same knowledge at different abstraction levels.
HUMAN LAYER AGENT LAYER
─────────── ───────────
Policy (business intent) → Prompt (reasoning context)
Procedure(how to fulfill) → Skill (domain expertise)
Standard (applied metadata) ←→ Tool output (executed metadata)
The circle closes when applied metadata (what agents did) is verified back against the governing policy (what humans intended). Drift detection, compliance audits, and reconciliation all live here.
Mission Control is the NLP command surface. Type a request, @mention a specialist to dispatch, and watch each agent's LangGraph execute node-by-node in the Graph Workspace — with live state, human approval gates, and execution replay.
A.T.O.M (Agentic Temporal Operating Model) is the single pane of glass over everything that exists in AWS — Discovery → Inventory → Dependencies. It absorbs infrastructure built outside CortexObserver (via the Resource Groups Tagging API), and renders agent-deployed CloudFormation/CDK stacks as a live dependency graph.
Each agent is an individual LangGraph StateGraph with role-specific nodes, skills, and tool access — governed identically whether a human or an agent is the principal.
| Agent | Role | What it does |
|---|---|---|
| @allen | Cloud Architect | Clones a CDK repo → cdk synth → reads governance policy → plans → human approval → deploys → renders in the DAG |
| @amy | ML Engineer | Profiles a dataset → frames the task → trains → critics gate it → deployment judge promotes → versioned model in the Model Farm |
| @charles · @charlene · @chad | Trading Desk | Multi-agent research across stocks, crypto, options — analyst lenses → bull/bear debate → risk debate → portfolio decision (research only — not financial advice) |
| @brian | Software Developer | Multi-model pipeline: orchestrate (Opus) → plan (Sonnet) → build (Haiku) → validate → synthesize → persist code |
| @bishop | Medical Reasoning | Risk-gated triage with hallucination & bias critics, human-in-the-loop |
| @becky · @alice · @chat | Identity · Knowledge · Assistant | Access management · governed RAG · general-purpose conversation |
Specialist desks ship their own architecture maps — showing exactly how you, the agents, data, reasoning, and governance connect.
| Trading Desk | ML Studio |
|---|---|
 |
 |
Farms aren't just resource pools. Each is a managed AI service with its own LLM, prompts, skills, and human control UI. Agents consume Farms; humans govern them.
| Farm | What it manages | Human control plane |
|---|---|---|
| MCPFarm | 100+ tools across 17 servers; pre-execution risk scoring + authorization | Tool grants, server health, invocation history, playground |
| LLM Gateway | LiteLLM routing, multi-provider model registry, tiers, failover, cost | Model lifecycle (active → deprecated → EOL), per-agent budgets, usage analytics |
| Memory Farm | Four-tier agent memory (L1 Redis → L2 Postgres → L3 snapshots → L4 procedural) | Cross-agent Memory Explorer with temporal search; consolidation; quotas |
| Knowledge Farm | Agent-namespaced RAG (Qdrant hybrid BM25 + dense + RRF) | Document lifecycle, sources, collections, retrieval testing |
| Allocation | Per-agent budgets, risk budgets, tool grants, memory/knowledge quotas | The enforcement table — checked before every tool call, LLM invocation, and memory write |
Humans encode intent as Policies, Procedures, and Standards across 19 enterprise domains. Those documents become agent Prompts, Skills, and Tools — and agent expertise is itself governed in the Skills Store.
- Policies / Procedures / Standards → injected into agent reasoning and skills
- Skills Store — 79 governed, versioned competencies bound to agents
- Identity Store — unified agent / human / service principals with RBAC and AWS linkage
- Risk budgets & approval gates — consequential actions (a deploy, a delete) pause for human approval before they run
graph LR
subgraph UI["HUMANS · Next.js"]
H["Policies · Procedures<br/>Standards · Skills<br/>Identities · IaC"]
end
subgraph CMD["COMMANDER · NLP C2"]
direction TB
D["Dispatch + WebSocket"]
D --> A1["@allen · Cloud Architect"]
D --> A2["@amy · ML Engineer"]
D --> A3["@charles · Trading"]
D --> A4["@brian · Software Dev"]
D --> A5["…10 agents"]
end
subgraph FARMS["FARMS · managed AI services"]
direction TB
F1["🔧 MCPFarm"]
F2["🧠 LLM Gateway"]
F3["💾 Memory Farm"]
F4["📖 Knowledge Farm"]
F5["💰 Allocation"]
end
subgraph GOV["GOVERNANCE"]
G["Policies · Budgets<br/>Risk · Approval gates"]
end
subgraph DATA["DATA & CLOUD"]
direction TB
D1["PostgreSQL · Redis · Qdrant"]
D4["AWS · CloudFormation · SSM"]
end
UI --> CMD --> FARMS --> GOV --> DATA
style UI fill:#1e3a5f,stroke:#2d5a8e,color:#fff
style CMD fill:#2d2d3d,stroke:#4a4a5a,color:#fff
style FARMS fill:#3d2d1d,stroke:#5a4a3a,color:#fff
style GOV fill:#3d1d1d,stroke:#5a3a3a,color:#fff
style DATA fill:#1d2d1d,stroke:#3a4a3a,color:#fff
| Layer | Technology |
|---|---|
| Frontend | Next.js 15 · TypeScript · Tailwind · @xyflow/react (React Flow) |
| Backend | FastAPI · SQLAlchemy 2.0 (async) · Pydantic |
| Agents | LangGraph — one StateGraph per agent |
| LLM | LiteLLM — Anthropic Claude, OpenAI GPT-4o, and more |
| Data | PostgreSQL (pgvector) · Redis · Qdrant |
| Cloud | AWS CloudFormation · CDK · SSM · Organizations · IAM |
| Infra | Docker Compose (dev) · ECS/Fargate (prod) |
git clone https://github.com/iotlodge/CortexObserver.git
cd CortexObserver/CortexObserver
./scripts/start.sh # full stack in Docker
./scripts/start.sh --bare # infra in Docker, app on host (dev)
./scripts/stop.sh # stopCopy .env.example → .env and set:
ANTHROPIC_API_KEY— required for agent reasoningAWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY— for @allen deploys + AWS discoveryCORTEX_TAVILY_API_KEY— optional, web search for the Trading Desk
Then open http://localhost:3000 (API at http://localhost:8000/api, docs at /docs).
Optional worker sidecars:
--profile mlruns the @amy training worker;--profile cdkruns the @allen CDK-synth worker.
| Guide | What's inside |
|---|---|
| Architecture | The circular loop, Humans/Agents/Farms, A.T.O.M, time as the universal index |
| Commander | NLP dispatch, the Graph Workspace, human-in-the-loop approval gates, missions |
| Agents | The repeatable agent pattern + the roster, with the Trading Desk & ML Studio deep dives |
| Cloud (A.T.O.M) | @allen, CDK synth → deploy, SSM, and the live dependency DAG |
| Farms | The five managed-AI-service control planes |
| Governance | Policies/Procedures/Standards, Skills Store, Identity Store, risk & approval |
backend/src/cortex/
├── agents/ # Per-agent LangGraph graphs (allen, amy, charles, brian, …)
├── commander/ # Generic workflow engine + checkpointer (HITL)
├── gateway/ # LLM Gateway (LiteLLM routing, model registry)
├── memory/ # Memory Farm (L1–L4)
├── knowledge/ # Knowledge Farm (Qdrant hybrid RAG)
├── mcpfarm/ # Tool registry, risk scoring, authorization, executor
├── worldmaker/ # A.T.O.M — AWS discovery, dependency graph, bootstrap engine
├── lifecycle_projection/ # CFN → resource-graph projection (the live DAG)
├── models/ # SQLAlchemy models
└── realtime/ # Redis event bus + WebSocket hub
frontend/src/
├── app/dashboard/ # Next.js pages (A.T.O.M, Commander, Farms, Admin)
├── components/ # Mission Control, Graph Workspace (React Flow), A.T.O.M DAG
└── lib/ # API client, auth, stores
CortexObserver — humans write the policies, agents do the work through skills, and the Farms govern the boundaries.