Skip to content
Astromesh Logo

Astromesh

Multi-model, multi-pattern AI agent runtime with declarative YAML configuration.

The Astromesh ecosystem

One runtime,
18 shipped pieces around it.

Every component is versioned and released on its own cadence. They all meet at the core runtime — the engine that loads an agent and runs it. Pick a part of the stack to see what lives there.

Clockwise from the top: author an agent, choose how it executes, put it in front of people, ship it somewhere, operate it — and, upstream of all of it, make the models.

Four ways to write an agent — Python, browser, desktop, or plain English — all emitting the same YAML, and a spec-first method for building software with coding agents.

What runs around the model: an action language for when a loop of tool calls is the wrong shape, and libraries that put the right knowledge in front of it.

How an agent reaches out: a gateway to the person it is talking to, in both directions, and a protocol to agents running on someone else’s stack.

Where the runtime lives: a system service, a sealed appliance, or cloud infrastructure you did not have to write.

Day two. Who is running what, for which tenant, at what cost.

Upstream of everything: the foundry that trains and publishes the models the runtime routes to.

Define agents in YAML. Astromesh handles the rest — from input safety checks to model routing to tool execution.

Action language glyph-v0.1.3

The plan is a program

A ReAct loop asks the model what to do next, one tool at a time, and resends the whole prompt every turn. With pattern: glyph the model writes the plan once, as a program, and the runtime executes it — chaining locally and running independent statements at the same time.

parts-agent.glyph 5 constructs, no loops
1 v = search_parts(make="Toyota", year=2019) 3 oem = v | where(kind == "oem") | top(3, by=rating) 4 alt = v | where(stock > 0) | top(3, by=price) 6 if oem.empty: 7 eta = check_restock(sku=v.first.sku) 9 return {oem, alt, eta}

What the compiler derives

wave 1
search_parts
one call
wave 2
oem alt
independent — run together
wave 3
check_restock
only if oem came back empty
wave 4
return
result

Each name is bound exactly once, so reads and writes give an exact dependency graph. oem and alt never read each other, so nothing forces them into sequence.

Measured, against three models

Model writes the program on every run

+164% to +2839%

more expensive than ReAct, and slower in 16 of 17 runs. Output tokens cost roughly 4× input tokens, and this trades cheap input for expensive output — 81–99% of the bill is the model writing code.

Program reviewed once, pinned in spec.program

zero model calls

The model authors it, you review and parameterise it, the runtime executes it from then on. This is the mode Glyph is for, and the reason a fixed program that fails to compile stops the agent from loading instead of quietly falling back.

x = cap(arg=v) Call. Arguments are always by name.
x = c | where(a == 1) Filter a collection; conditions AND together.
x = c | top(3, by=f) Sort descending and truncate.
x = c | map({g: cap(id=id)}) One call per item, in parallel, capped at 16.
if / else The only branch. The same name may be bound in both arms.
return {x, y} {x} is shorthand for {"x": x}.
LIBRARY okf-v0.1.0

Astromesh OKF

Navigate knowledge, don't retrieve chunks

Three tools that let an agent in any framework walk an Open Knowledge Format bundle: read the index, search by type or tag, open a concept and follow its links.

okf · navigation
1 kb_index("/")
2 * policies/ - Customer-facing policies.
3 * products/ - What we sell.
4 kb_find(type="Policy")
5 policies/refunds · human-reviewed
6 kb_read("policies/refunds")
7 title: Refund policy · trust: human-reviewed
8 link → products/plans (exists)
3 tools kb_index · kb_find · kb_read
9 frameworks LangChain, CrewAI, ADK, …
MCP server Claude Desktop, Code, Cursor
Trust & freshness Warnings, never hidden
Never raises Errors come back as JSON
Path confinement Symlinks resolved first
$ pip install astromesh-okf
$ astromesh-okf index ./bundle
SKILLS sdd-v0.1.0

