🤓 Latest Submissions
NodeFlow: Speak it, IBM Bob 2.0 builds it
The problem. An unclear request costs you three times: in implementation (you build too much or too little), in review (there is nothing to compare against, so review becomes opinion) and in fixes (the defect surfaces late, when other code already sits on top of it). The workflow. Every request starts as a contract — scope, function signature, enumerated cases — committed before any code, so the request has a fixed date. IBM Bob 2.0 implements against that text. Then an independent review by a different agent audits the delivery against the same contract. One real request: the contract for the partial-transcript segmenter was committed first (docs/hackathon/PEDIDO-BOB-01.md); Bob implemented the module and its endpoint and delivered cff0baa; a later revision fixed its stability (e84fb5b). A second request — creating nodes when the voice turn closes — landed in 8582026, and the review caught that nodes were being created once per audio segment instead of once per turn, fixed in 0e059ed. The steps are manual and deliberate: this is not an automatic voice-to-code pipeline. What we built. A local-first desktop app (Tauri + Rust + React Flow) where you think out loud and the canvas draws itself: a deterministic segmenter decides whether what you said is an idea, a correction or noise; a draft node appears while you speak; and when the turn closes, each topic becomes a real node — chained, draggable, connectable — created without a confirmation step, because the safety net is undo. A public web demo runs the same interface in the browser, with real dictation powered by a temporary session the server issues, so nobody has to bring their own key. The interface ships in Spanish and English. Why it holds together. The canvas is where the request becomes the contract: you talk, the nodes appear, and it is written down while it is still fresh. The contract is what makes review objective, and the review is what catches the defect before merge. The limits, stated up front. The test counts (324/324 Rust, 141/141 frontend) are recorded results from the suites on the named commits, not a measured saving. The defect caught in review is one case, not a controlled experiment. The process was applied to this project: it does not prove general productivity.
27 Sep 2026
NodeFlow (Hybrid Knowledge Orchestrator)
NodeFlow bridges the gap between chaotic brainstorming and structured knowledge execution. It is a local-first desktop application and orchestrator that converts spoken thoughts into a validated, human-approved knowledge graph. Built on top of Tauri v2, Rust, and React, NodeFlow continuously synchronizes with your local Obsidian vault, leaving your knowledge as plain Markdown files while keeping your GPU free for local inference. The Problem It Solves Waste & Opacity: Sending every minor prompt to cloud frontier models is expensive and opaque. NodeFlow routes tasks dynamically between local models (Ollama) and cloud APIs, accounting for exact token usage and financial cost. Hallucinated Actions: Traditional AI agents execute destructive changes autonomously. NodeFlow enforces a strict Human-In-The-Loop (HITL) pipeline where proposals must pass programmatic graph validation and explicit human approval. Amnesia & Lock-in: Chat interfaces lose context, and SaaS tools lock your data in proprietary databases. NodeFlow stores everything directly in your vault as Markdown + YAML. Core Features & Voice Loop Real-time Voice Execution: Built for the AssemblyAI Voice Agent Hackathon, NodeFlow opens a secure WebSocket stream with server-side JWT authentication. Dictated commands are parsed into precise graph operations (create, link, focus, condense, delegate). Strict Graph Guardrails: The engine validates returned IDs and field types against the real, live vocabulary of your graph before displaying a proposal. If a model invents an ID, it is blocked on the server. Hybrid Engine & Smart Caching: Features a two-tier cache (exact contract hash + semantic cosine similarity) that avoids recomputing duplicate prompts, saving tens of thousands of tokens while serving accurate cost metrics. Lossless Condensation: Complex subgraphs can be collapsed into macro-nodes with full lineage tracking, preventing visual pollution without losing underlying connections.
30 Sep 2026
