Atlas Research Lab.
Watch the research happen.
An open multi-agent research laboratory in which a planner, a researcher, a skeptic, an analyst, and a replicator carry a visitor's question through a six-stage run that can be paused, replayed, and audited line by line.
Can verification-focused agent roles make autonomous research easier to inspect and eventually more reliable?
Most autonomous research tools present a finished answer and hide the work. Atlas takes the opposite position: the interesting artifact is the run itself — who proposed what, who challenged it, what survived replication, and what was discarded along the way.
The wager is that separating research labour into bounded, verification-focused roles — a planner, a researcher, a skeptic, an analyst, and a replicator — makes an autonomous run observable in a way that a single undifferentiated assistant never is. Observability is the precondition for reliability, not a substitute for it.
Six versions, each one a correction to the last.
Atlas was not designed once. It was revised in public-facing increments, and each increment fixed a specific failure of legibility observed in the version before it. The log below is the design history in the order it happened.
- V0 · ConceptFrom decision systems to a research laboratory
Atlas began as a move beyond small, single-purpose decision systems toward an open multi-agent research laboratory. The first decision was the role taxonomy: planner, researcher, skeptic, analyst, and replication — verification split out as its own labour rather than folded into a single model's self-assessment.
Correction → Named the roles before designing any interface.
- V1 · Evidence DashboardSerious, but not observable
The first build was a dark scientific dashboard with an evidence graph, a live trace panel, and one fixed research question about NYC tree canopy and heat equity. It communicated seriousness, but it looked too similar to another project in this portfolio, and playback changed too little on screen to feel like anything was actually happening.
Correction → Legibility failure: a trace that scrolls is not a run you can watch.
- V2 · Research StudioA room instead of a dashboard
The palette was rebuilt in cream, coral, sky blue, yellow, lavender, and mint, and the five abstract roles became five mascot agents physically working inside a 3D-style studio. The metaphor shifted from telemetry to laboratory: agents occupy space, hold tools, and stand where their work is happening.
Correction → Gave each role a body so its contribution has a location.
- V3 · Observable WorkflowSix stages with visible movement
Playback expanded into six named stages — Briefing, Gathering, Challenging, Analyzing, Replicating, Outcome — with mascots moving between stations, picking up action tools, and a result that appears only after replication has completed.
Correction → Withheld the outcome until verification, so sequencing carries meaning.
- V4 · Auditable InteractionOpen Full Trace becomes real
Open Full Trace was converted from a decorative label into a complete modal audit log of the entire run. Pause, replay, restart, and stage navigation were added, and action bubbles were repositioned clearly above the mascots so no utterance is obscured by the studio itself.
Correction → Made the record inspectable at rest, not only in motion.
- V5 · Visitor-Authored QuestionsThe visitor sets the agenda
The fixed NYC question was replaced with a composer. Board themes, the trace contents, and the bounded recommendation now adapt to whatever the visitor asks, and explicit simulation labels were added throughout so no adapted output is mistaken for empirical research.
Correction → Adaptivity without labels would have been a credibility hazard.
Five bounded roles, five mascots, one shared run.
Each role is deliberately narrow. Narrowness is what makes a contribution attributable: when a claim is wrong, the run shows which role produced it and which role failed to catch it.
Decomposes the visitor's question into a bounded research plan and assigns what each subsequent role is responsible for.
Gathers material against the plan and stages candidate findings for challenge rather than presenting them as conclusions.
Attacks the weakest link in each candidate finding: scope, sourcing, and the leap from observation to claim.
Reconciles what survived the challenge into a structured reading, holding on to residual uncertainty instead of smoothing it away.
Re-runs the analytical path independently; the outcome is withheld from the visitor until this role reports.
A skeptic that cannot block a claim is decoration. The role only means something if the run visibly changes when it objects.
Six stages, then the trace.
A visitor writes a question into the composer. The studio then plays the run through six named stages, with the mascot agents physically moving to the tools they are using. The outcome does not appear until replication has run — the sequencing is the argument.
- Stage 01BriefingPip converts the visitor's question into an explicit plan with scope and success conditions.
- Stage 02GatheringScout collects candidate material and stages it in the studio for review.
- Stage 03ChallengingMochi objects on the record; weak claims are visibly withdrawn or narrowed.
- Stage 04AnalyzingByte assembles surviving material into a structured reading with stated uncertainty.
- Stage 05ReplicatingDot re-derives the reading independently to test whether it holds up.
- Stage 06OutcomeA bounded recommendation appears — only after replication, and always labelled as simulated.
Open Full Trace opens a complete modal audit log of the run: every stage, every action, every agent utterance, in order. Playback can be paused, replayed, restarted, or navigated stage by stage, so a reader can stop on a single moment and read what was actually claimed there.
React state as the laboratory clock.
The run is a deterministic state machine in React: stage index, agent positions, active tools, emitted claims, and trace entries are all derived from a single typed run model, which is what makes pause, replay, restart, and stage navigation trivial rather than special-cased.
TypeScript types the run model end to end — stages, roles, actions, and trace records — so that adding a stage or a role forces every consumer to account for it. The studio and the five mascots are built entirely in CSS: no sprite sheets, no 3D engine, no video. That keeps the payload small and the animation inspectable in the DOM.
The app is built with vinext on Vite and deploys to a Cloudflare-compatible edge runtime, matching the rest of the lab's deployment model.
The entire run is one typed state machine; pause, replay, restart, and stage navigation are reads of that state, not separate code paths.
Stages, roles, actions, and trace records are typed end to end, so adding a stage or a role forces every consumer to handle it.
The 3D-style room and all five agents are built in CSS — no sprites, no engine, no video — keeping the animation small and inspectable in the DOM.
Built with vinext on Vite and deployed to a Cloudflare-compatible edge runtime, matching the rest of the lab's deployment model.
Atlas-100: what would make the thesis testable.
Nothing below has been measured yet. Atlas-100 is a proposed benchmark of one hundred research questions with known, checkable answers, designed so that the roles can be evaluated rather than merely demonstrated. The metrics and ablations are research targets.
Proportion of cited sources that genuinely support the statement attached to them.
Proportion of asserted claims that are traceable to gathered material rather than inferred silently.
How often the replicator independently reproduces the analyst's reading.
Whether stated confidence tracks empirical accuracy across the benchmark set.
How much of the plan's stated scope the run actually addressed.
Compute and wall-clock cost of the role separation relative to a single-agent baseline.
- Remove the skepticMeasures how much unchallenged material survives to the outcome when nothing objects on the record.
- Remove the replicatorTests whether withholding the outcome until independent re-derivation changes reliability or only perception.
- Remove shared memoryIsolates how much of the system's coherence comes from a shared run record rather than from the roles themselves.
- Remove role separationCollapses all five roles into one undifferentiated agent — the baseline the opening thesis is arguing against.
The failure modes this design invites.
- No live browsing or source verification
The public release does not retrieve or verify live sources. Anything that resembles a citation is interface content within a simulated run.
Mitigation → Simulation labels are shown persistently in the interface, and an evidence-grounded retrieval layer is the first item on the build roadmap.
- Heuristic domain classification
The visitor's question is routed to board themes and framings using heuristics, not a validated classifier, so some questions will be framed imperfectly.
Mitigation → Framing decisions are exposed in the trace so a reader can see — and discount — how the question was interpreted.
- Persuasive animation
A studio of mascots working diligently is emotionally convincing in a way that has nothing to do with epistemic quality.
Mitigation → Outcomes are bounded and hedged, replication gates the result, and the simulation notice sits alongside the animation rather than beneath it.
- Citation laundering
Formatting an unverified statement as a citation can lend it borrowed authority the underlying material never had.
Mitigation → Simulated references are labelled as such, and citation precision is a first-class metric in the proposed Atlas-100 benchmark.
- Overconfidence
A visible verification ritual can make a run feel audited even when nothing was independently confirmed.
Mitigation → Recommendations are deliberately bounded, uncertainty is carried through the analyst stage, and calibration is a planned measurement rather than an assumed property.
A full run, narrated end to end.
A single visitor-authored question carried through briefing, gathering, challenging, analyzing, replicating, and outcome — with the full trace opened at the end.
Prefer a local copy? Download the demo (MP4).
A lab notebook, not a finished claim.
Atlas demonstrates a shape of research automation in which verification is a visible role rather than an implicit hope. It does not yet demonstrate that this shape produces more reliable research — that is what Atlas-100 is for.
Until then, this page and the prototype it documents should be read as a working notebook: a legible architecture, an honest account of what is simulated, and a list of the experiments that would make the opening thesis answerable.