A functional split that survives time

Splits by business domain age with the organisation. Splits by pipeline age with the stack. A split by cognitive regime, however, is stable: whatever happens to models and frameworks, someone will always need to capture, remember, prove, reason, contradict, find the oblique angle, time, judge, take the long view, produce. The ten profiles are an architectural invariant — implementations will change underneath, the grammar stays.

Quality guarantees by construction

Each profile encodes a guard-rail that monolithic systems don't have:

• A pipeline without Elenchos never catches its own contradictions — it smooths them over.
• A pipeline without Epistêmê never distinguishes verified from plausible — it states everything in the same tone.
• A pipeline without Kairos produces on demand but never on point — it ignores the moment.
• A pipeline without versioned Mnêmê relearns every day what it already knew yesterday.

The separation isn't decorative: it makes every guarantee auditable. You can trace which contradiction Elenchos raised, which score Epistêmê assigned, why Kairos fired. That's the answer to oblique intelligence's trust problem: every detour leaves a trace, every trace has a responsible agent.

A shared human/agent product language

The ten names work as a project-management vocabulary. In an EigenVertex meeting cycle, saying "we need an Elenchos pass on this file before deciding" or "Kairos flagged a signal on this competitor" is immediately understood — by the human team as much as by the orchestrator. The cast becomes a steering interface, not window-dressing.

A defensible differentiator

The 2026 state of the art confirms it: generic multi-agent is commoditised. Supervisor, orchestrator-worker, swarm — these are templates everyone deploys. What isn't commoditised is a theory of the split. Few players treat investigative logic (Mètis), counter-hypotheses (Elenchos) and timing (Kairos) as first-class functions. That's an intellectual position competitors can't copy by renaming their nodes — because it commits to real mechanisms: an investigation log, an evidence layer, contextual triggers, versioned memory.

What the state of the art says

LangGraph is the 2026 production standard for multi-agent systems, with three dominant topologies: supervisor/hierarchical, orchestrator-worker (roughly 70% of production deployments), and swarm (peer-to-peer, no central control). The economics are known and blunt: independent multi-agent architectures cost roughly 58% more tokens, and centralised architectures up to 285% more — multi-agent only pays off when the task genuinely benefits from specialisation, parallelism, or critique.

Good news: the ten regimes tick precisely those three boxes. Specialisation is their very definition; Aisthêsis and Kairos naturally run in parallel to the main flow; Elenchos *is* institutionalised critique.

The natural mapping

Yes, the approach templates well onto LangGraph — and the mapping is even elegant.

Recommended topology: supervisor, with the supervisor as Phronêsis. The supervisor pattern is the most legible: a routing node, a clear control flow, every decision visible in the traces. And routing is exactly judging: deciding which regime of intelligence the situation calls for. Phronêsis therefore isn't one worker among others — it's the graph's natural supervisor. This isn't cosmetic: it gives the routing node a doctrine (arbitrating between regimes) instead of an ad hoc prompt.

The other nine as specialised workers, each with its own tools:

• Aisthêsis → ingestion connectors, OCR, feed parsers
• Mnêmê → wiki writes, versioning, indexing
• Epistêmê → source scoring, claim verification, cross-referencing
• Logos → synthesis, structuring, sourced generation
• Elenchos → adversarial search, contradiction detection
• Mètis → neighbourhood queries, analogy, graph exploration
• Kairos → feed monitoring, delta detection, novelty scoring
• Sophia → long-context synthesis, perspective-setting
• Technê → rendering engines (docx, pptx, MusicXML…), publishing pipelines

Model tiering applies directly. The 2026 production rule — a strong model for the supervisor that needs to route correctly, light models for the workers that execute — cuts costs 60–70% without degrading routing. In EigenVertex terms: Phronêsis and Sophia on a frontier model; Aisthêsis, Mnêmê, Technê on economy models; Elenchos and Mètis on a mid tier (critique and obliqueness demand real reasoning).

LangGraph's shared state carries the EigenVertex structures. A custom state (beyond a plain message list) naturally hosts: Epistêmê's evidence layer, Mètis's investigation log, the decision register, Kairos's scores. Subgraphs isolate contexts — the meeting cycle can be one subgraph, the document investigation another.

Watch for routing loops. The classic failure mode of the supervisor pattern is the supervisor→worker→supervisor loop that never converges; the fix lives in the supervisor's prompt, not in a recursion limit. For EigenVertex: Phronêsis needs explicit termination criteria ("the cycle's objective is met / the artefact is produced / the signal is handled"), or Elenchos and Mètis — the two agents that, by definition, reopen questions — will create infinite loops. That's a real design point, not a theoretical one.

Where we'd be stating the obvious — and where we wouldn't

