Logos Reasoning Library

How Logos sits above the substrate, defines canonical archetypes and reusable patterns, and preserves runtime authority boundaries.

On this page
  1. Core model
  2. Detailed structure
  3. Canonical tree
  4. Archetype catalog
  5. Activation bundles
  6. Catalog artifacts
  7. Boundaries and invariants
  8. Extensibility
  9. Related

Logos Reasoning Library

Logos is the structured reasoning library above the Cortex substrate. It names reusable epistemological modes under Logos.Archetypes, one bounded model-mediated node evaluation under Logos.Thought, cognitive memory under Logos.Memory, and reusable reasoning programs under Logos.Patterns. It does not extend the runtime alphabet. Algebra, Wire, Pulse, Capability, and runtime provenance mechanics remain the substrate. Logos composes those mechanics into reusable reasoning programs.

Core model

The split is vertical:

LayerOwnsDoes not own
Cortex runtime substrateAlgebra, Wire language and compiled circuit form, Pulse execution, executor-registration capability, runtime provenance.Product persona, domain policy, concrete reasoning templates.
LogosArchetype taxonomy, thoughts, cognitive memory, provider/model adapters, reusable pattern catalogs, .wire templates, prompt families, artifact IRs.Runtime authority, new executor kinds, the substrate contract registry or its authority boundary, host tool implementations. Logos may publish Wire-package contract registry fragments interpreted by Cortex; it does not own the registry surface.
Downstream product bindingDomain prompts, product policy, domain tools, approval behavior, product artifact semantics.Generic substrate mechanics or generic Logos archetype definitions.

The dependency direction is strict:

flowchart LR
    Product[Downstream product binding] --> Logos[Logos<br/>structured reasoning library]
    Logos --> Runtime[Cortex substrate<br/>Algebra, Wire, Pulse, Capability]

Substrate code must not import Logos. Logos may import runtime types and publish catalog values or source templates that consumers opt into.

Detailed structure

Canonical tree

The canonical module and concept tree is:

Logos
|-- Archetypes
|   |-- Logos     -- discursive reason, argument, symbolic reasoning
|   |   `-- Activation
|   |-- Sophia    -- wisdom, judgment, synthesis
|   |   `-- Activation
|   |-- Techne    -- craft, engineering, implementation
|   |   `-- Activation
|   |-- Episteme  -- knowledge, evidence, research
|   |   `-- Activation
|   |-- Kritikos  -- criticism, adversarial review
|   |   `-- Activation
|   |-- Themis    -- audit, law, correctness, constraints
|   |   `-- Activation
|   `-- Poiesis   -- creative generation, composition
|       `-- Activation
|-- Thought       -- one bounded model-mediated node evaluation
|-- Memory        -- cognitive memory and context construction
`-- Patterns
    `-- DeepReport -- planned extraction target

Archetype catalog

The first catalog contains seven archetypes:

ArchetypeRoleTypical responsibilityLiterature-backed pattern
Logos.Archetypes.LogosDiscursive reason, argument, symbolic reasoningMake reasoning explicit as structured claims, premises, inference, and explanation.Self-consistency, Tree of Thoughts
Logos.Archetypes.SophiaWisdom, judgment, synthesisWeigh competing goods, recognize context, identify salience, and synthesize under uncertainty.LLM-as-a-judge, multi-agent debate
Logos.Archetypes.TechneCraft, engineering, implementationTurn understanding into working artifacts, executable plans, interfaces, tests, and systems.SWE-agent, CodeAct, tool-use frameworks
Logos.Archetypes.EpistemeKnowledge, evidence, researchGround cognition in what is known, observed, measured, cited, or otherwise supported.ReAct, tool-use agents, information retrieval
Logos.Archetypes.KritikosCriticism, adversarial reviewApply constructive severity to expose weak claims, hidden assumptions, contradictions, and failure modes.Constitutional AI, red-teaming
Logos.Archetypes.ThemisAudit, law, correctness, constraintsEnsure reasoning and action remain within defined bounds, contracts, policies, and invariants.AI safety, Constitutional AI, alignment
Logos.Archetypes.PoiesisCreative generation, compositionBring forth new forms, alternatives, narratives, designs, and generative possibilities.Creative generation, story-telling agents

The catalog describes reusable modes of cognition. It does not prescribe a specific provider, model, prompt, tool list, or domain ontology. Those are later library presets or downstream bindings.

Activation bundles

An archetype becomes operational when it is implemented as an activation bundle:

Logos.Archetypes.<Archetype>.Activation
  = prompt discipline
  + retrieval corpus
  + embedding index
  + tool surface
  + evaluation criteria
  + memory policy
  + runtime contract

