AEGIS Platform
An enterprise multi-agent system that behaves like an AI employee, not a chatbot.
- Status
- Production-grade
- Role
- Solo — architecture, agent design, infrastructure, observability
- Timeline
- 2026
At a glance
A production-oriented multi-agent platform that decomposes goals into executable plans, coordinates specialist agents, and instruments every step for cost, latency, and traceability. Runs locally with no API keys or GPU, and scales to real infrastructure through configuration.
- Supervisor agent decomposes a goal; a planner compiles it into a directed acyclic graph of tasks.
- Specialist agents (research, coding, critic, memory) execute nodes with bounded self-correction retries.
- Knowledge graph plus vector store give agents durable, queryable context across sessions.
- Enterprise controls built in: RBAC, human approval gates, guardrails, and per-run cost ceilings.
- Provider-agnostic: swap local models for frontier APIs without touching agent code.
Key numbers
0 API keys
Runs with
Local models by default; frontier APIs optional
5
Agent roles
Supervisor, Planner, Research, Coding, Critic, Memory
Compose → K8s
Deployment
Same artefact, environment-driven config
Instrumented
Every step
Cost, latency, and full execution trace
Tech stack
- Orchestration
- PythonFastAPISupervisor / Planner / Specialist agentsMCP tool protocol
- Knowledge & memory
- PostgreSQL + pgvectorNeo4j knowledge graphRedisRAGLong-term memory
- Messaging & scale
- KafkaDocker ComposeKubernetes
- Observability
- PrometheusGrafanaExecution tracesPrompt versioning
- Governance
- RBACHuman-in-the-loop approvalSafety guardrailsCost & latency budgets
The problem
Most 'AI agent' demos are a single model in a while-loop. They cannot be reasoned about, budgeted, audited, or safely given access to real systems — which is exactly what an organisation needs before it will let an agent do anything important.
AEGIS treats the agent as a system to be engineered: planned, observed, bounded, and reviewable.
Approach
A supervisor agent receives a goal and decomposes it. A planner turns that decomposition into a DAG of concrete tasks with explicit dependencies, so execution order is a property of the plan rather than an emergent accident.
Specialist agents own narrow responsibilities — research, coding, criticism, memory management — and communicate through typed messages. A critic agent reviews outputs before they are accepted, and failed nodes retry within a fixed budget instead of looping forever.
Architecture
Requests flow: frontend → gateway → supervisor → planner → specialist agents → knowledge graph / vector DB → tools and APIs → human approval gates. Every layer is instrumented.
Durable context lives in two stores: a Neo4j knowledge graph for entities and relationships, and PostgreSQL with pgvector for semantic retrieval. Redis handles short-lived state and Kafka carries events between components.
- Tool calling standardised on the MCP protocol so new capabilities are additive.
- Prompt versioning makes prompt changes reviewable like code.
- Prometheus and Grafana expose cost, latency, and error rate per agent and per run.
Enterprise capabilities
Role-based access control scopes what each user — and each agent acting on their behalf — is allowed to touch. Human-in-the-loop approval workflows pause execution before consequential actions. Safety guardrails and per-run cost and latency budgets keep runaway behaviour contained.
What I took from it
The hard part of agentic AI is not the reasoning loop — it is everything around it: planning as an explicit artefact, observability that survives contact with production, and governance a security team would actually sign off on.
Want the details?
The full source, READMEs, evaluation harnesses, and results are on GitHub.
github.com/dariyaDeepanshu/AEGIS-PLATFORM