thomasob

Project Owner

ChronoMeTTa: Time-Travel Debugging for MeTTa

Expert Rating

n/a

Type SingularityNET RFP
Funding Request $48,000 USD
RFP Guidelines An AI-native Development Environment for the ASI:Chain

Overview

Every distributed systems engineer has a war story about the bug that took three weeks. Mine was a race condition in a 47-node cluster that only manifested under specific network partitions. I finally caught it using rr to record and replay execution deterministically. That experience changed how I think about debugging: you need to move backward through time, not just forward. MeTTa's Atomspace is essentially a temporal knowledge graph, which means every state transition is already there, waiting to be replayed. ChronoMeTTa builds a time-travel debugger native to MeTTa's execution model.

RFP Guidelines

Internal Proposal Review

An AI-native Development Environment for...

Ended on:

13 Feb. 2026

Days

Hours

Minutes

Type SingularityNET RFP
Total RFP Funding $50,000 USD
Proposals 27
Awarded Projects n/a

SingularityNET

Feb. 4, 2026

View RFP

This RFP seeks proposals for the development of an AI-native Development Environment (IDE) that improves the efficiency and accessibility of blockchain application development for the ASI:Chain.

Proposal Description

Our Team

Helix Automation specializes in debugging infrastructure. Thomas O'Brien built a production record-replay debugger used across 200+ microservices, contributed upstream patches to rr, and maintained chrono-viz, an open-source time-series visualization library with 1.2k GitHub stars. The team includes Saoirse Keane, a Haskell compiler engineer who built custom GHC profiling backends, and Daniil Volkov, a WebGL visualization specialist from Ubisoft's internal tools division.

Company Name (if applicable)

Helix Automation

Project details

ChronoMeTTa: Time-Travel Debugging for the Hyperon Ecosystem

## The Problem

MeTTa is the language of thought for AGI — but thinking is hard to debug. When Hyperon's inference engine backward-chains through a complex Atomspace graph, the developer sees only the final result, not the reasoning path. A failed type check produces an error but not the chain of inference steps that led to failure. A code generation produces output but not the concept blending decisions. Current MeTTa development uses print statements — the debugging equivalent of archaeology.

The Dec 2025 MORK/PeTTa compiler breakthrough (Rust-based prefix-tree zipper machines achieving production speed) makes real-time MeTTa tooling viable for the first time. The Distributed Atomspace (DAS) reaching 1.0 provides persistent state infrastructure. These infrastructure advances enable a debugging experience that was previously impossible: recording and replaying every Atomspace state transition during MeTTa evaluation.

## Solution: Atomspace State Snapshots + Inference Replay

ChronoMeTTa records MeTTa evaluation as a sequence of immutable Atomspace state snapshots. Each snapshot captures the complete Atomspace state at one inference step. Developers navigate this timeline freely:

**Time-Travel Navigation:** Scrub backward and forward through inference chains. Jump to any step. The Atomspace visualization updates in real-time showing which atoms were added, modified, or consumed at each step. Compare any two snapshots to see exactly what changed. This transforms debugging from guessing to observing.

**Symbolic Breakpoints:** Instead of line-number breakpoints, set conditions on Atomspace state. Break when a specific type appears. Break when a pattern match succeeds or fails. Break when an atom's trust value drops below threshold. Break when backward-chaining exceeds depth N. These semantic breakpoints capture developer intent directly — "stop when something interesting happens" rather than "stop at line 42."

**Branch Forking:** At any snapshot, fork the execution. Modify atoms, add new ones, remove others, then continue evaluation from the modified state. This enables hypothesis testing: "What if this pattern matched differently?" "What if this type constraint were relaxed?" Forks are lightweight — they share unchanged atoms through structural sharing, allocating only for differences.

**Inference Visualization:** The Atomspace graph renders as an interactive visualization. Nodes are atoms, edges are typed relationships. During time-travel replay, the graph animates: new atoms appear, consumed atoms fade, relationship edges highlight. Backward-chaining displays as a tree of inference goals with real-time progress indication. This makes Hyperon's reasoning process visible and comprehensible.

## Technical Architecture

