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.
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.
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 / elseThe only branch. The same name may be bound in both arms.
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.
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.
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.
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
1astromesh-context explain --config policy.yaml \
2 --query "Can I get a refund after 3 weeks?"
3id final tokens
4static:5d57e41583af 1.000 24 in
5okf_index:/ 1.000 18 in
6okf:policies/refunds 1.650 50 in
7okf:policies/refunds-v1 0.656 25 out deprecated
8okf:policies/shipping 0.175 20 in
One budgetRAG, OKF, memory, history compete
A trace per itemin, or out with the reason
Cross-source dedupeInherits OKF deprecation
Cache-friendly orderStable content first, byte for byte
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
1python -m astromesh_a2a.eval
2trap stopped
3card_spoof yes requests to host B: 0
4redirect_internal yes internal hits: 0
5dns_private yes reached a socket: 0
6injection_text yes one intact, escaped block
7self_confirm yes RPCs sent: 1, no reply
89/9 traps stopped
Policy firstNothing reachable until you list it
Pinned egressNo SSRF, no rebinding, no redirects
Untrusted outputRemote words wrapped and escaped
Never auto-confirmsA remote “yes” is an agent turn
9 frameworksLangChain, CrewAI, ADK, MCP, …
Core, ADK, Nexustype: a2a, remote_a2a(), served cards
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 TypesPersistent context across conversations
One command to provision a production-ready Astromesh stack on GCP.
Cloud-native managed services, declarative config, and an escape hatch to raw Terraform.
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.
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.
NEWcortex-v0.29.0
AstromeshCortex
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.
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
1POST /api/v1/agents/soporte/run
2X-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-TenantThe tenant comes from the credential
Versioned RegistrySpecs in Postgres, author + checksum
Metering & BillingPer run, per model, per tenant
Shared Runtime PoolDispatch, not a node per tenant
Streaming RunsWebSocket, cancellable mid-flight
Per-Run CredentialsOne tenant, one capability, one run
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
PersonWhatsApp
WebhookHMAC-SHA256 checked
Routeconversation or entry agent
NexusPOST /agents/:name/run
the agent answers
Outbound
Persondelivered
Channel APIGraph API send
Outbox10 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
WhatsAppliveMeta Cloud API — text, media, templates
Echodevthe whole pipeline with no provider account
Web chatreservedneeds a WebSocket endpoint to activate
SMTPreservedoutbound 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.
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.
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.
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
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.
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`.
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`).
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.
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`.
`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.
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.
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`.
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.
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.
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`.
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.
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.
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.
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.