Every feature shown here runs on real data generated from a single question: "Can AI systems develop genuine consciousness, or is machine consciousness fundamentally different from biological consciousness?"
This guide walks through every tab, panel, and capability in the platform.
- ThinkGraph — Persistent Reasoning Graphs
- Agent Swarm — 6-Specialist Orchestration
- Graph of Thoughts — Tree Search Reasoning
- Step Verification — Structured Reasoning (PRM)
- ThinkFork — Divergent Analysis
- Metacognitive Insights — Self-Reflection
- Memory Hierarchy — MemGPT-Inspired
- Sessions — Persistent Reasoning Library
The core innovation: every extended thinking session becomes a navigable, persistent graph. Nodes represent discrete reasoning steps. Edges are typed (influence, support, contradiction, refinement, supersedes) to show how ideas relate.
The complete workspace: reasoning graph center stage, session list on the left, right panel with Insights/Fork/Memory tabs, and the thinking input at the bottom. The header shows the session title, replay tour button, and navigation links.
Zoomed into the graph structure:
- Green nodes (majority) — Regular thinking steps with confidence scores
- Orange/red bordered nodes — Fork branches (contrarian and aggressive perspectives)
- Teal node — Compaction boundary (context consolidation checkpoint)
- Colored edges — Different relationship types visible at a glance
- Minimap (bottom-right) — Navigate large graphs efficiently
- Legend (top-left) — All 5 edge types and 3 node types documented
Each node displays a truncated reasoning excerpt and its confidence score. Click to expand the full reasoning text.
Traditional AI interfaces show only final answers. ThinkGraph persists the entire reasoning path as a first-class data structure:
- Every node is stored in PostgreSQL with pgvector embeddings
- Edges capture the actual relationships between reasoning steps
- Graphs survive across sessions and can be queried, compared, and extended
- Decision points within nodes are extracted and tracked separately
A swarm of 6 specialized AI agents collaborate on complex problems in 3 phases:
- Phase 1: Maestro decomposes the query into subtasks
- Phase 2: DeepThinker, Contrarian, Verifier run in parallel
- Phase 3: Synthesizer merges, then Metacognition audits
The Synthesizer agent's output: a structured analysis incorporating all agent perspectives. Notice the session stats on the left (17 thinking nodes, 62K total tokens, 14 high-confidence nodes, 1 low-confidence). The tab bar shows ThinkGraph, Swarm, GoT, and Verify tabs.
The full swarm execution trace showing multiple agent phases. Each agent's output is collapsible with role labels, key findings, and challenge details. The human can intervene at checkpoint boundaries to steer the analysis.
Unlike simple multi-agent setups, the Opus Nx swarm:
- Streams agent reasoning live via WebSocket (not batch)
- Uses a SharedReasoningGraph (NetworkX) so agents build on each other's work
- Provides human-in-the-loop checkpoints between phases
- Tracks token usage per agent for cost transparency
- The Metacognition agent audits the entire swarm for biases after synthesis
An implementation of Besta et al. (2023) — arbitrary thought graph topologies with BFS, DFS, or best-first search.
Top: the thought tree visualization with color-coded depth levels. Bottom: the full thought stream showing each node's reasoning in detail. The tree uses BFS/DFS/best-first search over reasoning branches, with aggregation and verification at each level.
A 4-depth GoT tree with 8+ branches:
- Top (root): The original question with 100% confidence
- Level 1 (pink): Aggregated reasoning perspectives (75%–88% confidence)
- Level 2 (green): Verified sub-arguments (70%–85%)
- Level 3 (yellow): Evaluated evidence and counterarguments (75%–87%)
- Level 4 (blue/orange): Final verified conclusions and aggregated syntheses (83%–94%)
Each node shows: thought content, confidence score, verification status (Verified/Aggregated), and a "best path" indicator for optimal reasoning chains. Edge colors match the node depth for visual tracing.
The GoT implementation goes beyond the original paper by:
- Persisting the entire thought tree as reasoning artifacts
- Color-coding depth levels for instant visual orientation
- Showing verification status (Verified vs. Aggregated) per node
- Highlighting the "best path" through the tree
- Integrating with the ThinkGraph — GoT results become graph nodes
Based on "Let's Verify Step by Step" (Lightman et al., 2023). Each reasoning step is extracted, typed, and verified independently.
The first 5 steps of a 13-step reasoning chain:
- Steps 1-4: CONSIDERATION — Examining the analysis structure, identifying strengths, noting risks
- Step 5: HYPOTHESIS — Identifying philosophical assumptions embedded in the framing
Each step has a numbered badge, colored type label, and the full reasoning text. Header shows: 13 Steps, 13 Decisions, 1 Edge, 1.6K thinking tokens, 40% confidence.
Steps 6-9: The chain transitions from HYPOTHESIS to EVALUATION, examining each claim against evidence and identifying logical gaps.
Steps 10-12: Deep EVALUATION of specific claims — testing each assertion for falsifiability, examining counterarguments, and rating argument strength.
The final step (13: EVALUATION), followed by the MAIN CONCLUSION (highlighted in green) and the MODEL OUTPUT section. The conclusion summarizes the entire deliberation chain, and the output presents a structured response generated from the reasoning.
The Verify tab shows the full PRM output: a step-by-step verification chain with confidence bands (green gradient), step validity assessments, and overall chain integrity scoring.
A zoomed view of a single reasoning artifact: the complete text of a thinking node, showing the full deliberation including strengths, weaknesses, philosophical assumptions, and synthesis.
Most verification approaches check only final answers. PRM in Opus Nx:
- Extracts discrete reasoning types (consideration, hypothesis, evaluation, conclusion)
- Verifies each step independently with per-step confidence
- Tracks the decision count within each reasoning pass
- Persists structured reasoning as a queryable artifact
- Links each step back to the source thinking node in the graph
Fork any question into 4 concurrent reasoning styles: conservative, aggressive, balanced, and contrarian. Based on Tree of Thoughts (Yao et al., 2023) with added debate mode.
Left: The divergent analysis overview showing 4 branches, 4 perspectives, and 8 divergences identified. The Analysis Summary section shows key points from each style.
Right: Final positions from each perspective with confidence scores:
- Conservative (82%): Focus on falsifiable functional measures
- Aggressive (45%): Consciousness is already emerging
- Balanced (78%): Multi-dimensional consciousness space
- Contrarian (58%): Computation may be fundamentally insufficient
Each perspective includes key points, confidence scoring, and the style badge. The synthesis at the bottom reconciles the positions.
ThinkFork adds to Tree of Thoughts by:
- Running 4 reasoning styles concurrently (not sequentially)
- Allowing mid-flight steering — redirect any branch while it's running
- Producing fork branch nodes that integrate into the ThinkGraph
- Offering a Debate mode where branches argue against each other
- Quantifying divergence between perspectives
The AI analyzes its own reasoning for biases, patterns, and blind spots. Uses a 50K thinking budget to audit reasoning traces across the session.
Left: 7 total metacognitive insights: 3 biases, 3 patterns, 1 improvement idea. The panel shows all insights with confidence scores, searchable and filterable by type. The confidence slider lets you set a minimum threshold.
Right: An Improvement insight (75% confidence) suggesting a "conditional analysis protocol" for contested philosophical questions. Includes metadata showing which agents generated the insight and the source (swarm_v2).
Left: A bias insight detecting "confirmation validation" — where the verifier tends to mark pre-existing beliefs as "correct" rather than genuinely probing them. Includes specific evidence citations with node references.
Right: A pattern insight identifying convergence across all agents toward gradient/spectrum models, with analysis of whether this represents genuine insight or groupthink.
Metacognition in Opus Nx goes beyond simple summarization:
- Uses a dedicated 50K thinking budget (separate from the main analysis)
- Categorizes findings into 3 types: bias detection, pattern recognition, improvement hypotheses
- Links every insight back to specific evidence nodes in the graph
- Tracks actionability (high/medium/low) for each finding
- Can audit across sessions, not just within one
A 3-tier memory system based on MemGPT (Packer et al., 2023): working context, recall buffer, and archival storage.
Left: The Memory Hierarchy panel showing:
- Main Context (Working Memory): 4 entries, 1,061 tokens, 1% capacity
- Recall (Recent History): 4 entries
- Archival (Long-term Knowledge): 0 entries (promotes from recall over time)
- Stats: Insertions, Searches, Evictions, Promotions tracked
- Recent Entries: Each showing content, importance score, source type, and tier badge
Right: The Recall tier with entries showing "What's biased to say" analysis and "Token Usage" metadata. Each entry is tagged with its importance score and source (thinking_node).
The memory system provides cross-session reasoning continuity:
- Auto-eviction when working memory exceeds token budget
- Promotion pipeline: working → recall → archival based on access patterns
- Semantic search via pgvector embeddings (voyage-3, 1024-dim)
- Knowledge entries with graph relations (theoretical_basis, supports, challenges, informs)
- Token accounting per tier to prevent context overflow
Every session is a persistent reasoning artifact that can be revisited, extended, or shared.
The session panel showing:
- Thinking Nodes: 17 discrete reasoning steps persisted
- Total Tokens: 62.0K consumed across all operations
- High Confidence: 14 nodes above threshold
- Low Confidence: 1 node flagged for review
- Token Breakdown: Thinking (323), Input (51.5K), Output (10.1K)
- Session timestamp and active status indicator
Sessions in Opus Nx aren't just chat history:
- Every session contains a full reasoning graph (nodes + edges + decisions)
- Sessions can be shared via unique tokens
- Archived sessions can be restored and extended
- Cross-session insights compare reasoning patterns over time
- The evaluation harness measures retrieval quality and reasoning improvements
git clone https://github.com/omerakben/opus-nx.git
cd opus-nx
./scripts/dev-start.shSet DEMO_MODE=true in your .env, then click "Launch Demo" on the login page. The demo seeds a fully populated workspace with all features visible — ThinkGraph, Swarm, GoT, Verify, Fork, Insights, Memory, and a guided tour walks through each one.
Built by Ozzy + TUEL AI + Claude — a human-AI collaboration exploring persistent reasoning artifacts.