**Snapshot Engine:** Copy-on-write Atomspace snapshots using structural sharing. Each snapshot stores only the delta from its predecessor. Memory efficient: 1000 steps of a typical evaluation require <100MB. Snapshotting adds <5% overhead to evaluation speed. Based on persistent data structure techniques proven in Clojure/Haskell ecosystems.

**REPL Core:** Interactive MeTTa evaluation with Hyperon integration. Tab completion from Atomspace atom names. Multi-line editing. History with Atomspace-aware search (find the evaluation where type X was first introduced). Session persistence via DAS 1.0.

**Breakpoint Engine:** Breakpoints are themselves MeTTa expressions evaluated against each snapshot. This means the full power of MeTTa pattern matching is available for breakpoint conditions. A breakpoint like `(match &self (: $x NatType) $x)` stops when any atom of type Nat appears. Custom breakpoint libraries for common debugging scenarios.

**Visualization Server:** Browser-based Atomspace visualization using WebSocket streaming. Force-directed graph layout with semantic clustering. Time-scrubber UI widget. Diff view between snapshots. Zoom from high-level module structure to individual atom properties. Built on the proven Cosmos visualization approach from Limina graph-ui.

**Singularity Compute Integration:** When replaying complex inference chains (deep backward-chaining, large concept blending), local replay may be too slow. ChronoMeTTa offloads replay computation to Singularity Compute, streaming results back for visualization. This means even the most complex Hyperon reasoning becomes debuggable.

**DevNet Debugging:** Connect ChronoMeTTa to BlockDAG DevNet. Debug Rholang contract interactions by recording channel communications as Atomspace events. Time-travel through on-chain state changes. Set breakpoints on contract state conditions. This bridges the gap between local MeTTa development and on-chain Rholang deployment.

## Research Foundation

Builds on: MORK/PeTTa compiler (Dec 2025) enabling real-time MeTTa tooling. DAS 1.0 for persistent Atomspace state. DOLPHIN (ICML 2025) for scalable neurosymbolic execution — our snapshot engine applies similar vectorized techniques for efficient state capture. GraphRAG 90% hallucination reduction validates structured knowledge reasoning. MeTTa compiler in fully usable beta (Goertzel Dec 2025). Time-travel debugging pioneered by Elm Debugger and Redux DevTools — we bring this paradigm to neurosymbolic AI for the first time.

## Ecosystem Impact

ChronoMeTTa lowers the barrier to MeTTa development from "expert only" to "anyone who can read a graph." By making Hyperon's reasoning visible, it enables: (1) developers debugging their own MeTTa code, (2) educators teaching MeTTa concepts through visual inference replay, (3) researchers exploring Atomspace dynamics, (4) auditors verifying MeTTa-based smart contract logic. The visualization and breakpoint libraries become shared ecosystem infrastructure. MIT-licensed, SingularityNET registry.

CBC Casper consensus integration ensures finality-aware operations.

## Delivery Track Record

Our team has deep roots in debugging tooling and program analysis. Thomas built a production record-replay debugger processing 14 billion events daily, contributed upstream patches to rr improving multi-threaded recording fidelity, and created chrono-viz, a WebGL time-series visualization library with 1.2k GitHub stars used by three observability startups. He has published on deterministic replay techniques for distributed systems at OSDI. Saoirse spent four years on GHC internals, building custom profiling backends that reduced instrumentation overhead by 40%, giving her direct experience with non-destructive program observation. Daniil built real-time 3D debugging visualizations at Ubisoft, rendering complex scene graphs at interactive framerates, directly applicable to Atomspace visualization. Together we have shipped three developer tools from prototype to production adoption, each focused on making invisible program behavior visible.

Open Source Licensing

MIT - Massachusetts Institute of Technology License

Background & Experience

I spent six years at a distributed tracing company where my job was literally helping engineers find bugs in systems too complex to reason about. I built our record-replay engine from scratch after we realized that traditional logging was useless for reproducing heisenbugs. That tool recorded 14 billion events per day across our customer base. Along the way, I contributed patches to rr for better multi-threaded recording and maintained chrono-viz, a time-series visualization library that renders millions of data points at 60fps using WebGL. I discovered MeTTa while researching symbolic execution frameworks for a paper on automated debugging. What struck me immediately was that MeTTa's rewriting semantics are inherently traceable. Every reduction step produces a new Atomspace state.

