Skip to main content
loomcycle
apache-2.0 · agentic runtime · in Go
Loomcycle

The kernel of an agentic OS.

UNIX-style operator/caller trust separation. Default-deny everything. The substrate where agents live, talk, and learn — one Go binary, shaped to grow from a single-replica VPS to multi-replica HA.

Apache-2.0 · v0.8.14 · Active development through v1.0

§ 03 — primitives

The five primitives that make agentic systems learnable.

Memory and Channel are the substrate. AgentDef and Evaluation are the self-evolution loop. Context is the introspection primitive that closes it.

Memory

shipped v0.8.0

Persistent state per agent or per user. Atomic incr. TTL. Cross-run continuity that survives process restarts.

// set a memory key
{"tool":"memory",
 "input":{"op":"set",
         "scope":"user",
         "key":"last_seen",
         "value":"…"}}

Channel

shipped v0.8.4

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":{...}}}

AgentDef

shipped v0.8.5

Agents fork themselves into versioned definitions with lineage tracking. The substrate for self-evolution.

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

Evaluation

shipped v0.8.5

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"}}

Context

shipped v0.8.7

The introspection primitive. Ten ops covering self · tools · agents · history · help. 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
§ 04 — trust model

Same binary. Two postures. The operator picks via env.

The UNIX shape you already know — operator, caller, agent. Operator config is the floor; callers can narrow per-request but never widen. The bearer token is the authority.

posture A

True managed sandbox

  • Default-deny every tool
  • No FS roots
  • No Bash
  • Caller-authoritative allowed_hosts
  • No outbound by default

Shared-server deployments processing untrusted input. Multi-tenant SaaS. Anywhere the caller isn't the operator.

posture B

Agentic dev environment

  • Bash on, scoped FS roots
  • Broad allowed_hosts
  • Local Ollama for offline work
  • Operator-trusted tooling
  • Iteration speed prioritized

Local development. Internal trusted operators. The single-machine workflow where you are the caller.

§ 05 — providers

Six providers. One interface. No vendor binary in the loop.

Resolver picks (provider, model) per tier and effort. Cross-provider fallback with reasoning_content strip. Cache_control where supported. Native HTTP-only.

Anthropic
OpenAI
DeepSeek
Gemini
Ollama (cloud)
Ollama (local)

// Provider interface

caps:cache_control · reasoning · tools
resolve:(tier, effort) → (provider, model)
fallback:on 429 · strip reasoning_content
pin:v0.8.13 · pin-after-success

Pin-after-success ends the transcript-translation bug class. Cache_control where supported. No bundled SDK.

§ 06 — production-validated

Production-validated where it counts.

jobs-search-agent — the first production user of an agentic runtime substrate — migrated off vendor SDK backends to loomcycle in May 2026 after a single bug class generated unattributable production cost.

The bug: subprocess auth inheritance. The CLI-based SDK runner inherited the operator's Anthropic Pro auth across spawned children, so multi-tenant agent runs billed against the operator's subscription instead of the tenant's API key. The SDK can't help — the leakage is at the OS process-inheritance layer.

Loomcycle's HTTP-only loop has no subprocess. Credentials are supplied per-request, never inherited. The entire bug class is structurally eliminated, not patched.

Read the full migration story →
§ 07 — quickstart

Three commands. One curl. One Web UI link.

Self-host on a single replica in under three minutes. Set an API key, copy the example config, run the binary.

~/loomcycle · zsh
// build & configure
$ make build-all $ cp .env.example .env.local # set ANTHROPIC_API_KEY / etc. $ cp loomcycle.example.yaml ~/.config/loomcycle/loomcycle.yaml $ ./bin/loomcycle --config ~/.config/loomcycle/loomcycle.yaml
// health check
$ curl http://127.0.0.1:8787/healthz {"ok":true}
// first real call
$ curl -N http://127.0.0.1:8787/v1/runs \ -H "Authorization: Bearer $LOOMCYCLE_AUTH_TOKEN" ...
// open the Web UI
$ open "http://127.0.0.1:8787/ui?token=$LOOMCYCLE_AUTH_TOKEN"
§ 08 — roadmap

Honest. Dated. Trigger-based.

No "Q3 2026" calendar guessing — versions and triggers. Each line has a concrete what and a concrete why.

v0.8.14● shipped

Current — bearer auth, web UI

Per-request user_bearer auth. Operator-yaml-templated MCP header substitution. The credential boundary now terminates at the HTTP frontier.

v0.8.15▶ in flight

LoomCycle MCP — the v0.8.x capstone

Loomcycle exposes itself as an MCP server. Claude Code and external orchestrators drive it through standard MCP. The substrate becomes addressable from outside.

v0.8.16next

Question tool — human-in-the-loop

Built-in primitive for "ask the operator." Rides system channels. Agents pause cleanly on uncertainty instead of confabulating an answer.

v0.8.17next

Pause / Resume / Snapshot

Runtime-wide quiesce + cross-version-portable JSON snapshot. Precondition for v0.9.x multi-replica HA.

v0.9.xnext

High-load capacity sweep

Per-tenant fairness. OTEL traces. Multi-replica HA via Redis cancel pubsub.

v1.0launch

Distribution & stable contributor surface

Homebrew · Docker · Helm · operator cookbook · settings UI. External code contributions open here.

§ 09 — talk to us

Building on loomcycle, or thinking about it?

We'd like to hear what you're building. Production users inform v1.0 design, and integration-shape ideas are the things that get RFCs written. No sales process, no NDA, no waitlist — just a real conversation about whether loomcycle fits your shape.

[email protected]