Astromesh SDD

Spec first, for any coding agent

Seven skills that make a coding agent write a spec, a plan and tasks before the code, and verify against the spec at the end — every phase a file next to your code.

sdd · one feature
1 /sdd add slugify(title) to textutil
2 specify → specs/001-slugify-title/spec.md
3 REQ-1 … REQ-7 · 0 NEEDS CLARIFICATION
4 plan → plan.md · tasks → T-1 … T-3
5 T-1 check: python3 -m unittest → OK
6 /sdd-verify
7 REQ-1 … REQ-7 ✅ · Verdict: PASS
7 skills specify → plan → tasks → verify
Files on disk Any session or agent resumes
6 agents Claude Code, Codex, OpenCode, …
Traceable REQ → task → evidence
Human gates Approval recorded in the file
Yours to bend .sdd/ rules, templates, phases
$ /plugin marketplace add monaccode/astromesh-sdd
$ /plugin install astromesh-sdd@astromesh
LIBRARY rag-v0.1.0

Astromesh RAG

Every RAG pattern, one set of parts

Ingest, retrieve, rank and build the context from small, swappable parts. Switch pattern by changing one line, and read in the trace what each stage did.

rag · one hybrid query, offline
1 uv run python examples/hybrid.py
2 > ¿Qué significa ERR-4012?
3 trace:
4 retrieve vector 1.0 ms 1->10
5 retrieve bm25 0.2 ms 1->10
6 fuse RRF 0.0 ms 20->10
7 context context 0.0 ms 10->5
4 patterns naive, hybrid, multi_query, hyde
A trace per query Every stage: ms, in, out, error
5 vector stores memory, FAISS, Chroma, Qdrant, pgvector
Python or YAML kind: RAGPipeline, one line per pattern
Open registry Register a part, use it by name
Labeled benchmark 200 docs, 60 questions, 4 traps
$ pip install astromesh-rag
LIBRARY context-v0.1.0

Astromesh Context

What goes into the window, decided in one place

Knowledge, memory and history fill one token budget, and every item comes back marked in or out with the reason. A concept OKF marks as deprecated stays out, and says why.

context · explain, test fixture
1 astromesh-context explain --config policy.yaml \
2 --query "Can I get a refund after 3 weeks?"
3 id final tokens
4 static:5d57e41583af 1.000 24 in
5 okf_index:/ 1.000 18 in
6 okf:policies/refunds 1.650 50 in
7 okf:policies/refunds-v1 0.656 25 out deprecated
8 okf:policies/shipping 0.175 20 in
One budget RAG, OKF, memory, history compete
A trace per item in, or out with the reason
Cross-source dedupe Inherits OKF deprecation
Cache-friendly order Stable content first, byte for byte
3 policies knapsack, fixed slots, everything
Published eval Level 1 run; level 2 pending
$ pip install astromesh-context
LIBRARY a2a-v0.1.1

Astromesh A2A

Talk to other agents without trusting them

A client and a server for the A2A 1.0 protocol on the official SDK. Every remote is checked against a policy, its output reaches your model wrapped as untrusted, and a remote can never confirm anything for your user.

a2a · the attack eval, default policy
1 python -m astromesh_a2a.eval
2 trap stopped
3 card_spoof yes requests to host B: 0
4 redirect_internal yes internal hits: 0
5 dns_private yes reached a socket: 0
6 injection_text yes one intact, escaped block
7 self_confirm yes RPCs sent: 1, no reply
8 9/9 traps stopped
Policy first Nothing reachable until you list it
Pinned egress No SSRF, no rebinding, no redirects
Untrusted output Remote words wrapped and escaped
Never auto-confirms A remote “yes” is an agent turn
9 frameworks LangChain, CrewAI, ADK, MCP, …
Core, ADK, Nexus type: a2a, remote_a2a(), served cards
$ pip install astromesh-a2a
NEW adk-v0.7.1

