Glaux

A multi-agent swarm
that proves its work

Glaux turns a goal into a team of agents that plan, execute in parallel, and verify each other — then signs every step onto a tamper-evident ledger. It writes its own tools when none exist, and improves itself without being able to get worse.

Proves every stepWrites its own toolsCan’t get worseWASM-sandboxedRuns offline
Glaux running a task, streaming the swarm, and verifying the signed ledger

Quickstart

Running in three commands

No API key required — Glaux runs fully local on Ollama, or against 30+ hosted providers.

# clone, build the native ledger kernel + dashboard
git clone https://github.com/aniketshukla1/glaux && cd glaux
./install.sh

# start the swarm → http://127.0.0.1:8000
./venv/bin/glaux up

# or drive it straight from the terminal
glaux run "research the top vector databases and write a comparison"
glaux verify   # ✓ chain verified · every step signed

Why Glaux

What makes it different

Most frameworks give you orchestration and observability. Glaux adds two things they structurally don't have — provable provenance and genuine self-extension — and makes both safe by construction.

It proves its work

Every action is Ed25519-signed by the agent that took it and appended to a hash-chained ledger. Tamper with a block and the chain breaks. Tracing tells you what a system claims it did; a signed chain lets you prove it.

It builds its own tools

When nothing fits, an agent writes a skill. Glaux static-capability-checks it, runs its generated tests in the sandbox, and injects it into the live run. Proven skills get promoted; failing ones get repaired and retried.

It can't get worse

The harness tunes its own routing, budgets, prompts, playbooks and tool library from outcomes. Every self-modification is evidence-gated, signed to the ledger, and reversible.

It doesn't overpay

A sub-millisecond embedding router sends trivial asks to a one-shot responder and only escalates real work to the full swarm — and it learns from mis-routed runs. An opt-in semantic cache answers repeats with zero model calls.

Capability-zero sandbox

Model-written code runs in a WebAssembly guest with no ambient authority — it cannot syscall by default. File access is a separate, opt-in jailed workspace with size caps.

Yours, and local

Runs entirely offline on Ollama with a native Rust core. No vendor lock-in, no telemetry, Apache-2.0 licensed. Drive it from a dashboard, a full-parity CLI, or the HTTP API.

GlauxTypical agent framework
Audit trailSigned, hash-chained ledgerTracing / logs
New toolsSynthesized + sandbox-tested at runtimePre-registered by you
Self-improvementGated, signed, reversibleManual tuning
Cost controlLearned tiering + semantic cacheUsually one model per call
IsolationWASM, zero ambient authorityOften “enforce at the tool level”

The console

Built around the proof

Every answer shows who worked on it and how many steps were signed. One click takes you to the chain itself, with the command to check it offline, without trusting this app.

The Proof page: chain verified, every block with its signer and hash, and the command to check it offline
Proof. The whole chain: every block, who signed it, and how to verify it yourself.
A finished run: the answer, a structured canvas, the agents involved and the number of signed blocks
Runs. The answer, the agents behind it, and the signed steps it took.
The Library: synthesized skills, each marked quarantined until proven, with tabs for tools, memory and playbooks
Library. Everything the swarm can draw on. New skills start quarantined.

Screenshots from the built-in demo mode: no model connected, answers simulated, signatures real.

The self-evolving harness

It improves itself — and can prove it

The harness learns from task outcomes: better routing, per-specialist budgets, prompt lessons, distilled playbooks, and promoting proven tools. In the demo run shown here, it lifted its own routing accuracy from 31% to 51% over 61 episodes.

  • Gated — applied only when the evidence supports it
  • Signed — written to the ledger as EVOLVE_HARNESS
  • Reversible — one command undoes it
How it works
The self-improvement tab: routing accuracy, learned budgets, and a signed evolution log