For platform engineers shipping AI agents to production.

Deterministic replay for non-deterministic agents.

Your agent works in the notebook. Then it loops, hallucinates a tool call, refunds the wrong customer, and you can't replay why. Olymp records every signal, decision, and action — keyed by run id, replayable months later, defensible to legal.

See a real run → ★ on GitHub Run it locally ↓

Wrap any agent.Drop-in audit beneath your LangGraph, CrewAI, or MCP agent. Four lines of HTTP per node.

Replay a 2am decision.The same chain that fired in production reproduces the decision weeks later, against the same inputs.

Defensible by design.Every action ties back to its decision, its evidence, its model, its weights. Open source, your data, your model.

mnemos memory chronos time nous decisions praxis execution olymp runtime
Live preview. The dashboard ships in the binary at /dashboard — click any packet for the JSON each layer received and returned.

Proof, not vibes

Wrap your existing agent. Replay any decision it ever made.

A four-node LangGraph refund-triage agent — running here, against a real Mnemos. Each node emits one event keyed to the run id. The full reasoning chain is one HTTP call away, weeks after the fact.

1

fetch_history
customer 12 prior refunds, $89 LTV, 18-day tenure

2

score_risk
risk = 1.00 (prior_refunds >=5, tenure <30, amount > LTV)

3

decide
escalate — confidence 0.90, "high risk score, human review required"

4

execute
zendesk.create_ticket → succeeded

See the raw run JSON → Source · 270 lines of Python

run id 00855d21-83a4-4cc1-8db4-0653161a058d — one of three personas in the demo. Re-run it locally with python agent.py --customer-id CUST-42 --amount 245.00.

Reference scenario

Two services start misbehaving. Watch Olymp react.

The reference demo boots two deliberately-broken sample services alongside the cognitive stack and pipes their Prometheus metrics into Chronos. As the failure pattern builds in Grafana, Olymp's loop pulls the same observations through every layer and writes the outcome back into memory.

The loop closes — for real. Payments error rate climbs from 2% to 35% over 80s. The signals layer flags the spike and the checkout latency drift. The decision layer (driven by a local Llama via Ollama) plans the remediation. The execution layer fires two http_request actions — heals flaky-payments AND slow-checkout. Error rate drops below 5% in ~70s. Visible live in Grafana, recorded by Mnemos, replayable from the audit chain.

flaky-payments

Error rate climbs from 2% baseline to 40% over three minutes. Visible in Grafana, ingested into Chronos via the prom2chronos bridge.

slow-checkout

Request latency drifts upward 60ms per minute, capped at 2.5s p99. The kind of regression a binary alarm misses.

Olymp loop

Each remediate intent runs the full loop and fires multiple Praxis actions in one decision — heal flaky-payments AND slow-checkout, then write the outcome back to memory.

One run, end to end

From a fresh stack — runs complete in seconds. Press play to scrub through the recorded session.

Static fallback below if the asciinema player can't load.

→ pull pinned cognitive-stack images and bring up demo services
→ wait for olymp /healthz                      ok
→ wait for prometheus to scrape both services  both targets up
→ pull the local LLM model (llama3.2)          ok (~2 GB on first run)
→ seed mnemos with operational claims          seeded 3 claims into mnemos

  Open http://localhost:3000 to watch the broken services degrade.

→ submit explain payments-latency
{
  "id":     "5bbd4777-…",
  "status": "completed",
  "intent": "explain"
}

→ baseline payments error rate before remediate
  32.00%

→ submit remediate payments-latency — provenance chain
{
  "intent":  "remediate",
  "subject": "payments-latency",
  "status":  "completed",
  "timeline": [
    { "stage": "observing",     "layer": "mnemos",  "outputs": { "count": 3 } },
    { "stage": "understanding", "layer": "chronos",
      "outputs": { "count": 2, "patterns": ["spike", "trend"] } },
    { "stage": "deciding",      "layer": "nous",    "ref": "05966dd5-…",
      "outputs": { "model": "llama3.2", "actions_planned": 2 } },
    { "stage": "acting",        "layer": "praxis", "ref": "b2d98814-…",
      "outputs": { "actions": [
        { "capability": "http_request", "url": "…/flaky-payments/admin/heal", "status": "succeeded" },
        { "capability": "http_request", "url": "…/slow-checkout/admin/heal",  "status": "succeeded" }
      ] } },
    { "stage": "learning",      "layer": "mnemos"  }
  ]
}