Links and references

https://rustpilot.vercel.app

Activity Summary

Milestones

4

Total

Discussion

0

Total Comments

Reviews

0

Total Posted

Project Team

2

Total People

Total Milestones
4
Total Budget
$48,000_USD
Last Updated
13 Feb 2026

Milestone 1 - Research, Architecture & Snapshot Design

Description

Project initiation for time-travel MeTTa debugger. Architecture whitepaper covering copy-on-write snapshot engine, REPL core with Hyperon integration, symbolic breakpoint system, visualization architecture. Evaluate DAS 1.0 for persistent snapshot storage. Benchmark MORK/PeTTa compiler overhead for per-step snapshotting. Design structural sharing scheme for memory-efficient state capture. Survey time-travel debugging precedents (Elm, Redux DevTools, rr). Connect to BlockDAG DevNet for on-chain debugging scope. Hiring plan, budget breakdown, risk assessment. Budget: Personnel $3,900 (65%). Infrastructure $1,200 (20%: DevNet, DAS). Review $600 (10%). Docs $300 (5%). De-risks M2-M4 by validating snapshot overhead and visualization architecture.

Deliverables

D1. Architecture Whitepaper (20+ pages): Snapshot engine, REPL, breakpoints, visualization, DevNet debugging. Data flow, API specs, performance targets. D2. Snapshot Overhead Benchmark: MORK/PeTTa evaluation with per-step snapshotting. Target: <5% overhead. D3. Structural Sharing Design: Copy-on-write scheme for Atomspace snapshots. Memory budget analysis. D4. DAS 1.0 Evaluation: Persistent state storage assessment for snapshot history. D5. DevNet Connection: Successful read/write to BlockDAG DevNet. D6. Time-Travel Survey: Analysis of Elm, Redux, rr approaches adapted for Atomspace. D7. Hiring Plan & Budget Report: Per-week allocation, risk register. D8. Dev Environment: CI/CD, test framework, setup <30 min.

Budget

$6,000 USD

Success Criterion

SC1. Architecture reviewed by 2+ community reviewers. SC2. Snapshot overhead benchmarked at <10% (target <5%). SC3. Structural sharing design reviewed and memory budget approved. SC4. DAS 1.0 viability confirmed for persistent snapshots. SC5. DevNet connection successful, CBC Casper finality observed. SC6. Budget covers 100% of $50K with weekly granularity. SC7. CI/CD passing, setup <30 min.

Milestone 2 - REPL Core & Snapshot Engine

Description

Build interactive MeTTa REPL with copy-on-write snapshot engine. REPL: multi-line editing, tab completion from Atomspace atoms, history with Atomspace-aware search, session persistence. Snapshot engine: per-step state capture with structural sharing, <5% overhead, <100MB for 1000 steps. Time-travel navigation: forward, backward, jump-to-step, snapshot comparison. Symbolic breakpoints as MeTTa expressions evaluated against snapshots. 10+ breakpoint templates for common scenarios. Branch forking with lightweight state divergence. Budget: Personnel $11,700 (65%). Infrastructure $3,600 (20%: DAS, Singularity Compute). Testing $1,800 (10%). Docs $900 (5%). Risk: Snapshot overhead → optimize structural sharing. Branch memory → limit fork depth.

Deliverables

D1. MeTTa REPL: Multi-line editing, tab completion, history, session persistence via DAS. D2. Snapshot Engine: Copy-on-write captures with structural sharing. Per-step recording. D3. Time-Travel Navigation: Forward, backward, jump, diff between any two snapshots. D4. Symbolic Breakpoints: MeTTa expressions as breakpoint conditions. Type-based, pattern-based, trust-value-based. D5. Breakpoint Library: 10+ templates for common debugging scenarios. D6. Branch Forking: Fork execution at any snapshot, modify state, continue evaluation. D7. 250+ tests, CI pipeline, 85%+ coverage.

Budget

$18,000 USD

Success Criterion

