Graph Architecture — Mikoshi AI Turbo

The Reasoning Graph

Propose → Verify → Select as a Graph

Every Turbo query creates a directed acyclic graph (DAG) of reasoning. The prompt node fans out to candidate nodes, each connected to a verification node, which feeds into a scoring node. The best-scored candidate is selected as the final answer.

💬 Prompt

🧠 Cand. A
t=0.3

🧠 Cand. B
t=0.6

🧠 Cand. C
t=0.9

🔬 Verify A
✅ pass

🔬 Verify B
✅ pass

🔬 Verify C
❌ fail

📊 0.96

📊 0.87

📊 0.38

✅ Selected
Answer

Components

Graph Node Types

The reasoning graph consists of five types of nodes, each representing a distinct phase of the Turbo pipeline:

// Graph node types
const NodeTypes = {
  PROMPT:       'prompt',        // User's question — root node
  CANDIDATE:    'candidate',     // Generated answer at temperature T
  VERIFICATION: 'verification',  // Test code + execution result
  SCORE:        'score',         // Fuzzy predicate scores
  SELECTED:     'selected',      // Final chosen answer — leaf node
};

// Edge types
const EdgeTypes = {
  GENERATES:  'generates',   // Prompt → Candidate
  VERIFIES:   'verifies',    // Candidate → Verification
  SCORES:     'scores',      // Verification → Score
  SELECTS:    'selects',     // Score → Selected
  CONTEXT:    'context',     // Previous Selected → New Prompt
};
      

Prompt node: The root of each query sub-graph. Contains the original question and any context
Candidate nodes: Fan out from the prompt — one per temperature setting
Verification nodes: One-to-one with candidates. Contain the test code and pass/fail result
Score nodes: Fuzzy predicate scores (correctness, confidence, coherence)
Selected node: The winning answer. Becomes context for future queries

Memory

The Graph Grows Over Time

Each query adds a new sub-graph to the overall reasoning graph. The selected answer from one query becomes context for the next, creating a knowledge chain:

// Multi-query graph growth
Query 1: "What is 47 × 83?"
  └─ Candidates → Verify → Score → Selected: 3901

Query 2: "Now divide that by 7"  ←── context: 3901
  └─ Candidates → Verify → Score → Selected: 557.28...

Query 3: "Round to nearest integer"  ←── context: 557.28
  └─ Candidates → Verify → Score → Selected: 557

// The graph now has 3 linked sub-graphs
// Total nodes: 3 prompts + 9 candidates + 9 verifications
//              + 9 scores + 3 selected = 33 nodes
      

This graph structure provides a complete audit trail of every decision. You can trace back through the graph to see exactly why any answer was selected, what alternatives were considered, and what verification evidence exists.

Why Graphs

Graphs vs Linear Chains

❌ Linear Chain (Standard AI)

Prompt → Answer → Prompt → Answer

Single path. No alternatives explored. No verification. Error in one step propagates to all subsequent steps. No way to backtrack or audit.

✅ Reasoning Graph (Turbo)

P ⟶ C₁ C₂ C₃ ⟶ V₁ V₂ V₃ ⟶ ✅

Multiple paths explored simultaneously. Each verified independently. Errors caught and filtered. Full audit trail. Knowledge compounds across queries.

Parallelism: Graphs explore multiple solution paths simultaneously
Error isolation: A bad candidate doesn't corrupt the others
Auditability: Every decision can be traced and explained
Context accumulation: Knowledge from verified answers compounds over time
Resilience: If one path fails, others can still succeed

Connections

Relation to Knowledge Graphs

Turbo's reasoning graph shares principles with knowledge graphs used in modern AI systems:

Structured knowledge: Facts and relationships stored as nodes and edges, not flat text
Traversable reasoning: You can walk the graph to understand the chain of logic
Composable: Sub-graphs from different queries can be connected when topics overlap
Persistent memory: Unlike chat history (linear, lossy), graphs preserve the full reasoning structure

🔮 Future Direction

The Mikoshi team is researching cross-session graph persistence — where verified knowledge from previous sessions can be reused without re-verification. Imagine: ask a question once, prove the answer, and never need to re-derive it. This is the foundation for truly cumulative AI intelligence.