1. One-liner: five deities, one engine

When a request arrives, Metnos no longer calls the LLM planner five or six times in a row. It hands the turn to five modules named after five Greek deities: Mētis advises, Noûs executes, Praxis remembers, Pronoia rescues when something stumbles, Aporia honestly admits when we're stuck. Together they answer in twelve seconds where the legacy planner needed seventy-six — without ever asking the cloud for help.

2. The real problem: the step-by-step PLANNER

Until 24 May 2026 Metnos worked like this: at every turn, the planner (a local Gemma 4 26B) was called repeatedly — one step, the observation, the next step, the next observation, and so on. A five-step pipeline meant five or six model calls. Each call took ten to fifteen seconds. Net result: one turn averaged a minute and a quarter. And it didn't always finish.

A third, subtler problem compounded the first two: the search space. The planner saw two hundred tools every turn and had to rebuild the right sequence from scratch, even for sequences it had seen a thousand times (“find mail, classify spam, move to trash”). Rediscovering the obvious is wasteful — but the system had no memory.

3. The myth that drove the refactor

Zeus married Mētis, goddess of cunning counsel. But when she became pregnant, Zeus swallowed her whole — so as to keep her wisdom inside him forever, without ever again needing to ask outside advice. Since then Mētis lives in Zeus's belly: she whispers strategies from within, but she is no longer seen. — Hesiod, Theogony, vv. 886-900

The 25 May 2026 refactor took this image literally. The step-by-step PLANNER gets swallowed by a new module called Praxis (πράξις, “learned practice”). The language model doesn't disappear: it still lives inside Praxis as Mētis (Μῆτις, “cunning counsel”). But its role changes radically:

• before, it was queried at every step to pick the next tool;
• now, it is queried once per turn, and proposes the whole plan in one shot;
• if the pipeline works, Praxis stores it;
• next time Mētis stays silent: Praxis already has the answer.

This is Zeus swallowing Mētis: the wisdom lives inside Praxis, but it is only invoked when accumulated experience is insufficient. As the catalog matures, Mētis stays silent for days. The system becomes its own adviser — it learns not to ask any more.

But the myth doesn't end there. Two more deities enter the stage when things go wrong:

Pronoia, according to some sources Prometheus's mother, is divine providence. Her name literally means “intellect-before”: pro-noûs. She sees the obstacle while the others are already stumbling into it. She intervenes after the plan has failed, not before. — Aeschylus, Prometheus Bound

Aporia (ἀπορία) means “perplexity, dead-end”. In the Socratic dialogues it's the moment when the interlocutor realises they don't know — and that realisation, far from being a defeat, is the beginning of real inquiry. — Plato, Meno, 80a-d

Pronoia steps in when Mētis's plan fails: she figures out the kind of error, proposes an alternative, retries. Aporia steps in when even Pronoia can't save the turn: she honestly admits we can't proceed, tells the user what's needed to break out of the impasse, and keeps a record of the gap for the future.

4. The pentad, deity by deity

5. The cascade across a turn

Here is the full path, from the user's hello to the final answer. Read top to bottom: each layer is tried only if the one above didn't already resolve.

        USER: "find spam mail and move it to trash"
             |
             v
   +-------------------+
   | fast_path L0      |  regex on banal patterns ("what time", "where am i")
   | (zero LLM)        |  --> match? answer in 50ms and end
   +-------------------+
             | (no match)
             v
   +-------------------+
   | intent_extractor  |  LLM fast tier ~370ms
   | verb + object +   |  --> (verb="move", object="messages",
   | keywords          |        keywords=["spam","trash"])
   +-------------------+
             |
             v
+--------------------------------------------------------------+
|   PRAXIS ENGINE (the three internal deities)                 |
|                                                              |
|  +----------------+                                          |
|  | Praxis         |  sha[:16] hash of intent_sig             |
|  | try_match      |  --> cache hit O(1)? jump to Nous        |
|  | (sqlite)       |                                          |
|  +----------------+                                          |
|         | (miss)                                             |
|         v                                                    |
|  +----------------+                                          |
|  | Metis          |  LLM wise 1-shot, ~15s                   |
|  | propose        |  --> framework JSON {steps, fillers,     |
|  | (Gemma 26B)    |       final_message}                     |
|  +----------------+                                          |
|         |                                                    |
|         v                                                    |
|  +----------------+                                          |
|  | Nous           |  for each step:                          |
|  | execute        |    - resolve from_step + FILLER          |
|  | (deterministic)|    - invoke_executor                     |
|  +----------------+    - vaglio.judge                        |
|         |              - accumulate                          |
|         v                                                    |
|  +----------------+                                          |
|  | render final   |  template "Found {N} mails, moved"      |
|  +----------------+                                          |
+--------------------------------------------------------------+
             |
             v  (ok? yes --> Praxis records + replies to user)
             |
             |  (error? yes --> Pronoia enters)
             v
   +-------------------+
   | Pronoia           |  classifies: wrong_tool / wrong_args /
   | classify + retry  |    missing_input
   |                   |  --> re-proposes framework excluding failed_tool
   |                   |  --> re-runs via Nous
   +-------------------+
             |
             v  (ok? yes --> reply)
             |
             |  (still error? --> Aporia enters)
             v
   +-------------------+
   | Aporia            |  classifies root_cause: user_action_required /
   | honest dead-end   |    missing_executor / missing_skill / missing_data
   |                   |  --> log in aporiae.sqlite
   |                   |  --> "Can't resolve: X. To proceed: Y."
   +-------------------+
             |
             v
        USER: final message (reply or action request)