Astromesh ADK

Agent Development Kit

Build AI agents in pure Python. Decorators, auto-generated schemas, multi-agent teams — powered by the same runtime engine under the hood.

my_agent.py
1from astromesh_adk import agent, tool
2 
3@tool(description="Search the web")
4async def search(query: str) -> str:
5 return await fetch_results(query)
6 
7@agent(
8 name="assistant",
9 model="openai/gpt-4o",
10 tools=[search],
11)
12async def assistant(ctx):
13 """You are a research assistant."""
14 return None
Decorators Python-first API
Auto Schema From type hints
6 Providers One string config
Multi-Agent 4 team patterns
CLI 5 commands
Local + Remote One codebase
$ pip install astromesh-adk
$ astromesh-adk run my_agent.py:assistant "What is quantum computing?"

Everything you need to build, deploy, and scale AI agents.

core

6 LLM Providers

Connect to any model, local or cloud

Details

Ollama, OpenAI-compatible, vLLM, llama.cpp, HuggingFace TGI, ONNX Runtime. Automatic failover with circuit breaker (3 failures → 60s cooldown).

core

7 Orchestration Patterns

From simple to multi-agent

Details

ReAct (think-act-observe), Plan & Execute, Parallel Fan-Out, Pipeline, Supervisor (delegate to workers), Swarm (agents hand off conversations), Glyph (the plan is a program, not a loop).

3 Memory Types Persistent context across conversations

Conversational (Redis/PG/SQLite), Semantic (pgvector/ChromaDB/Qdrant/FAISS), Episodic (PostgreSQL). Strategies: sliding window, summary, token budget.

RAG Pipeline Document ingestion to retrieval

4 chunking strategies (fixed, recursive, sentence, semantic), 3 embedding providers, 4 vector stores, 2 rerankers (cross-encoder, Cohere).

Mesh Discovery (Maia) Nodes find each other automatically

Gossip-based discovery, failure detection (alive→suspect→dead), leader election, least-connections routing. No manual peer configuration.

Rust Extensions 5-50x speedup on CPU-bound paths

Optional native Rust extensions via PyO3 for chunking, PII detection, tokenization, rate limiting. Pure Python fallback when not compiled.

Developer Experience

Your Toolkit

Three tools, one workflow. Define agents in YAML, run them instantly, debug with full traces — all wired together.

astromeshctl

Your command center

16 commands to scaffold, run, debug, monitor, and deploy agents — without ever leaving the terminal.

01
$ new agent Scaffold a YAML agent
02
$ run Execute instantly
03
$ traces Full execution trees
04
$ metrics Token & cost tracking
05
$ doctor Health diagnostics
06
$ ask AI copilot, inline
CLI Reference

Built-in AI Copilot

Answers that know your project

An AI assistant embedded in both CLI and VS Code that understands your agents, configs, and runtime — ask anything.

01
$ ask "Why is this slow?" Performance insights
02
$ ask "Add a RAG pipeline" Config generation
03
$ ask "Explain this trace" Debugging help
04
$ ask "Compare providers" Decision support
05
$ Copilot Chat panel Interactive in VS Code
06
$ Context-aware Reads your YAML files
Copilot Guide

VS Code Extension

Your editor becomes mission control

7 integrated features turn VS Code into a full agent development environment — from IntelliSense to live traces.

01
$ YAML IntelliSense Auto-complete & validation
02
$ ▶ Play Button Run agents from editor
03
$ Traces Panel Expandable span trees
04
$ Metrics Dashboard Real-time charts
05
$ Workflow Visualizer DAG visualization
06
$ Copilot Chat AI assistant panel
Extension Docs
Coming Soon

Connect to remote Astromesh clusters from VS Code — deploy, monitor, and orchestrate agents across production environments, all from your editor.

From a single command to a production Kubernetes cluster.

