Skip to content

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.

ComponentWhat it doesPackage / RepoVersion
Core RuntimeMulti-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 trackingastromeshv0.75.0
GlyphAction language — an agent’s plan as a program the runtime executes, instead of a tool-calling loopastromesh-glyphv0.1.3
OKFOpen-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 signalsastromesh-okfv0.1.0
RAGOpen-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 YAMLastromesh-ragv0.1.0 (PyPI)
ContextOpen-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 choiceastromesh-contextv0.1.0
A2AOpen-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.27astromesh-a2a · PyPIv0.1.1
ADKPython-first agent SDK with decorators and a CLIastromesh-adkv0.7.1
CLIStandalone CLI for managing nodes and clustersastromesh-cliv0.4.1
NodeCross-platform system installer and daemon (Linux, macOS, Windows)astromesh-nodev0.1.10
OSMinimal, immutable, API-only Linux appliance that runs agentsastromesh-osv0.13.8
ForgeVisual agent builder — a web SPA embedded in a node at /forgeastromesh-forgev0.29.1
CortexDesktop IDE & multi-runtime control plane (Electron)astromesh-cortexv0.29.0
OrbitCloud-native IaC deployment — generates Terraform for GCP (AWS/Azure planned)astromesh-orbitv0.4.4
PrismaTurns your agent into a cloud’s own native agent, running on that cloud’s base resources (GCP: ADK on Agent Engine)astromesh-prismav0.2.1 (in development)
NexusMulti-tenant managed control plane — publishes, runs, meters and bills agentsastromesh-nexusv0.28.2
HeraldCommunications gateway — WhatsApp, Telegram, Instagram, Messenger and web chat messages reach agents, and agents reach people back through one outboxastromesh-heraldv0.14.0
LeiaNatural-language agent operations as a Claude Code pluginastromesh-leiav0.11.2
SDDSpec-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 Skillsastromesh-sddv0.1.0
NebulaOpen-model foundry — trains, gates, and publishes the ecosystem’s own modelsastromesh-nebulav0.1.0 (preview)

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:

  • 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-context 0.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 (extra astromesh[a2a], see A2A in Astromesh); the ADK does it with remote_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 astromeshctl management 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).

Both build agents visually, but they are distinct, coexisting products with different form factors — pick by where and how you work.

ForgeCortex
Form factorWeb SPA (Vite + React)Desktop app (Electron)
Where it runsEmbedded in a node at /forge, or npx astromesh-forgeOn your machine, run from source (no installer yet)
BackendNone — pure client against one node’s /v1/* APIManages local runtime, GCP (Orbit), and Nexus connections
ScopeQuick visual building & a developer console for one nodeFull IDE + multi-runtime control plane and ops console
Best forFast, zero-install agent building inside a running nodeDay-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.

I want to…Use…
Define agents with YAML and run the runtime directlyAstromesh Core
Define agents with Python decorators and a CLIAstromesh ADK
Build agents visually in the browser, embedded in a nodeAstromesh Forge
Design, test, and deploy from a desktop IDEAstromesh Cortex
Go from idea to a deployed WhatsApp agent in plain EnglishAstromesh Leia
Build software with a coding agent, spec first, with every requirement traced to a testAstromesh SDD
Install as a system service on Linux, macOS, or WindowsAstromesh Node
Run agents on a hardened, immutable applianceAstromesh OS
Deploy in containers or KubernetesDocker / Helm (part of core)
Provision cloud infrastructure with TerraformAstromesh Orbit
Run a multi-tenant agent platform on KubernetesAstromesh Nexus
Put an agent on WhatsApp, and let it message people backAstromesh Herald
Give a model the right documents, with a pattern you can switch and a trace you can readAstromesh RAG
Decide what the model reads under one token budget, and measure the choiceAstromesh Context
Call or serve agents over A2A without trusting the remoteAstromesh A2A
Replace a long tool-calling loop with one reviewed programGlyph
Manage nodes and clusters from the command lineAstromesh CLI
Hand the workload to a cloud’s own managed AI serviceAstromesh Prisma (in development)
Train and publish the ecosystem’s own open modelsAstromesh Nebula

The ecosystem forms a layered stack. You choose your entry point at each layer:

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.

ComponentStart here
Core RuntimeQuick Start — run your first agent in 5 minutes
ADKADK Introduction — Python-first agent development
ForgeForge Introduction — visual agent builder
CortexCortex Introduction — desktop IDE & control plane
LeiaLeia Introduction — agents in plain English
NodeNode Introduction — install as a system service
OSOS Introduction — the immutable agent appliance
OrbitOrbit Introduction — provision cloud infrastructure
NexusNexus Introduction — multi-tenant Kubernetes control plane
PrismaPrisma Introduction — the multi-cloud reconciler, and what it does not do yet
HeraldHerald Introduction — channels in, proactive messages out
GlyphGlyph Introduction — the action language, and when it actually pays
OKFOKF Introduction — navigating knowledge bundles from any framework
RAGRAG Introduction — retrieval patterns from swappable parts, and how to choose one
ContextThe map of context patterns — six questions about context and knowledge, and which pattern answers each
A2AA2A Introduction — the library, type: a2a tools, remote_a2a() and Nexus as an A2A server
NebulaNebula Introduction — the open-model foundry where our models are born
Built by FAiNANSU