→ wait for prometheus to record the recovery
  t+10s payments error rate = 30.55%
  t+30s payments error rate = 24.73%
  t+50s payments error rate = 16.73%
  t+70s payments error rate =  3.20%   ← recovered
  t+90s payments error rate =  1.91%   ← stays healed (no climb-back)

What happens at each stage

observing
Olymp asks the memory layer for active claims about the subject. Returns SLO claims, hypotheses, and ownership relationships.
understanding
Olymp asks the time-series layer for signals. Chronos detectors have been running on the bridged observations every 5s; the demo's tuned thresholds surface a spike on payments error rate and a trend on checkout latency.
deciding
Olymp submits memories + signals to the decision layer. Nous (driven by a local Llama via Ollama) produces a remediation plan; the playbook resolves it to two concrete actions. The decision is recorded with inputs + weights + outcome.
acting
Olymp dispatches both ActionRequests to the execution layer. Praxis runs them sequentially through the same executor — schema-validated, policy-checked, idempotent, audit-logged. In production the same path fires rollback / restart / page handlers.
learning
Olymp writes the outcome back to memory as a structured event. The next iteration's observing stage sees it. The loop is closed.

How it differs

Trace tools log what happened. Olymp lets you replay why.

LangSmith and Langfuse log spans. LangGraph routes messages. Temporal makes steps durable. Olymp's seam: the chain of evidence behind a decision — claim → signal → decision → action → outcome — keyed to a run id and replayable months later, with the same data that fired in production.

Tool Solves Olymp's seam
Langfuse / LangSmith Trace + span logs for LLM calls. Olymp records the chain of evidence, not just the spans — replayable, not just searchable.
LangGraph Graph executor for LLM calls. Olymp sits beneath LangGraph as the audit substrate. Drop in a callback; every node becomes replayable.
Temporal / Restate Durable workflows for any business logic. Olymp ships replay-from-evidence semantics out of the box — Temporal replays steps, Olymp replays reasoning.
Computer Use / Swarm Model-driven action and handoffs. Olymp records every step and gates risky ones — the model decides, Olymp commits.

Architecture

Two ways in. One audit trail.

Use Mnemos directly as a drop-in audit substrate beneath your existing LangGraph / CrewAI / MCP agent — that's what the refund-triage demo above does. Or run the full Olymp orchestrator end-to-end across the four services below, like the broken-services scenario does. Same storage, same replay, different entry point.

Run it

One script. Five minutes from clone to first run.

Requires Docker (with Compose v2), jq, and curl.

git clone https://github.com/felixgeelhaar/olymp.git
cd olymp
./deploy/demo-full.sh

What the script does, in order:

  1. Builds a local olymp:demo image carrying the seed-demo subcommand.
  2. Boots the cognitive stack, the two broken sample services, Prometheus 2.55, Grafana 11.3, and the prom2chronos bridge.
  3. Waits for /healthz, then seeds memory with three baseline claims.
  4. Submits one explain and one remediate run, prints the provenance chain.

While it's running, open:

localhost:8080/dashboard

Live cognitive-loop view. Radial topology of the four layers around Olymp; glowing packets per call; click any packet for the JSON each layer received and returned.

localhost:3000

Grafana — anonymous viewer enabled. The Olymp Demo — Broken Services dashboard refreshes every 5s.

localhost:9090

Prometheus UI. Try payments_requests_total or histogram_quantile(0.99, …).

localhost:8080/v1/runs/stream

Raw SSE feed of every run state change — curl -N from a terminal if you'd rather skip the UI.

Tear down

docker compose -f deploy/docker-compose.yml --env-file deploy/.env --profile demo down -v

The four services

Each service ships standalone. Olymp wires all four into one loop.

Use any one of them on its own — the refund-triage demo above only touches Mnemos. Or wire all four through Olymp for the full closed loop. Same images either way.

Mnemos · memory

Local-first evidence layer. Append-only events keyed by run id; structured claims with citations; replay any run from one HTTP call.

Chronos · signals

Pattern detection over time-series data. Spike, trend, and drift detectors run continuously over bridged Prometheus observations.

Nous · decisions

Risk evaluation and intervention generation. Decisions persisted with weights, evidence refs, and model name. Bring your own LLM.

Praxis · execution

Three verbs (ListCapabilities, Execute, DryRun). Idempotency, policy gating, replay-from-audit.