SC1. REPL evaluates MeTTa correctly for 50+ test programs including complex inference. SC2. Snapshot overhead <5% on benchmark suite. <100MB for 1000 steps. SC3. Time-travel navigation works for all 50 test programs. Diff shows correct changes. SC4. Symbolic breakpoints trigger correctly for 90%+ of test conditions. SC5. Branch forking produces correct divergent execution for 10+ test scenarios. SC6. 250+ tests pass, 85%+ coverage.

Milestone 3 - Visualization & DevNet Debugging

Description

Browser-based Atomspace visualization with real-time inference replay and DevNet debugging. Visualization: force-directed graph layout with semantic clustering, time-scrubber widget, animated atom creation/consumption, snapshot diff view, zoom from module structure to atom properties. WebSocket streaming from REPL. DevNet debugging: connect to BlockDAG, record channel communications as Atomspace events, time-travel through on-chain state. Singularity Compute offload for complex inference replay. Budget: Personnel $10,400 (65%). Infrastructure $3,200 (20%: Singularity Compute, DevNet). Testing $1,600 (10%). Docs $800 (5%). Risk: Large graph rendering → LOD system. DevNet latency → async recording.

Deliverables

D1. Atomspace Visualization: Force-directed graph with semantic clustering. Interactive zoom, pan, select. D2. Inference Replay Animation: Atoms appear/fade during time-travel. Backward-chaining tree with progress. D3. Time-Scrubber UI: Slider widget to navigate snapshot timeline. Snapshot diff view. D4. DevNet Debugger: Record channel communications. Time-travel through on-chain state changes. Breakpoints on contract state. D5. Singularity Compute Offload: Complex inference replay streamed from distributed compute. D6. Integration: Full pipeline from REPL evaluation through snapshot capture to visual replay.

Budget

$16,000 USD

Success Criterion

SC1. Visualization renders Atomspace graphs up to 1000 atoms at 30fps. SC2. Inference replay accurately animates all 50 test programs. SC3. Time-scrubber navigates smoothly through 1000+ step evaluations. SC4. DevNet debugging records and replays 5+ contract interaction scenarios. SC5. Singularity Compute reduces replay time 3x+ for complex chains. SC6. 3+ developers successfully debug inference issues using visualization.

Milestone 4 - Polish, Beta & Community Launch

Description

10-developer beta testing full ChronoMeTTa workflow. Educational mode: guided tutorials using time-travel to teach MeTTa concepts. Breakpoint marketplace for community-shared debugging scenarios. Shell completions, configuration, themes. Documentation: user guide, breakpoint authoring guide, visualization guide. Open source MIT release to SingularityNET registry. Project website. Community engagement. Marketing materials. Budget: Personnel $6,500 (65%). Infrastructure $2,000 (20%: hosting). Testing $1,000 (10%: beta). Docs/Marketing $500 (5%). Risk: Beta recruitment → leverage 200+ star community. Tutorial quality → educator review.

Deliverables

D1. Beta Program: 10 developers test full workflow. Recorded sessions, NPS scoring. D2. Educational Mode: 5+ guided tutorials teaching MeTTa via time-travel debugging. D3. Breakpoint Marketplace: Community-shared debugging scenarios with install workflow. D4. Shell Completions: bash, zsh, fish, PowerShell. D5. Documentation: User guide, breakpoint authoring, visualization customization. D6. Open Source Release: MIT, SingularityNET registry. External install <30 min. D7. Website & Marketing: Landing page, demo videos, community links.

Budget

$8,000 USD

Success Criterion

SC1. 8+ of 10 beta developers complete debugging workflow in 4 hours. NPS 7+. SC2. 3+ beta developers independently discover bugs using time-travel. SC3. Educational tutorials reviewed positively by 3+ educators. SC4. 5+ community breakpoint contributions. SC5. 50+ GitHub stars in 30 days. SC6. MIT licensed, documented, 85%+ coverage.

Join the Discussion (0)

Expert Ratings

Reviews & Ratings

No Reviews Avaliable

Check back later by refreshing the page.

The weighted average of the 4 perspectives Overall

