Watch the machine think
▸ CONTACT FOR MORE INFORMATIONReasoning you can navigate
What the Engine does, where I fit, and the three interaction decisions that make a long-running AI legible. Then one of its agents, thinking, below.
The Futurity Engine answers one research question with a small army. You ask something like "how close are solid-state batteries to displacing lithium-ion", and a five-phase pipeline pulls papers, patents, organizations and press out of Futurity’s knowledge network, computes signals over the evidence, and sets ten domain agents loose on the question. Every step streams to the browser over Server-Sent Events and lands in a live knowledge graph with more than 25 node types. You watch the system think while it thinks.
The Engine was our CEO’s idea. I gave it its first form: a working prototype of the UI concept, a collapsed version of what is now a massive node graph. That prototype settled the core interaction bet early: agent reasoning should be a graph you can navigate, not a wall of logs you scroll.
From there I built the frontend alongside the team. The visual system is mine: the theme architecture, the shape and color grammar that makes node types readable at a glance, and most of the report, publishing and chat surfaces. So are the streaming designs the team built against, incremental graph ingest with no rebuilds, and the heartbeat liveness contract I wrote for the backend before the backend emitted it.
A run starts from a question, or from a lab: a curated taxonomy of subjects built in FAST. The Engine pulls everything connected to those subjects from the knowledge network, then computes a layer of signals over the pool. Research velocity, patent concentration, citation momentum, whitespace. Each signal keeps pointers to the exact papers behind it, so no claim floats free of its evidence. Then the agents run. Each one researches, turns around and attacks its own findings in a critique round, and a synthesis pass folds all ten analyses into a report with scenarios, confidence scores and receipts.
Runs are long. Minutes at best, hours on a big lab. So the system is honest about time: every phase checkpoints, an interrupted run resumes without re-running finished agents, and the interface knows the difference between working quietly and being stuck.
A graph, not a log
Every entity the pipeline touches becomes a typed node. Subjects are hexagons, signals are diamonds, and every claim keeps an edge back to its evidence. The noisy machinery arrives hidden, so the picture stays legible while staying complete.
Incremental everything
Nodes stream into the graph without full rebuilds, so the layout never shifts under a cursor mid-exploration. On saved reports the heavy map is lazy-loaded on request, and the report stays responsive without it.
Honest liveness
Some steps run ten minutes without an event. The status system tells the truth in three states: events flowing, quiet but alive, actually stalled. The heartbeat contract behind it is one I wrote for the backend before the backend emitted it.
The Engine runs today as a Dockerized multi-service stack with resumable checkpoints, and the frontend stays responsive through runs that take the better part of an hour. It is the clearest statement of the thesis that runs through all my work: an AI system earns trust when its process is legible.
The Engine is client software, so there is no public build to poke at. Everything on this page is a recreation built for the portfolio, on synthetic data. If you want to know more about the work, get in touch.
▸ CONTACT FOR MORE INFORMATION
TRUST IS EARNED IN THE TRANSCRIPT.
NEXT ▸ carlton_dev
this site, built as a live patch