Let's be blunt, since that's the question being asked.

Obvious: "we have a supervisor and specialised workers." Everyone has that. The create_supervisor() template exists, tutorials abound, no defensible value there.

Obvious: "each agent has its own prompt and tools." Absolute standard.

Not obvious: the typology itself. Common deployments split by domain (billing/tech/account) or by stage (research/code/write/review). Splitting by cognitive regime is a distinct design choice, with concrete consequences: Elenchos as a first-class worker (systematic critique), Kairos as a permanent daemon (timing as a function, not a cron job), Mètis with a mandatory investigation log (traceable obliqueness). No LangGraph template ships that.

Not obvious: the coupling with living memory. Standard multi-agent systems are amnesiac between runs, or settle for technical checkpointing. At EigenVertex, Mnêmê versions *knowledge* (not execution state), and Kairos compares the present state against history. This memory-timing loop is the heart of "living knowledge" — and it exists in no template.

Not obvious: documentary kairos. A system that *suggests* a brief should be produced now — because a threshold was crossed, a contradiction appeared, scattered notes form a pattern — is an inversion of the request-response model that no one ships by default. Publishing as a response to a moment, not to a command.

The conclusion on this point: LangGraph is the right chassis, not the value. The value is in the doctrine of the split, the state structures (evidence, investigation, decisions, timing) and the mechanisms that make every regime auditable. Using LangGraph is neither original nor a problem — it's using standard steel for an architecture that, itself, isn't standard.

Phased implementation recommendation

• Start small, in supervisor mode. Production advice is unanimous: start with a flat supervisor, only add hierarchy after measured bottlenecks. First circle: Phronêsis (supervisor) + Logos + Epistêmê + Technê. That's already a system that answers, proves, and produces.
• Add the critique. Elenchos in the second circle — it's what creates the visible qualitative gap.
• Add the daemons. Aisthêsis and Kairos as background tasks (continuous ingestion, monitoring) — technically event-triggered graphs rather than workers of the main graph.
• Add obliqueness last. Mètis and Sophia require traceability (the investigation log) to already be in place, or obliqueness turns into vagueness.
• Evaluate continuously. Two minimum metrics, borrowed from production practice: routing accuracy (did the right regime handle the request?) and resolution completeness. Plus one metric specific to EigenVertex: the rate of contradictions Elenchos detects that turn out to be founded.

Commoditisation works in our favour

Models will keep improving and frameworks will keep becoming commonplace. Every model advance makes the ten regimes *sharper*, not less relevant: a model that reasons better makes a better Elenchos, a longer context makes a better Sophia, a native audio model makes a better Aisthêsis. The regime-based architecture is a receiving structure for model progress — it won't be made obsolete by it, it absorbs it.

The inter-agent protocol as a horizon

Agent-to-agent interoperability protocols (A2A and successors) are standardising. On a 2-3 year horizon, a credible scenario: a client's EigenVertex agents talk to third-party agents (a partner's compliance agent, a supplier's procurement agent). In that world, the typology becomes a semantic contract: exposing "this is our Epistêmê, it speaks in claims + evidence levels" is infinitely more interoperable than exposing a generic chatbot. The ten regimes can become published interfaces.

Kairos as a product category

Today, detecting the opportune moment is an internal mechanism. Tomorrow, it's potentially a product category in its own right: systems sold not to answer but to *know when to speak*. Today's augmented monitoring notifies; a mature Kairos publishes an argued opportunity note the moment the window opens, and stays silent the rest of the time. Scarcity as a feature. EigenVertex has a conceptual head start here — few players treat timing as a regime of intelligence.

Versioned memory as an asset

As an EigenVertex deployment ages, its Mnêmê accumulates something no competitor can replicate: the versioned history of the domain's knowledge *as it evolved*. In three years, being able to ask "what did we know in January 2027, and what made us change our mind?" will be a strategic asset — for audit, compliance, training, decision-making. It's a moat that deepens on its own over time. What-changed reviews are only the first exploitation of it.

Risks to keep in view

• Cost. Ten active regimes on every request would be ruinous (multi-agent token overheads are documented and real). The answer is in routing: Phronêsis only activates the regimes the situation calls for. A simple question = Logos + Epistêmê, two calls. A complex investigation = the full orchestra, deliberately and billed as such.
• Over-engineering. Some tasks should stay deterministic and plain: access rights, field extraction, exports. Obliqueness is reserved for the layers where it adds value — exploration, synthesis, monitoring, diagnosis.
• The Greek varnish. The risk of looking decorative never fully disappears. The safeguard stays the same: function first, name second, and every name backed by a measurable mechanism. The day an agent no longer has a mechanism of its own, it gets merged — fidelity is owed to the regimes of intelligence, not to the number ten.