The Astromesh Ecosystem
Astromesh is not a single tool — it’s an ecosystem designed to cover the full lifecycle of AI agents: define, build, run, deploy, and manage. The core runtime is the foundation, and a set of satellite projects extend it for specific use cases.
You can use just the core runtime with YAML config files, or combine it with the ADK for Python-first development, Forge or Cortex for visual building, the CLI and Node for system-level operation, OS for a hardened appliance, Orbit and Nexus for cloud, Herald to reach people on WhatsApp, Telegram, Instagram and web chat, or Leia for a natural-language workflow.
Nothing here ships on the same clock. Each package carries its own version and its own changelog; a core release does not bump anything else, and a component that has not changed keeps its number.
Components at a Glance
Section titled “Components at a Glance”| Component | What it does | Package / Repo | Version |
|---|---|---|---|
| Core Runtime | Multi-model agent engine with 7 orchestration patterns, per-role model routing, declarative agent chaining, a catalog of 18 declarative integrations, memory, tools, guardrails, and a per-model price table behind cost tracking | astromesh | v0.75.0 |
| Glyph | Action language — an agent’s plan as a program the runtime executes, instead of a tool-calling loop | astromesh-glyph | v0.1.3 |
| OKF | Open-source library: agents in LangChain, CrewAI, ADK and six more frameworks (or any MCP client) navigate an Open Knowledge Format bundle with trust and freshness signals | astromesh-okf | v0.1.0 |
| RAG | Open-source library: retrieval-augmented generation from swappable parts — naive, hybrid, multi_query and hyde patterns, optional reranking, five vector stores, a trace per query, in Python or kind: RAGPipeline YAML | astromesh-rag | v0.1.0 (PyPI) |
| Context | Open-source library: decides what goes into the model’s window — knowledge, memory, history — within one token budget, with a trace per item and an eval that measures the choice | astromesh-context | v0.1.0 |
| A2A | Open-source library: A2A 1.0 client and server for any agent framework — policy-first (allowlist, size and time caps, untrusted-output wrapping), with adapters for LangChain/LangGraph, CrewAI, smolagents and MCP; Nexus serves A2A since 0.27 | astromesh-a2a · PyPI | v0.1.1 |
| ADK | Python-first agent SDK with decorators and a CLI | astromesh-adk | v0.7.1 |
| CLI | Standalone CLI for managing nodes and clusters | astromesh-cli | v0.4.1 |
| Node | Cross-platform system installer and daemon (Linux, macOS, Windows) | astromesh-node | v0.1.10 |
| OS | Minimal, immutable, API-only Linux appliance that runs agents | astromesh-os | v0.13.8 |
| Forge | Visual agent builder — a web SPA embedded in a node at /forge | astromesh-forge | v0.29.1 |
| Cortex | Desktop IDE & multi-runtime control plane (Electron) | astromesh-cortex | v0.29.0 |
| Orbit | Cloud-native IaC deployment — generates Terraform for GCP (AWS/Azure planned) | astromesh-orbit | v0.4.4 |
| Prisma | Turns your agent into a cloud’s own native agent, running on that cloud’s base resources (GCP: ADK on Agent Engine) | astromesh-prisma | v0.2.1 (in development) |
| Nexus | Multi-tenant managed control plane — publishes, runs, meters and bills agents | astromesh-nexus | v0.28.2 |
| Herald | Communications gateway — WhatsApp, Telegram, Instagram, Messenger and web chat messages reach agents, and agents reach people back through one outbox | astromesh-herald | v0.14.0 |
| Leia | Natural-language agent operations as a Claude Code plugin | astromesh-leia | v0.11.2 |
| SDD | Spec-Driven Development skills for any coding agent — spec, plan, tasks, implementation and verification as files next to your code; a Claude Code plugin and open Agent Skills | astromesh-sdd | v0.1.0 |
| Nebula | Open-model foundry — trains, gates, and publishes the ecosystem’s own models | astromesh-nebula | v0.1.0 (preview) |
How They Relate
Section titled “How They Relate”Every component orbits the Core Runtime — the engine that loads agents, routes to LLM providers, and executes orchestration patterns. The satellites attach at different points in the lifecycle:
flowchart LR
subgraph build["DEFINE / BUILD"]
tools["`ADK (Python)
Forge (web)
Cortex (app)
Leia (NL)`"]
end
subgraph run["RUN"]
core["`Core Runtime
(engine + Glyph)`"]
infra["`Node
OS appliance
Docker / K8s`"]
end
subgraph manage["DEPLOY / MANAGE"]
mgmt["`CLI (astromeshctl)
Orbit (GCP IaC)
Prisma (cloud-native, in dev)
Nexus (managed plane)`"]
end
subgraph reach["REACH"]
herald["`Herald
(WhatsApp & friends)`"]
end
people(["People"])
tools --> core
mgmt --> core
core -- runs on --> infra
people <--> herald
herald -- "invokes agents via" --> mgmt
- ADK builds agents in Python → generates YAML the Core Runtime understands.
- Forge and Cortex build agents visually (see Forge vs Cortex below).
- Leia drives the whole flow in plain English from inside Claude Code.
- SDD is how you build the software around agents with a coding agent: Claude Code, Codex, OpenCode, Kimi and others write a spec, a plan and tasks before the code, and verify against the spec at the end. It does not touch the runtime.
- Core Runtime is the engine that executes agents.
- RAG is a standalone library for giving a model the right documents: ingest, retrieve with one of four patterns, rerank, and build the context, with a trace of every stage. It came out of the core’s RAG module and fixes the bugs found while porting it; like OKF, it works in any Python project.
- Context decides which of everything RAG, OKF, memory and the conversation propose actually goes into the model’s window, under one token budget and in an order the prompt cache can reuse. It ships as
astromesh-context0.1.0 on PyPI, with an eval that measures the choice. The map of context patterns explains where it sits next to RAG and OKF. - A2A lets an agent talk to other agents without trusting them: a client and a server for the A2A protocol, built on the official A2A SDK. Every remote is checked against a policy (allowlist, size and time caps) and its output reaches the model wrapped as untrusted. It plugs into LangChain/LangGraph, CrewAI, smolagents and MCP, and the core calls remote A2A agents with
type: a2a(extraastromesh[a2a], see A2A in Astromesh); the ADK does it withremote_a2a(). Nexus serves published agents over A2A since 0.27. PyPI · repository. - Node installs the runtime as a native system service (
astromeshd); OS ships it as a sealed appliance image; Docker/Helm package it for containers. - CLI is the
astromeshctlmanagement interface. - Orbit provisions cloud infrastructure with Terraform; Nexus is the multi-tenant managed control plane — it keeps agent specs in PostgreSQL with versioning and dispatches runs to a shared runtime pool, metering and billing what each one consumes.
- Herald sits in front of Nexus: an inbound WhatsApp message invokes an agent, and an agent can reach a person back through the same outbox. It never talks to the runtime — whether an agent exists and who may run it is Nexus’s call.
- Glyph sits inside the runtime: it is an orchestration pattern where the plan is a program rather than a loop. Reach for it when an agent chains five or more tools every time; not when it needs to see the data before deciding what to do next.
- Prisma is the other answer to “put this on a cloud”: where Orbit provisions infrastructure you operate the runtime on, Prisma hands the workload to the cloud’s own managed AI service and writes down what that service cannot host. It is in development: v0.2.1 translates an agent and reconciles it against an in-memory gateway, but provisions nothing in a real cloud yet, and its repository is private and not on PyPI.
- Nebula sits upstream of the runtime: it’s the open-model foundry that trains, gates, and publishes the ecosystem’s own models (the Models catalog the runtime routes to).
Forge vs Cortex
Section titled “Forge vs Cortex”Both build agents visually, but they are distinct, coexisting products with different form factors — pick by where and how you work.
| Forge | Cortex | |
|---|---|---|
| Form factor | Web SPA (Vite + React) | Desktop app (Electron) |
| Where it runs | Embedded in a node at /forge, or npx astromesh-forge | On your machine, run from source (no installer yet) |
| Backend | None — pure client against one node’s /v1/* API | Manages local runtime, GCP (Orbit), and Nexus connections |
| Scope | Quick visual building & a developer console for one node | Full IDE + multi-runtime control plane and ops console |
| Best for | Fast, zero-install agent building inside a running node | Day-to-day development, testing, channels, and deployment |
In short: reach for Forge when you want an instant, in-node visual builder; reach for Cortex when you want a full desktop IDE that also provisions and operates runtimes. Forge’s heavier monitoring/ops concerns are handled by Cortex.
When to Use What
Section titled “When to Use What”| I want to… | Use… |
|---|---|
| Define agents with YAML and run the runtime directly | Astromesh Core |
| Define agents with Python decorators and a CLI | Astromesh ADK |
| Build agents visually in the browser, embedded in a node | Astromesh Forge |
| Design, test, and deploy from a desktop IDE | Astromesh Cortex |
| Go from idea to a deployed WhatsApp agent in plain English | Astromesh Leia |
| Build software with a coding agent, spec first, with every requirement traced to a test | Astromesh SDD |
| Install as a system service on Linux, macOS, or Windows | Astromesh Node |
| Run agents on a hardened, immutable appliance | Astromesh OS |
| Deploy in containers or Kubernetes | Docker / Helm (part of core) |
| Provision cloud infrastructure with Terraform | Astromesh Orbit |
| Run a multi-tenant agent platform on Kubernetes | Astromesh Nexus |
| Put an agent on WhatsApp, and let it message people back | Astromesh Herald |
| Give a model the right documents, with a pattern you can switch and a trace you can read | Astromesh RAG |
| Decide what the model reads under one token budget, and measure the choice | Astromesh Context |
| Call or serve agents over A2A without trusting the remote | Astromesh A2A |
| Replace a long tool-calling loop with one reviewed program | Glyph |
| Manage nodes and clusters from the command line | Astromesh CLI |
| Hand the workload to a cloud’s own managed AI service | Astromesh Prisma (in development) |
| Train and publish the ecosystem’s own open models | Astromesh Nebula |
Deployment Layers
Section titled “Deployment Layers”The ecosystem forms a layered stack. You choose your entry point at each layer:
flowchart TB
l5["`**Layer 5: Reach**
Channels → Herald (WhatsApp, Telegram, Instagram, web chat)`"]
l4["`**Layer 4**
Multi-tenant plane → Nexus (managed control plane)
Infrastructure → Orbit (Terraform)
Cloud-native primitives → Prisma (in development)
System Service → Node (deb/rpm/...)
Appliance Image → OS (immutable mkosi)
Containers → Docker / Helm`"]
l3["`**Layer 3: Management**
CLI (astromeshctl) · Leia`"]
l2["`**Layer 2: Agent Runtime**
Astromesh Core`"]
l1["`**Layer 1: Agent Definition**
YAML · ADK · Forge · Cortex`"]
l5 --- l4 --- l3 --- l2 --- l1
Layer 1 is where you define agents — YAML files, ADK Python decorators, or the Forge/Cortex visual builders. All produce the same agent definitions.
Layer 2 is the runtime engine that loads agents, connects to LLM providers, manages memory, and executes orchestration patterns (ReAct, PlanAndExecute, etc.).
Layer 3 is the management layer — astromeshctl controls running nodes and clusters; Leia drives them in natural language.
Layer 4 is how you deploy the runtime. Pick the one that fits your infrastructure: Node for bare-metal/VM, OS for a sealed appliance, Docker for containers, Helm for Kubernetes, Orbit for cloud-managed infrastructure, or Nexus for a multi-tenant platform. Prisma is the one exception on this layer: it does not deploy the runtime at all, it hands the workload to a cloud’s own managed AI service — and it is still in development.
Layer 5 is how people reach the agents and the agents reach back. Herald owns the channel credentials and the delivery queue; it invokes agents through Nexus and never touches the runtime.
Next Steps
Section titled “Next Steps”| Component | Start here |
|---|---|
| Core Runtime | Quick Start — run your first agent in 5 minutes |
| ADK | ADK Introduction — Python-first agent development |
| Forge | Forge Introduction — visual agent builder |
| Cortex | Cortex Introduction — desktop IDE & control plane |
| Leia | Leia Introduction — agents in plain English |
| Node | Node Introduction — install as a system service |
| OS | OS Introduction — the immutable agent appliance |
| Orbit | Orbit Introduction — provision cloud infrastructure |
| Nexus | Nexus Introduction — multi-tenant Kubernetes control plane |
| Prisma | Prisma Introduction — the multi-cloud reconciler, and what it does not do yet |
| Herald | Herald Introduction — channels in, proactive messages out |
| Glyph | Glyph Introduction — the action language, and when it actually pays |
| OKF | OKF Introduction — navigating knowledge bundles from any framework |
| RAG | RAG Introduction — retrieval patterns from swappable parts, and how to choose one |
| Context | The map of context patterns — six questions about context and knowledge, and which pattern answers each |
| A2A | A2A Introduction — the library, type: a2a tools, remote_a2a() and Nexus as an A2A server |
| Nebula | Nebula Introduction — the open-model foundry where our models are born |