git clone https://github.com/monaccode/astromesh.git
cd astromesh
uv sync --extra all
astromeshctl init --dev
astromeshd --config ./config
NEW orbit-v0.4.4

Astromesh Orbit

Deploy to Any Cloud

One command to provision a production-ready Astromesh stack on GCP. Cloud-native managed services, declarative config, and an escape hatch to raw Terraform.

orbit.yaml
1apiVersion: astromesh/v1
2kind: OrbitDeployment
3metadata:
4 name: my-astromesh
5 environment: production
6spec:
7 provider:
8 name: gcp
9 project: my-project-123
10 region: us-central1
One Command orbit apply
Cloud-Native Managed services
Multi-Cloud GCP first, then AWS & Azure
Escape Hatch Eject to raw Terraform
Marketplace GCP Marketplace ready
Secure Defaults VPC, IAM, Auth Proxy

What gets provisioned:

Cloud Run Runtime
Cloud SQL PostgreSQL 16
Memorystore Redis
Secret Manager JWT / Provider Keys
$ pip install astromesh-orbit[gcp]
$ astromeshctl orbit apply --preset starter
NEW node-v0.1.10

Astromesh Node

Deploy as a Native System Service

Install Astromesh as a first-class OS service on Linux, macOS, and Windows. Platform packages, automatic restarts, CLI management, and 7 runtime profiles — no containers required.

Choose your platform:

Debian / Ubuntu sudo apt install ./astromesh_latest_amd64.deb
RHEL / Fedora sudo dnf install ./astromesh_latest_x86_64.rpm
macOS sudo ./install.sh
Windows .\install.ps1
System Service systemd, launchd, WinSvc
CLI Management astromeshctl
7 Profiles full, gateway, worker...
Cross-Platform Linux, macOS, Windows
Auto-Restart Restart on failure
Health Checks doctor + watchdog
$ sudo astromeshctl init --profile full
$ astromeshctl status
● Running v0.1.10 1 agent loaded 1 provider healthy

Astromesh is more than a runtime. Build agents visually, run them on a hardened appliance, orchestrate them across tenants in the cloud, put them in front of customers on WhatsApp, or spin one up in plain English.

NEW cortex-v0.29.0

Astromesh Cortex

Desktop IDE & Control Plane

A native desktop IDE for designing, testing, and shipping agents — with a managed local runtime, GCP provisioning via Orbit, and a Nexus cloud console in a single window.

.cortex/workspace.json
1 {
2 "name": "support-agents",
3 "connections": {
4 "runtime": [{ "type": "local", "url": ":8000" }],
5 "nexus": [{ "tenantId": "prod" }]
6 },
7 "environments": { "dev": { "vars": {…} } }
8 }
Desktop IDE Electron 41 · React 19
Visual Builder Drag-and-drop canvas
Local Runtime Managed venv on :8000
Deploy Anywhere Local · GCP · Nexus
Channels WhatsApp setup wizard
Dev Tunnel ngrok / cloudflared
$ npm install
$ npm run dev
NEW nexus-v0.28.2

Astromesh Nexus

Managed Multi-Tenant Control Plane

Publishes agents with versioning, dispatches runs to a shared runtime pool, and meters and bills what each one consumes. External clients call one REST API; Nexus resolves the tenant, applies its limits, and records the invocation.

run an agent
1 POST /api/v1/agents/soporte/run
2 X-API-Key: <tenant key>
3 {
4 "query": "¿Cuándo llega mi pedido?",
5 "session_id": "wa:+5491100000001"
6 }
7 → 200 { "answer": …, "usage": {
8 "credits": 412, "model": "kimi-k2" } }
Multi-Tenant The tenant comes from the credential
Versioned Registry Specs in Postgres, author + checksum
Metering & Billing Per run, per model, per tenant
Shared Runtime Pool Dispatch, not a node per tenant
Streaming Runs WebSocket, cancellable mid-flight
Per-Run Credentials One tenant, one capability, one run
$ kubectl apply -k deploy/overlays/mvp
$ curl -H "X-API-Key: $KEY" $NEXUS/api/v1/agents
New herald-v0.14.0

