The agentic runtime, in a sidecar.

Persistent state per agent or per user. Three facets: key-value (atomic incr, TTL, cross-run continuity), vector (semantic search via sqlite-vec / pgvector with provider-agnostic embedders), and now SQL (RFC AA, v1.2.0 — a per-scope SQL database the runtime hosts; sqlite + postgres tiers, default-deny sql_scopes gate, explicit + nested transactions, vector columns, snapshot integration, durable + ephemeral scopes, read-only shared schemas).

// SQL facet (RFC AA, v1.2.0)
{"tool":"memory",
 "input":{"op":"sql_exec",
         "scope":"user",
         "sql":"CREATE TABLE primes (n INTEGER PRIMARY KEY)"}}

Persistent inter-agent message bus. One agent publishes; another subscribes; no orchestrator handoff. Cursor-based delivery.

// publish to a channel
{"tool":"channel",
 "input":{"op":"publish",
         "name":"jobs.scored",
         "payload":{...}}}

Content-addressed, forkable, lineage-tracked. The substrate for self-evolution - and loomcycle import claude-code lifts .claude/agents/*.md + .claude/skills/*/SKILL.md directly into the substrate without rewriting.

// fork a new definition
{"tool":"agentdef",
 "input":{"op":"fork",
         "from":"matcher.v4",
         "prompt":"…"}}

Rate runs against versioned definitions. Selection stays policy - never auto-promote. Humans (or downstream agents) choose.

// score a run
{"tool":"evaluation",
 "input":{"op":"score",
         "run":"r_82a1",
         "rubric":"match.v2"}}

The introspection primitive. Ten ops covering self · tools · agents · history · help · time. The closing loop that makes the substrate learnable - an agent that can read itself can rewrite itself.

// what tools do I have?
{"tool":"context",
 "input":{"op":"tools"}}    // → list with shapes, costs, allowed-hosts

Cron-driven autonomous runs. on_complete hook → channel publish. max_fires self-retire. RFC S adds Channel.await fan-in and Context op=time so the substrate finally has a clock for cycle bucketing and deadline math.

// declare a cron schedule
{"tool":"scheduledef",
 "input":{"op":"create",
         "cron":"0 3 * * *",
         "agent":"nightly-scan",
         "max_fires":30}}

Signed-by-default external trigger. HMAC-SHA256 over the raw body - Stripe, GitHub, Linear, n8n envelopes all auto-detected. Two-layer idempotency (in-memory + durable). Never silently degrades.

// declare a webhook endpoint
{"tool":"webhookdef",
 "input":{"op":"create",
         "path":"github-pr",
         "delivery":"spawn",
         "agent":"pr-reviewer"}}

Per-agent ro/rw filesystem roots. {name, path, mode}. Static volumes from yaml plus a runtime-mutable VolumeDef substrate (tenant-scoped, runtime-derived path — never caller-supplied). Spawn-narrow: a sub-agent's volume set ⊆ its parent's. Ephemeral run-scoped: ephemeral=true auto-purges when the top-level run completes (clone repo, work, vanish). Sandbox-by-default replaces the global jail. v1.3.0: the new Bashbox tool (RFC AJ, opt-in via LOOMCYCLE_BASHBOX_ENABLED=1) honors ro volumes via an in-RAM write overlay, closing the asymmetry rule #7 left open (the existing Bash tool still refuses ro). v1.4.0: VolumeDef.create mount_at: registers a volume_mount dirent in the new Path tree.

// ephemeral volume for an on-demand workspace
{"tool":"volumedef",
 "input":{"op":"create",
         "name":"lc-src",
         "mode":"rw",
         "ephemeral":true}}

Unix-like VFS over Memory, Volumes, and Documents. Tenant-rooted, scope-aware. Borrows the Linux inode/dirent split: resources keep permanent ids, a dirents row maps (parent_path, name) → resource. One tree spans three resource kinds; renames are cheap dirent updates that never touch the resource. Six ops (resolve / ls / stat / mkdir / mv / rm). Paths reject ..; segments [a-zA-Z0-9._-]+. Resources opt in to a name: Memory.set path:, VolumeDef.create mount_at:, Document.create_document path:. SQL Memory stays out of the tree. A dirent is a name, not an authority grant — the resource's own scope/tenant check still applies. On every transport.

// list a directory
{"tool":"path",
 "input":{"op":"ls",
         "path":"/docs/launches/",
         "scope":"user"}}

