loomcycle.cloud is the fastest path to a live agentic runtime: sign in with Google, mint a named tenant token, point @loomcycle/client at app.loomcycle.cloud. No VPS, no compose file, no brew install. The same Go binary you would self-host — Apache-2.0, unchanged.
Free while in preview · Bring your own provider key · v1.23.1
0M
Circuits, 8-hour soak
0M
Agent runs completed
0
Waves at 100% completion
0
Goroutine or memory leaks
The hardened cycle the whole runtime exists to run. Seven inference modes behind tier-based routing with a fallback cascade, per-agent sampling, and context compaction at a clean turn boundary. Pause, resume, snapshot — including cross-instance resume of a parked mid-run. A run survives the client disconnecting and is re-attachable by run_id, replaying from any sequence number.
Key/value; vector search over sqlite-vec or pgvector on a pluggable MemoryBackend; and per-scope SQL — real tables, joins and aggregates in a database the runtime owns, isolated from the main store. Default-deny capability gate, statement timeouts, byte quotas, nested transactions, and a full audit trail on every statement.
Claude Code parity on the file tools, plus a true in-process shell sandbox — Bashbox runs commands with no OS process and no network, and honours read-only volumes through a RAM write overlay. Filesystem access exists only through a bound Volume: sandbox by default. MCP servers ingest as tools on one side; loomcycle serves as an MCP server on the other.
Nine content-addressed, tenant-scoped, versioned definition families, authored at runtime from any transport — no redeploy, no config reload. Fork, promote and retire each one; content_sha256 is the authority, not a name. Your tenant token authors all of it without ever holding cross-tenant admin.
A team is an author-defined state machine: states, transitions, and a per-state handler that is one agent, a parallel fan-out with a consolidator, or a terminal. Loops are bounded by a per-state iteration cap. It renders as a Mermaid state diagram, walks end to end through the sub-agent machinery, and reports progress on a Document task board a human can steer.
Five primitives, one loop. The runtime is not a wrapper around a model — it is the thing that keeps thousands of agents running 24/7.
One Go binary, ~50 MB. It runs alongside your application, not inside it — your app calls it over HTTP, gRPC, MCP, or the TypeScript and Python adapters, and stays in whatever language you wrote it in.
The hardened model → tool_use → tool_result loop, multi-provider routing, memory and channel primitives, MCP server identity, OpenTelemetry traces and multi-replica coordination all live in the binary.
The market gives you three shapes: a library embedded in your process, a managed service welded to one vendor's IAM, or a gateway that proxies model calls without running agents. loomcycle is the fourth — a self-hostable runtime that owns the loop and speaks every wire format your stack already uses. Cloud is that binary, hosted, so you can start in a minute instead of an afternoon.
01
Anthropic, OpenAI, DeepSeek, Gemini, Ollama (cloud + local), the synthetic code-js provider and a mock. Tier-based routing with a fallback cascade, model aliases, and a live routing view showing what actually serves you now. More providers land as they clear testing — the catalog is config-declared, so adding one is an option you set, not a release you wait for.
02
Claude Code parity — Read, Write, Edit, Grep, Glob, NotebookEdit — plus HTTP, WebFetch, WebSearch, Bash, Bashbox, Agent, Skill, Memory, Channel, Path, Document and Context. Filesystem access only through a bound Volume; sandbox by default.
03
Agent, Skill, MCPServer, Schedule, Webhook, MemoryBackend, Volume, A2A and Team defs — content-addressed and versioned, authored at runtime from any transport. Your tenant token authors all of it without ever holding cross-tenant admin.
04
Key/value, vector (sqlite-vec / pgvector) on a pluggable MemoryBackend, and per-scope SQL — real tables, joins and aggregates behind a default-deny capability gate, statement timeouts, byte quotas and a full audit trail.
05
Ingest MCP servers as tools, and serve loomcycle itself as an MCP server on a per-principal transport — your substrate:tenant token drives a fully tenant-confined session, so an MCP agent's documents land where your Web UI reads them.
06
A per-call token ledger tagged with which key paid, a grouped usage report, and soft/hard monthly token limits per tenant and per user. A hard limit refuses new runs at admission; an in-flight run warns and finishes.
Step 01
OAuth on loomcycle.cloud, served from Cloudflare. Your Google subject becomes the authoritative principal — no password, no separate account. First sign-in provisions your tenant.
Step 02
Mint a bearer bound to (tenant, subject, scopes) through the OperatorTokenDef substrate, with the admin token held server-side — or add a token a colleague minted for their tenant and sent you, which puts you in the same documents, memory and Path tree. Either way it is shown once and wrapped into a vault in your browser: AES-256-GCM under a non-extractable key in IndexedDB. No .env file to leave lying around.
Step 03
Pick a token by name and sign in — it opens app.loomcycle.cloud/ui already authenticated: the runtime consumes the bearer, sets an HttpOnly session cookie, and drops it from the address bar. The runtime itself sits behind a reverse proxy on its own VPS.
01
Provider keys live in a CredentialDef store: AES-256-GCM with a per-tenant HKDF-derived key, row-bound AAD, fail-closed, metadata-only reads. Bring your own Anthropic or OpenAI key and it is your key that pays and your bill that arrives.
02
Every store read goes through a central tenant-scoping accessor. Writes stamp the authoritative tenant resolved from your bearer, never from the wire. Tokens minted for you carry substrate:tenant — full power inside your tenant, none outside it.
03
The redact context-transform plugin scrubs resolved secrets on the outbound path, and host-command credentials are injected into the child process only — model-invisible. Dial-time SSRF guards apply to every HTTP, WebFetch and MCP call.
# in Claude Code
/plugin marketplace add denn-gubsky/claude-code-plugin-loomcycle
/plugin install loomcycle
# prints a `claude mcp add` line plus a JSON snippet to paste loomcycle mcp install # thin-client form — proxies to your cloud tenant, boots no second runtime loomcycle mcp --upstream https://app.loomcycle.cloud/v1/_mcp
01
Six slash commands — /loomcycle:run, :runs, :cancel, :snapshot, :eval, :connect. Four skills: spawn-evaluator, replay-failed-run, diff-agentdefs, import-claude-code. Two opt-in hooks: run telemetry and auto-snapshot-on-error, both off by default.
02
Install prompts you for the base URL and the bearer, and stores the token in your OS keychain — the same posture as the browser vault, one layer down. Point the base URL at https://app.loomcycle.cloud and paste a token from your vault; the MCP session then runs as your (tenant, subject), so documents and memory an agent writes from the IDE land where your Web UI reads them.
03
A substrate:tenant token drives a fully tenant-confined MCP session: the admin-only meta-tools — minting, runtime admin, snapshots — are withheld per-tool. Against a cloud tenant always use the thin-client form, --upstream, so the MCP server proxies your running instance instead of booting a second one; that is also what makes cancel_run and interruption_resolve work across the connection.
The plugin does not bundle or start a runtime — with loomcycle.cloud you do not need one locally. Source and issues: denn-gubsky/claude-code-plugin-loomcycle.
A thin-client chat UI for loomcycle — runs, streaming, history, documents, memory — Apache-2.0. Native desktop app, latest v0.1.2:
macOS · DMG · Windows · EXE · Linux · AppImage · all builds (.deb / .msi) →
# or run it locally — serves the app + reverse-proxies /v1 to your tenant npm install -g @loomboard/app # or embed the chat as a React component npm install @loomboard/chat
01
No loomboard backend — it talks straight to your tenant over loomcycle’s /v1 wire with @loomcycle/client. Anything it writes (runs, documents, memory) lands where your Web UI reads it.
02
No install: board.loomcycle.cloud runs the same app, hosted next to your runtime. Sign in from your token vault and it hands loomboard your bearer over an origin-checked postMessage — the same posture as the Web UI login, never in the URL.
03
Desktop, CLI, and browser all authenticate with a bearer from your vault against https://app.loomcycle.cloud. Desktop keeps it in the OS keychain; the hosted app in browser storage — loomcycle owns real persistence.
Downloads are GitHub releases of denn-gubsky/loomboard; the hosted browser app is the same source, served alongside your runtime.
// npm i @loomcycle/client import { LoomcycleClient } from "@loomcycle/client"; const lc = new LoomcycleClient({ baseUrl: "https://app.loomcycle.cloud", token: process.env.LOOMCYCLE_AUTH_TOKEN!, // the token you just minted }); for await (const ev of lc.runStreaming({ agent: "chat/medium", prompt: "Read ./CHANGELOG.md and summarise the last release.", })) console.log(ev.type, ev);
# the token is a bearer — never put it in a URL export LOOMCYCLE_AUTH_TOKEN=lc_... curl -N https://app.loomcycle.cloud/v1/runs \ -H "Authorization: Bearer $LOOMCYCLE_AUTH_TOKEN" \ -H "Content-Type: application/json" \ -d '{"agent":"chat/medium","prompt":"Summarise the last release."}' # or point Claude Code / any MCP client at the per-tenant transport loomcycle mcp --upstream https://app.loomcycle.cloud/v1/_mcp
No card. Open signup. A monthly token budget per tenant, enforced by the runtime's own limit primitive — you see the counter, we do not surprise you.
Bring your own Anthropic, OpenAI, DeepSeek or Gemini key. It is stored encrypted per tenant and used only for your requests. Inference cost never routes through us.
Not priced yet. When they land they will be about capacity and support, not about unlocking primitives: the runtime is Apache-2.0 and stays whole.
Google OAuth, one named token, and app.loomcycle.cloud is yours. Self-hosting stays a brew install away — nothing here is a lock-in.
Google OAuth only. Your Google subject becomes the authoritative principal — the same identity your tokens are bound to, so a revoked account revokes its tokens.
t_denys
Two ways in. Mint a token for your own tenant — an isolated store, your own substrate, your own encrypted provider keys. Or add a group token someone minted for their tenant and handed to you: it puts you in their documents, memory, Path tree and substrate, working on the same material.
| Name | Token | Tenant |
|---|
0 of 5 tokens in use
Add a tokenBound to your tenant and Google subject, scoped substrate:tenant runs:create, minted through the OperatorTokenDef substrate with the admin token held server-side. loomcycle stores a hash and the last four characters; the secret is returned once, wrapped straight into this vault, and shown to you on the next screen.
A token someone else minted for their tenant and sent you — signing in with it puts you in their tenant: shared documents, shared memory, shared Path tree, one budget. Whoever minted it can revoke it. It is wrapped locally and never sent to loomcycle.cloud.
lc_7Qv2xR8mKpL4dW9sT1nB6hJ3yF5aZcXu
loomcycle login \ --url https://app.loomcycle.cloud \ --token lc_7Qv2xR8mKpL4dW9sT1nB6hJ3yF5aZcXu
new LoomcycleClient({
baseUrl: "https://app.loomcycle.cloud",
token: "lc_7Qv2xR8mKpL4dW9sT1nB6hJ3yF5aZcXu",
})
loomcycle mcp --upstream https://app.loomcycle.cloud/v1/_mcp \ --token lc_7Qv2xR8mKpL4dW9sT1nB6hJ3yF5aZcXu
This is the last time the secret is displayed. It is already wrapped into your browser vault as mac-studio — copy it too if you want it in a password manager. In the vault it will read lc_•••••••••••••Xu.
Signing in opens app.loomcycle.cloud/ui and hands your bearer to it over an origin-checked postMessage; the runtime sets an HttpOnly session cookie — the token never touches the address bar, browser history, or an access log.
Reading /v1/config…