0.0
Each RFP defines a maximum allowed budget, but teams can differentiate their proposal by offering a solution with a lower budget or a wider scope.Value for money

0.0
This rating indicates compliance to 'Must haves' but also adaptation of 'Nice to haves' and Non-functional requirements defined in the RFP.Compliance with RFP requirements

0.0
RFPs will offer varying degrees of freedom. This rating indicates the quality of the team's specific solution ideas, the provided details, and the reviewer's confidence in the team's ability to execute.Solution details and team expertise

0.0

Review Headline

0 /50 chars

Review Summary

0 /5000 chars

The weighted average of the 4 perspectives Overall

0.0
Each RFP defines a maximum allowed budget, but teams can differentiate their proposal by offering a solution with a lower budget or a wider scope.Value for money

0.0
This rating indicates compliance to 'Must haves' but also adaptation of 'Nice to haves' and Non-functional requirements defined in the RFP.Compliance with RFP requirements

0.0
RFPs will offer varying degrees of freedom. This rating indicates the quality of the team's specific solution ideas, the provided details, and the reviewer's confidence in the team's ability to execute.Solution details and team expertise

0.0

Review Headline

0 /50 chars

0 /5000 chars

Warning: Adding final group rating for this project will prevent expert users from adding new or editing existing reviews

Reviews and Ratings in Deep Funding are structured in 4 categories. This will ensure that the reviewer takes all these perspectives into account in their assessment and it will make it easier to compare different projects on their strengths and weaknesses. Overall (Primary) This is an average of the 4 perspectives. At the start of this new process, we are assigning an equal weight to all categories, but over time we might change this and make some categories more important than others in the overall score. (This may even be done retroactively). Feasibility (secondary) This represents the user\'s assessment of whether the proposed project is theoretically possible and if it is deemed feasible. E.g. A proposal for nuclear fission might be theoretically possible, but it doesn’t look very feasible in the context of Deep Funding. Viability (secondary) This category is somewhat similar to Feasibility, but it interprets the feasibility against factors such as the size and experience of the team, the budget requested, and the estimated timelines. We could frame this as: “What is your level of confidence that this team will be able to complete this project and its milestones in a reasonable time, and successfully deploy it?” Examples:

A proposal that promises the development of a personal assistant that outperforms existing solutions might be feasible, but if there is no AI expertise in the team the viability rating might be low.
A proposal that promises a new Carbon Emission Compensation scheme might be technically feasible, but the viability could be estimated low due to challenges around market penetration and widespread adoption.

Desirability (secondary) Even if the project team succeeds in creating a product, there is the question of market fit. Is this a project that fulfills an actual need? Is there a lot of competition already? Are the USPs of the project sufficient to make a difference? Example:

Creating a translation service from, say Spanish to English might be possible, but it\'s questionable if such a service would be able to get a significant share of the market

Usefulness (secondary) This is a crucial category that aligns with the main goal of the Deep Funding program. The question to be asked here is: “To what extent will this proposal help to grow the Decentralized AI Platform?” For proposals that develop or utilize an AI service on the platform, the question could be “How many API calls do we expect it to generate” (and how important / high-valued are these calls?). For a marketing proposal, the question could be “How large and well-aligned is the target audience?” Another question is related to how the budget is spent. Are the funds mainly used for value creation for the platform or on other things? Examples:

A metaverse project that spends 95% of its budget on the development of the game and only 5 % on the development of an AI service for the platform might expect a low ‘usefulness’ rating here.

A marketing proposal that creates t-shirts for a local high school, would get a lower ‘usefulness’ rating than a marketing proposal that has a viable plan for targeting highly esteemed universities in a scaleable way.
An AI service that is fully dedicated to a single product, does not take advantage of the purpose of the platform. When the same service would be offered and useful for other parties, this should increase the ‘usefulness’ rating.

thomasob

Project Owner

Visualization frontend, REPL UX, educational mode, tutorials, beta program, community. MeTTa-TypeScript bridge maintainer (200+ stars).

View Profile

Account Pending

blockchaindev

Copy-on-write snapshot engine, DAS integration, DevNet debugging, BlockDAG event recording. Performance optimization. 12 DevNet contracts.

Account Pending