Chunked-graph documents. Each chunk is a first-class unit: UUID, hierarchy position, optional supertag-like type, structured fields, graph edges, Markdown body, optimistic revision. Content/structure split: chunk content lives in Memory keyed by UUID, chunk structure lives in SQL Memory across four tables (documents / chunks / chunk_edges / chunk_types). 13 ops: document lifecycle, chunk CRUD, edges (link_chunks / unlink_chunks), query (structured + under_path Path-join + raw sql: escape hatch through the SQL Memory validator), type defs. Atomic deletes in one SQL Memory transaction; bidirectional edge cleanup; move_chunk cycle guard. A Document at /docs/foo lists as a directory in Path AND resolves as one resource (macOS bundle semantics). On every transport. v1.5.0: per-principal /v1/_mcp dispatch (RFC AG) + declared static (tenant, subject) principals (RFC AO) close the cross-transport identity gap, so an agent's MCP-created documents and the Web UI's /ui/paths share the same per-scope SQLite file by construction.

// query the chunk graph
{"tool":"document",
 "input":{"op":"query_chunks",
         "under_path":"/docs/launches/",
         "type":"publication",
         "status":"draft"}}

One docker compose up brings up Grafana + Tempo + Prometheus + Loki + OTEL Collector with a ten-panel loomcycle-overview dashboard auto-provisioned. Run latency p50/p95/p99, provider RTT, tool call rate, MCP latency, error rate by provider - plus process and concurrency from /metrics. seed.sh drives synthetic traffic so the panels populate immediately. Self-hosted, no SaaS bill.

Set four env vars and you're sending OTLP to your Honeycomb dataset at a production-sensible 10% sampler. Ships eight canonical queries (run rate, latency, provider RTT, tool rate, MCP latency, error rate, token spend, slowest traces), three derived-column definitions, and a ten-minute board-authoring walkthrough against your team's dataset.

OTLP to your existing Datadog agent on :4318; agent forwards to the Datadog backend. Same eight canonical queries as Profile B in Datadog APM syntax, plus a DD_SITE knob for non-default regions and a fifteen-minute dashboard-authoring walkthrough against your org's service tags.

Postgres LISTEN/NOTIFY backplane (no Redis dep in v1.0). Cross-replica cancel + cluster-wide pause/resume + bus fanout + advisory-locked singleton sweepers. SQLite refuses cluster mode at boot (clear error, not silent fail). The runtime grows from one replica on a cheap VPS to many machines without changing shape. writeup →

1.27M circuits. 3.8M agent runs. 100% completion across 468 waves. Per-replica load split to 0.14%. Zero leaks (RSS, goroutines, connections, quotas). The substrate doesn't drift under sustained load. The number gate v1.0 had to clear. writeup →

Seventh substrate primitive. Per-principal lct_… bearer tokens bound to an authoritative {tenant_id, subject, scopes} resolved from the token, never from the wire. Per-route + per-RPC scope enforcement (deny-by-default-to-admin on gRPC), tenant-scoped read boundary, role-aware Web UI with super-admin tenant-focus switcher. Adversarial-QA pass found and closed one CRITICAL gRPC bypass plus three HIGH cross-tenant isolation breaks before tag. writeup →

Distributed traces across loop + providers + tools + MCP. Three drop-in profiles ship in the repo: self-hosted Grafana / Tempo / Prometheus / Loki, Honeycomb, Datadog APM. Plus a bearer-authed /metrics Prometheus endpoint live-read from runtime counters. Pick your backend; no vendor SDK in the loop.

Runtime-wide quiesce + cross-version-portable JSON snapshot. RFC X both phases shipped: F41 cooperative pause parks in-flight sub-runs at iteration boundaries; F42 cross-instance resume re-dispatches paused runs on a fresh box. exp6.5 wipes a DB, restores on a fresh loomcycle instance, and the paused breeder finishes its work autonomously. writeup →

Loomcycle publishes an AgentCard at /.well-known/agent-card.json; three protocol bindings (REST, JSON-RPC, gRPC); signed cards over RFC 8785 JCS canonicalization; multi-tenant routing in three modes; INPUT_REQUIRED↔Interruption bridge. Reachable from Microsoft Agent Framework, Google ADK, LangGraph. Outbound: synthetic a2a__<peer>__<skill> tools. Built against a2a-go v2.3.1. writeup →

External systems sign + POST events; loomcycle either spawns a run (delivery: spawn) or publishes to a channel to wake an agent already waiting (delivery: channel). HMAC-SHA256 over the raw body, three envelopes auto-detected (Stripe, GitHub, bare-hex Linear). Verify-before-parse trust boundary, two-layer idempotency (in-memory + durable runs.idempotency_key), never silently degrade. writeup →

Cron in yaml - per-user-tier templates that fork at signup, or operator-owned standalone schedules; sweeper fires real RunInputs; on_complete hooks deliver via channel / memory / MCP. Compound stress test pushed it to 100,000 fires, surfaced a double-fire race at 30,000, closed with a sync.Map in-flight tracker. writeup →