6. Praxis, the memory that grows

The engine's heart is the sqlite database. Three tables, all indexed for O(1) access:

The interesting phenomenon is that the system gets faster over time, by itself. The first time you say “find spam mail and move it to trash”, Mētis spends her good fifteen seconds generating the framework. The second time, Praxis already has the same exact intent fingerprint in cache: the pipeline starts in three milliseconds. From that point on, that specific request never touches the language model again.

Feedback is the grammar of memory

Below every chat reply, the user sees three small buttons: ✓ green (“correct answer”), ✗ red (“wrong answer”), ↺ orange (“retry”). Those three glyphs are the language by which Praxis learns:

• ✓: the pipeline moves one step closer to promotion. After two or three confirmations on the same intent fingerprint, it becomes an active skill and always starts first thereafter.
• ✗: the pipeline moves one step closer to anti-skill. Three consecutive failures and that specific path is excluded for thirty days: next time Mētis must find a different route.
• ↺: transient exclusion, only for the next turn. Useful when the answer was syntactically right but the user simply wants to try again.

Nothing has to be pressed: if the user gives no feedback and a pipeline finishes error-free two turns in a row, Praxis promotes it anyway (auto-promote). Explicit feedback accelerates and refines, but the system also learns from silence.

7. Mētis, the cunning adviser

Mētis is the only deity in the pentad that actually talks to the language model. Her job: given a query and an extracted intent, produce in one call the entire plan to execute. No step-by-step reasoning, no iterative tool-calls: just one big JSON object describing the whole pipeline.

{
  "steps": [
    {"tool": "find_messages",
     "args": {"folder": "INBOX", "query": "is:unread"}},
    {"tool": "classify_entries",
     "args": {"from_step": 1, "category": "spam"}},
    {"tool": "filter_entries",
     "args": {"from_step": 2, "where": {"category": "spam"}}},
    {"tool": "move_messages",
     "args": {"from_step": 3, "dst_folder": "${FILLER:trash_folder}"}}
  ],
  "fillers": {
    "trash_folder": {
      "prompt": "What's the trash folder name for this account?",
      "default": "Trash",
      "tier": "fast"
    }
  },
  "final_message": "Moved ${step4.ok_count} mails to trash."
}

The model call is constrained by a deterministic GBNF grammar: the model cannot produce malformed output because the decoder rejects in real time any token that violates the schema. Average time: 15 seconds on the local Gemma 26B, with reasoning enabled (2048-token budget). Cost: zero. Six times faster than the legacy step-by-step mode.

Anti-fixation: Mētis doesn't repeat the same mistake

If Pronoia calls Mētis for a re-propose after a failure, she passes the list of tools that failed in the previous turn. The prompt includes an explicit instruction: “DO NOT propose these tools, they already failed”. So Mētis doesn't loop in circles, and every failure becomes an opportunity to explore a different route.

8. Noûs, the doubt-free executor

Noûs is the most rigorous module: zero language model in the main loop. Only deterministic Python. His job:

1. For each step, resolve from_step: N references (extract entries from step N).
2. Resolve ${FILLER:name} by calling a small fast-tier LLM (one per filler, half a second each) or by using the default if Praxis already cached the answer.
3. Resolve ${stepN.field} in the final-message template by extracting the field from the step's result.
4. Validate args (requires_one_of, forbid_placeholder_values) before invoking the executor.
5. Invoke the executor and collect the result.
6. Pass the result to Vaglio (the safety judge).
7. Accumulate into step history.

This loop is deterministic by construction. No “plot loss”, no plan reconsideration. If a step fails, Noûs doesn't improvise: he stops and gives the floor to Pronoia.

9. Pronoia, the providence that sees first

Pronoia is the safety net. She activates only if Noûs hit an error while executing Mētis's plan. Her first job: figure out what kind of error it is.