Astromesh Herald

The communications gateway

An inbound WhatsApp message reaches an agent, and an agent reaches a person back — through the same Postgres outbox, with the same retry budget. Herald never talks to the runtime: whether an agent exists and who may run it is Nexus's call, checked when a binding is created and again on every run.

One message, end to end
Inbound
  1. Person WhatsApp
  2. Webhook HMAC-SHA256 checked
  3. Route conversation or entry agent
  4. Nexus POST /agents/:name/run
Outbound
  1. Person delivered
  2. Channel API Graph API send
  3. Outbox 10 attempts, 30s × 2ⁿ

An agent calling send_message mid-run enters at the outbox too — same queue, same retries. A success means queued, never delivered.

The entry agent decides

When no conversation exists yet for a sender, the binding's entry agent gets the message and answers with a routing decision. That is how a courtesy refusal costs nothing: nothing is persisted, and the answer is still delivered.

{
  "answer": "Te ayudo con tu reclamo.",
  "data": {
    "route": {
      "start_session": true,
      "handoff_agent": "reclamos"
    }
  }
}

Channels

  • WhatsApp live Meta Cloud API — text, media, templates
  • Echo dev the whole pipeline with no provider account
  • Telegram reserved port implemented, returns ErrNotImplemented
  • Web chat reserved needs a WebSocket endpoint to activate
  • SMTP reserved outbound only, by design

Stubs are real port implementations that refuse work — the contract exists, the provider does not. Listing them as shipped would be a lie you would find out on a Friday.

APPLIANCE os-v0.13.8

Astromesh OS

Immutable Agent Appliance

A minimal, immutable, API-only Linux appliance built with mkosi on Debian trixie — a verified read-only root, A/B updates with automatic rollback, and the Astromesh runtime baked in at a pinned commit. Mature through Phase 4 + post-4: TPM-sealed secrets, mesh mTLS, OTel, and eBPF causal egress.

mkosi.conf
1 [Distribution]
2 Distribution=debian Release=trixie
3 [Content]
4 Bootloader=systemd-boot
5 UnifiedKernelImages=yes
6 SplitArtifacts=uki,partitions
7 # read-only root · dm-verity · A/B
8 # core image must stay ≤ 500 MB
Immutable Root dm-verity verified
A/B Updates sysupdate + rollback
API-Only No shell · no SSH
Tiny Footprint ≤ 500 MB ceiling
OCI Artifact Pulled via ORAS
Reproducible Pinned runtime ref
$ oras pull ghcr.io/monaccode/astromesh-os:v0.13.8
$ PHASE0_MODE=stub mkosi build
PLUGIN leia-v0.11.2

Astromesh Leia

Agents in Plain English

A Claude Code plugin that turns a business idea into a deployed WhatsApp agent on a Nexus cluster — no Kubernetes required. Named after Leia, a lemon beagle: approachable, loyal, friendly.

leia · session
1 /leia bootstrap local
2 ✓ Kind cluster ready · nexus @ :8080
3 /leia I need a WhatsApp bot for my café
4 ◆ interpreter → architect → preview
5 ✓ deployed: cafe-support (running)
6 /leia test cafe-support
7 > "What time do you open?"
8 ◇ "We open at 8am every day ☕"
Natural Language Plain-English ops
10 Commands create · deploy · test
5 Subagents interpreter → architect
6 Templates support · booking · …
Nexus-Native Kind or remote cluster
Smart Models Ollama + cloud fallback
$ claude plugins add ./astromesh-leia
$ /leia create a lead-qualifier bot

Create a YAML file, start the daemon, call the API.