The archetype is the semantic definition. The activation is the concrete bundle of assets and policies that implement that mode. A thought frame composes one or more archetype activations into a single cognitive evaluation.

Current implementation status: this first PR lands the type shape and module slots only. Current Logos.<Archetype>.Capability modules are staging stubs. The canonical target is Logos.Archetypes.<Archetype>.Activation, populated by later PRs with real prompts, corpora, embedding indexes, tool surfaces, memory policies, evaluation checks, and runtime contracts.

For example, Logos.Archetypes.Episteme.Activation is the home for evidence-grounded prompts, source-quality rules, retrieval strategies, source-ranking heuristics, uncertainty policy, citation discipline, and validation tests. A Logos.Archetypes.Kritikos.Activation bundle is the home for adversarial-review prompts, failure-mode corpora, contradiction checks, falsification discipline, and red-team evaluation. A Logos.Archetypes.Techne.Activation bundle is the home for codebase-local implementation memory, architecture conventions, build and test patterns, and implementation checks.

This makes the vocabulary operational. A node is not just tagged with Episteme; it runs with the Episteme activation active. The activation shapes what context is retrieved, which tools are available, which prompt discipline is applied, which memory policy is used, and how the result is evaluated.

The stub activations in this PR are not yet operational substrates. They are public slots and expected component lists for follow-up implementation.

Retrieval is thought-frame-aware rather than a single global index per archetype. An activation can combine canonical corpus, local project corpus, examples, failures, contracts, and tool docs with task-specific weights. A Techne activation for Cortex code and a Techne activation for another domain share the archetype but activate different local corpora and tool surfaces.

Catalog artifacts

Logos can expose the following catalog artifacts:

ArtifactShapeRuntime relationship
Archetype definitionsHaskell data values under Logos.ArchetypesMetadata only. No runtime registration.
Activation bundle slotsPrompts, corpus selectors, embeddings, tools, memory policy, evaluation, runtime contractStubbed in this PR; later activated by thought frames and interpreted through existing substrate APIs.
Thought runtimeFrame, policy, host, tool loop, structured output, thought eventsUses Logos model/provider surfaces without granting host authority.
Cognitive memoryRetrieval, ranking, packing, compaction, source selection, topological contextBuilds model context over substrate state; Pulse remains durable execution state.
Pattern catalogsLogos.Patterns.<Name> modulesLibrary-owned reasoning programs interpreted by existing substrate APIs.
Template programs.wire modules shipped by Logos patternsImported by consumers and compiled by the normal Wire compiler.
Memory presetsHaskell values naming query and walk strategy defaultsPassed through Logos.Memory APIs over substrate state.
Contract conventionsStable contract entries and documentationImplemented through the existing contract registry.
Prompt familiesText builders or source artifactsBound to executors by consumers or library templates.

The important rule is that each artifact is interpreted by an existing substrate mechanism. Logos catalogs do not add a hidden resolver.

Boundaries and invariants

Logos is correct when these invariants hold:

  • Substrate modules do not import Logos modules.
  • Archetype names never grant tool access, model access, side effects, or host authority.
  • Archetype activations can request tool surfaces and runtime contracts, but those requests are still admitted through existing executor, contract, and host authority boundaries.
  • Patterns can ship contracts, ports, prompts, and templates, but executable authority still comes from consumer-selected executors and host bindings.
  • A node’s executable authority still comes from its registered executor and its configured tool scope.
  • A node’s payload obligations still come from its contracts and runtime validation.
  • Archetypes classify epistemic function and reusable program shape; contracts define data obligations; activations bundle operational assets; executors define runnable authority.

What Logos intentionally does not enforce in this first slice:

  • role-contract refinement typing
  • per-run admission policy for reasoning templates
  • full canonical .wire program set
  • downstream domain semantics

Those are follow-up decisions and implementation work, not prerequisites for the taxonomy to exist.

Extensibility

New archetypes require an ADR because they change the public epistemological vocabulary. Downstream products do not need an ADR to create product-specific roles; they should map those roles to the nearest Logos archetype when using generic templates.

Program templates extend the library by composing existing runtime authority:

  • choose archetypes for structural role clarity
  • bind concrete executors through the normal executor registry
  • bind contracts through the normal contract registry
  • attach memory presets through Logos.Memory
  • compile through Wire and run through Pulse unchanged

The planned target for reusable LLM-shaped workflow extraction is Logos.Patterns.DeepReport. Its first slices should extract generic contract and port catalogs; downstream bindings keep product tools, artifact semantics, DB loading, and authorization.