Fleet Orchestration
Central dispatch for thousands of autonomous units. Decompose top-level goals into low-level tasks based on real-time sensor data, weather, and traffic conditions.
Open Source
The Nervous System for Intelligent Architecture
Orchestrate AI, sensors, and tools in one lifecycle.
A framework that connects AI and automation into a coherent system that remembers state and routes work intelligently.
Prometheus is the connective tissue for systems of any complexity. Route events between "brainless" nodes and AI agents without losing context.
- Multiple specialists in one system — not a single chatbot.
- Continuity: identity, memory, and goals persist across sessions.
- Instant model switching (local or cloud) without losing context.
Architecture
event-driven orchestration
Powering Complex Systems
Prometheus is a foundation: you define the entities and the workflows for any domain.
Autonomous Simulations
Create persistent worlds where AI entities with distinct personalities and goals interact, compete, or collaborate—driven by narrative arcs or survival logic.
Hybrid Workforce
Seamlessly route tasks between completely autonomous AI agents and human operators. A unified operating layer for projects involving both silicon and carbon intelligence.
The Framework
Not another agent builder. Prometheus provides the infrastructure to build intelligent systems where every component — smart or simple — plays a role. Entities are one kind of node; Prometheus also supports non-AI nodes (scripts/sensors) in the same event system.
Universal Nodes
Integrate anything. From powerful LLMs to lightweight scripts, route planners, and sensors. If it can receive an event, it can be a node.
Event-Driven Core
A central nervous system that processes signals asynchronously. Inputs trigger workflows that can span milliseconds or days.
Context Continuity
Memory isn't just for chatbots. Maintain state across the entire system lifecycle, allowing different nodes to share a unified understanding.
Intelligence & Efficiency
Don't waste compute. Prometheus optimizes how your system thinks, balancing speed, cost, and capability automatically.
Context-Aware Routing
Cut inference costs dramatically by routing simple tasks locally.
- Routes simple requests to local models (Llama, Mistral, ...)
- Escalates complex reasoning to frontier cloud models (GPT-5, Gemini, ...)
- Decides routing dynamically based on task complexity
- Keeps the full context regardless of the model used
Hybrid Architecture
Brainless meets Brainy.
- Combine deterministic code (APIs, math) with probabilistic AI
- "Brainless" nodes (like route planners) participate equally
- Seamless data flow between sensors, UI, and Agents
- Full observability of the decision tree
How it works
A simple loop: route → act → remember → reflect.
-
1
Signal Intake
An event triggers the system. It could be a user command, a sensor reading, or a scheduled cron job entering the universal queue.
-
2
Cognitive Routing
The core analyzes the signal's complexity. Is it a reflex? Route to a script. Is it a reasoning task? Wake up an AI entity.
-
3
Execution & Evolution
Nodes release their output. Prometheus updates the shared memory and mood state, learning from the outcome before the next cycle.
Core principle: The framework is the brain. The models are just transient thoughts.
See it in action
Real-time event routing log
10:42:01
[INPUT] New signal: "Analyze server
logs for error patterns"
10:42:02
[ROUTE] Classification: Complex
Reasoning → Dispatch to GPT-4o
10:42:05
[ACTION] Entity "SysAdmin_Bot" started
workflow "Log_Analysis"
10:42:08
[OUTPUT] Found 3 critical timeouts.
Suggested fix: increase keep-alive.
10:42:08
[MEMORY] Stored incident #402 in
long-term context.
Status
Prometheus is in active development. Core ideas work end-to-end: multi-entity orchestration, model routing, memory continuity, tool integration, and reflection loops.
What exists
- Multi-entity runtime and orchestration
- Routing across local and external models
- Memory + context continuity
- Tool integration via a unified protocol
- Observability (event stream / logs)
- Self-reflection and improvement workflows
What’s next
- More user-facing demos and narratives
- More “out of the box” entity templates
- Distributed execution and scaling patterns
- Polished docs for non-technical readers