config/agents/hello.agent.yaml
apiVersion: astromesh/v1
kind: Agent
metadata:
  name: hello-agent

spec:
  identity:
    description: A minimal test agent

  model:
    primary:
      provider: ollama
      model: llama3.1:8b
      endpoint: http://ollama:11434
      parameters:
        temperature: 0.7

  prompts:
    system: |
      You are a helpful assistant.
      Keep responses brief.

  orchestration:
    pattern: react
    max_iterations: 3
Terminal
curl -X POST http://localhost:8000/v1/agents/hello-agent/run \
  -H "Content-Type: application/json" \
  -d '{"query": "What is 2+2?", "session_id": "demo"}'
Response
{
  "agent": "hello-agent",
  "response": "2 + 2 = 4",
  "session_id": "demo",
  "tokens_used": 42,
  "provider": "ollama",
  "pattern": "react",
  "iterations": 1
}

Release ledger

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. Latest movement 2026-11-04

  1. 2026-11-04 Core Runtime v0.75.0

    The OpenAI-compatible provider sends extra `headers` on every request (a gateway key, a tenant id), from `providers.yaml` or the agent’s `model` block; `${VAR}` values fail loudly when unset, `Authorization` and transport headers are reserved, and values never reach logs. Agents now load in alphabetical order on every machine. Since 0.74, tools `type: a2a` call a remote A2A agent through `astromesh-a2a` (extra `astromesh[a2a]`): only the `card_url` host is reachable, the remote’s output reaches the model wrapped as untrusted, an `input_required` stays pending per session, and the tool always runs as an agent turn. Since 0.73, `origen` (`humano`|`agente`) on run and WebSocket — an agent turn never confirms a `confirm`-gated tool — and `spec.skills` for Agent Cards. 0.74.1 uses the public helpers of `astromesh-a2a` 0.1.1, with no change in behaviour.

  2. 2026-11-04 Astromesh Leia v0.11.2

    Knows the whole published ecosystem — a request-to-component table (Spanish or English) covering Cortex 0.29, Forge 0.29.1, Glyph, Orbit vs. Prisma (in development) and Nebula/Centinela (preview) — and maps Spanish verbs to its intents. Since 0.10, synced to core 0.74.1 and Nexus 0.28.2: designs `type: a2a` tools, publishes agents over A2A (`spec.a2a.publicar` + `spec.skills`) and checks the Agent Card after deploy; knows the rest of the ecosystem (`astromesh-a2a`, `-okf`, `-rag`, `-context`, ADK 0.7). 0.11.2: Herald 0.14.0, attachments to `media_callback_url`.

  3. 2026-11-03 Astromesh Herald v0.14.0

    A binding that runs an agent can also send every message with attachments to `media_callback_url`, signed with its own secret, through the same outbox: the agent keeps the conversation and another service gets the photos. Since 0.13, new conversations per day, hour and channel for an owner’s dashboard (`GET /admin/stats/conversaciones`).

  4. 2026-10-22 Astromesh Forge v0.29.1

    Creates and edits `type: a2a` tools: card URL, auth as an environment variable name (never the secret), optional policy and description, validated with the same limits as the runtime so it never writes YAML that leaves the agent in draft.

  5. 2026-10-22 Astromesh Cortex v0.29.0

    A2A panel on Nexus agents: the Agent Card a caller sees, or why there is none. Since 0.28, schema at parity with core 0.74.1: `type: a2a` tools with a form that validates like the core, and an A2A block for `spec.a2a.publicar`, the card description and `spec.skills`.

  6. 2026-10-20 Astromesh ADK v0.7.1

    `remote_a2a()` uses any A2A agent like an ADK agent — `run()`, `stream()`, `as_tool()` — over `astromesh-a2a` (extra `astromesh-adk[a2a]`), always as an agent turn. Remote calls through `bind()`/`connect()`/`remote()` now declare `origen: "agente"`, so a remote node never takes the parent model’s "si" as a human confirmation. 0.7.1: `remote_a2a()` passes the task’s `context_id` when it replies to a pending task.

  7. 2026-10-20 Astromesh Context v0.1.0

    Engine that fills one budget across sources and returns a trace per item; three policies; containment dedupe that inherits OKF deprecation; Compactor and Offloader for the agent loop; ContextEval with a published level-1 table; LangChain, PydanticAI and MCP integrations.

  8. 2026-10-20 Astromesh A2A v0.1.1

    First release: `RemoteAgent` client and `serve`/`create_app` server on the official A2A SDK, a pinned egress guard, `Policy` with budgets and signed cards, tools for nine frameworks (MCP included), a redacted trace per call and a nine-trap attack eval in CI. On PyPI. 0.1.1 adds the task API (`submit`, `get_task`, `subscribe`, `list_tasks`), `reply(..., context_id=)` and the public `tool_description` and `PENDING_NOTE`.

  9. 2026-10-20 Astromesh Nexus v0.28.2

    Published agents are served over A2A 1.0 (opt-in with `spec.a2a.publicar: true`): Agent Card and JSON-RPC behind the tenant’s API key or JWT, blocking, streaming and background (`returnImmediately`) runs, `GetTask`, `CancelTask` across replicas, `SubscribeToTask`, `ListTasks` and signed push notifications (off by default). Every A2A run is an agent turn and is billed like any invocation. The runtime pool runs core 0.74.1, so published agents can call remote A2A agents as tools. A completed A2A run carries its usage (tokens and Nexus credits) as a final data part.

  10. 2026-10-17 Astromesh OS v0.13.8

    Runtime at core v0.71.0 (permissions, semantic/episodic memory, swarm and `timeout_seconds` now applied), still with its own CPython and no system python3. The boot gate passes on the new pin.

  11. 2026-10-17 astromeshctl v0.4.1

    The `new agent` template emits `timeout_seconds: 120`: on core 0.71 the old `timeout: 30` cut every run at 30 s. Requires core 0.71. Since 0.4.0, `astromeshctl eval` and the BLOCKED panel in `run`.

  12. 2026-10-14 Astromesh RAG v0.1.0

    First release: four retrieval patterns with optional reranking, memory, FAISS, Chroma, Qdrant and pgvector indexes, `kind: RAGPipeline` YAML, a trace per query, retrieval metrics and a labeled benchmark corpus. Tagged on GitHub and on PyPI.

  13. 2026-10-13 Astromesh SDD v0.1.0

    First release: seven Agent Skills, a Claude Code plugin, installers for Claude Code and the `.agents/skills` agents (Codex, OpenCode, Kimi, Gemini, Copilot), and `.sdd/` settings to customize them.

  14. 2026-10-13 Astromesh OKF v0.1.0

    First release: the core reader ported from the runtime, plus adapters for LangChain/LangGraph, CrewAI, Google ADK, OpenAI Agents SDK, PydanticAI, LlamaIndex, smolagents, Microsoft Agent Framework and an MCP server, on PyPI.

  15. 2026-09-28 Astromesh Node v0.1.10

    A macOS tarball for Intel Macs alongside Apple silicon; every package carries its own CPython and is installed and run on a clean machine before it is published.

  16. 2026-09-28 Astromesh Orbit v0.4.4

    `orbit apply` asks before creating billable resources (skip with `--auto-approve`), and `orbit init --provider/--preset` answer the wizard.

  17. 2026-09-27 Glyph v0.1.3

    Release aligned with the astromesh 0.59.0 round; still no runtime dependencies.

  18. 2026-06-09 Astromesh Nebula v0.1.0

    The Foundry pipeline and the GitOps catalog, with Centinela as the first model through it.

Status board

What is green, and what version it is

One row per repository, coloured by the slice of the stack it belongs to — the same taxonomy as the chart above.

Built by FAiNANSU