One agentic run, multiple per-user-authorized MCP servers, zero secrets visible to the agent. user_credentials map on the wire across all transports; ${run.credentials.<name>} substitution at the HTTP boundary inside Client.do(); values never reach transcripts, snapshots, or OTEL spans. writeup →

Three primitives that make ensemble-shaped pipelines first-class. Channel.await {channels, mode: any/all/at_least, n, wait_ms} is the missing fan-in combinator. Its symmetric twin Channel.broadcast publishes one payload to N channels in one call. Context op=time gives every agent a wall-clock. Schedule max_fires retires a def after N successful fires. Validated by exp5 (5 RSS collectors → consolidator → Telegram digest). writeup →

Operator JavaScript via goja as a first-class agent - no host filesystem needed, no LLM call. Same loop, OTEL, scheduler / webhook / A2A reachability, sub-agent composition. Stateless replay execution: each Provider.Call builds a fresh runtime, fast-forwards through the transcript, stops at the first un-recorded tool call. Resumable across restart and replica for free. Bundled examples ship at internal/examples/code-agents/. writeup →

MemoryBackendDef binds AgentDefs to backends; the in-process sqlite-vec + Postgres backend is canonical, external backends plug in. MemoryLayer sits alongside the flat Backend for LLM-extract products (mem0, Mem9). Capability probe routes ops; unsupported call fails closed with typed ErrCapabilityUnsupported. Native ranker + search-time dedup. writeup →

A run-loop plugin chain that runs every iteration between the agent and the outbound LLM. First built-in is redact - scrubs secrets before the model sees them. The model never receives the literal token in the first place. Plugins live in the loop, not the agent - operator opts in, agents don't have to know. Context compressor plugin is next. writeup →

Steer agents mid-run, Claude-Code-style from the browser. Mid-run steering via POST /v1/runs/{run_id}/input + a per-run buffered registry, drained at iteration boundaries (never between tool_use and tool_results). Parked end_turn instead of terminating. Inline interruption answers. View-switch survival via context.WithoutCancel + persistent event tailing. writeup →

Long-running agentic sessions stay in context budget. Three coordinated triggers around one shared summarizer. Manual: a Compact button. Auto: per-iteration threshold (autocompact_at_pct). Self: an agent can call Context op=compact itself. Pinned task + summary + last-N form, with CompactionSplit snapping the cut to a clean user-turn boundary so a tool_use/tool_results pair is never split. A context-compressor plugin is the next built-in in the contextplugin chain - same logic, operator-customizable surface. writeup →

spawn_runs(mode: "join", spawns: […]) dispatches N agent runs concurrently from one MCP call and returns an index-aligned envelope when they settle. The shape exp7 used to drive 10 reviewers across the loomcycle repo from one Claude Code call. exp7 writeup →

Lift .claude/agents/*.md + .claude/skills/*/SKILL.md into the loomcycle substrate without rewriting. AgentDef + SkillDef synthesized from YAML frontmatter + markdown bodies; tools mapped to allowed_tools; skills bundled into the system prompt at config-load. One command - and your existing Claude Code agents run on loomcycle. Pairs with the claude-code-plugin-loomcycle companion repo for the round-trip. writeup →

pip install loomcycle. Full client paired with @loomcycle/client on npm - same surface across HTTP / gRPC / MCP wire shapes. Python apps don't have to write a custom REST client to drive loomcycle.

Dev workflow can run against your Claude MAX subscription instead of pay-per-token API. Three subcommands: loomcycle anthropic login / status / logout. Reverse-engineered integration with explicit no-warranty terms - full disclaimer on GitHub →

@loomcycle/n8n-nodes-loomcycle on npm - source at github.com/denn-gubsky/n8n-nodes-loomcycle. Two editions. The Slim edition (this one, 20 nodes, zero deps, langchain-free) passes n8n's community-node scanner and runs on n8n Cloud. The Full edition (@loomcycle/n8n-nodes-loomcycle-full, 24 nodes) adds langchain-based AI-Agent Tool sub-nodes, SSE-push triggers, and a Run "wait for completion" op for self-hosted n8n. 16 dedicated action nodes covering Run / Memory / Channel / AgentDef / SkillDef / MCPServer / Schedule / Hook / Webhook / A2A Agent / A2A Server Card / Interruption / LLM / Memory Backend / Operator Token / Snapshot. 3 triggers (Run Completed / Channel Message / Interrupt Pending). 1 AI-Agent Chat Model sub-node routing through loomcycle's gateway. Drop loomcycle in front of an n8n workflow without writing custom HTTP nodes. writeup →