Classification is deterministic: textual markers, no language model. Only the framework re-proposal uses Mētis again (because that's an intrinsically creative act).

Budget: Pronoia intervenes at most once per turn. If even the alternative plan fails, she hands off to Aporia. No infinite loops, no “one and a half” further attempts.

10. Aporia, the dead-end that becomes a proposal

Aporia is the subtlest piece of the system. She is not an “error handler”: she is an honest epistemic recognition. By the time her turn comes, the whole cascade has tried and failed. Aporia doesn't try to hide it: she classifies the gap, names it clearly to the user, and suggests what would be needed to get out.

Everything deterministic, zero LLM inside Aporia. The gap is logged in aporiae.sqlite: the next day, the occurrence count is visible on the admin dashboard /admin/aporiae, and we can decide whether it's time to close it structurally (synthesise the missing executor, enable the skill, build the index).

11. Bench: honest numbers

Test set: 35 real queries, collected from production turn logs + smoke battery + E2E sample. They cover mail, files, web, location, time, multi-turn dialogues, scheduling, contact management.

Six times faster. Equivalent coverage. Zero cost (model runs on Strix Halo 96GB unified). Agent codebase reduced by 55% (about 8000 LOC of full PLANNER removed).

12. What changes for the user

The visible difference, from the user side, comes in three points:

1. First requests are faster

Even on first hit, Praxis doesn't call the step-by-step planner: it makes a single 1-shot call to Mētis. Result: 12 seconds instead of 76. The feel is of a system that “takes a moment” instead of one that “hangs for a minute”.

2. Repeated requests are instant

After two or three turns of the same request family, the skill is active and subsequent turns start as cache hits. The answer arrives before you finish reading the message you just sent: under a second, often under 500 ms. That's the difference between “assistant” and “immediate reaction”.

3. Failures become informative

When something can't be done, Aporia says exactly what's needed. No vague “generic error” messages, no loops of pointless attempts: one clear sentence, one operative suggestion, and (if appropriate) a dialog to resolve the gap on the spot.

13. Why it beats OpenClaw and LangGraph

OpenClaw, Lobster, LangGraph and friends are frameworks for writing “LLM agent workflows” in YAML or Python. They partially address the same problem: reduce LLM-in-loop variance by giving structure to tasks. But they have limits that Praxis doesn't:

The analogy that clarifies everything

Traditional LLM-in-loop frameworks (OpenClaw, LangGraph) are like artists with a blank canvas: they reinvent the composition every turn. Beautiful creativity, but hallucinating a brush instead of a pencil is a real risk, and each artwork is expensive.

Praxis is like a craftsman with a sketchbook: Mētis sketches the plan once (concentrated, constrained creativity), and from then on the craftsman opens the book to the right page. Model creativity is still there, but it's confined to the moment of invention: execution is faithful reproduction of the sketch. That avoids execution-time hallucinations, gains speed, gains zero cost when the sketchbook is already rich.

14. Open questions

• Skill versioning. When the executor pool changes (a new synthesised executor, an old one removed), how are dependent skills invalidated? Current solution: framework_hash includes references to executors; catalog change → new framework_hash → natural cache miss.
• Cross-user skill sharing. If two users on the same host share an intent (e.g. “give me tomorrow's agenda”), should the skill be per-user or global? Current decision: per-user, for privacy. To be revisited if bottlenecks emerge.
• Slowly decaying skills. The 30-day TTL is empirical. Highly seasonal skills (e.g. “book dentist appointment” used once a year) could decay while still useful. Possible solution: TTL graded by observed frequency.
• Frontier fallback. When Mētis fails and Pronoia can't save, there's the “ask the frontier” option (Anthropic Opus 4.7) via consult_frontier. When to auto-activate vs leave to user escalation? Strato 3 escalation UI (ADR 0159 ext) already covers the case with a 4-choice dialog.

15. References

• ADR 0161 — Praxis Engine: canonical ADR with full sqlite schema, 8-stage lifecycle, deprecations and detailed bench.
• ADR 0150 — multi_tool_paths (partial predecessor, subsumed).
• ADR 0151 — planner_split (partial predecessor, deprecated).
• ADR 0156 — Naming Authority (vocab compliance for skill ids).
• ADR 0157 — Telos engine (proposal alignment).
• ADR 0158 — Change_intent lifecycle (UI/audit for promoted skills).
• ADR 0159 — Safety net 7-layer (gating on imported skills).
• Hesiod, Theogony, vv. 886-900 — Zeus swallows Mētis.
• Aeschylus, Prometheus Bound — Pronoia as mother.
• Plato, Meno, 80a-d — aporia as a Socratic moment.
• Aristotle, Nicomachean Ethics, book VI — praxis as action informed by experience.
• Detienne & Vernant, Cunning Intelligence in Greek Culture and Society, University of Chicago Press 1991 (orig. Les ruses de l'intelligence: la mētis des Grecs, Flammarion 1974) — for those who want to dig into the Greek notion of mētis.