1n4NO
All work

Multi-Agent AI System

A research workflow you can inspect while it runs.

Next.js (App Router)TypeScriptMaterial UIReact FlowServer-Sent EventsOllama (local LLM)

Project brief

The product bet, in plain language.

Turned opaque AI research into a workflow with live state, manual checkpoints, reruns, citations, and exportable reports.

Hiring signal

Senior ownership across product framing, scope, and shipped interface quality.

Engineering read

Focus on constraints, architecture choices, external systems, and data flow.

Role
Frontend architecture, agent workflow design, product UI, and local inference integration
Scope
Goal intake, planner review, researcher orchestration, live graph state, critic loop, and final report export
Core constraint
The system had to feel transparent and useful while running entirely on local LLM infrastructure.
Technical bet
A streamed, checkpointed agent graph would earn more trust than a plain chat window.
Drag to scrub
Multi-Agent AI System full-page run state in dark mode
Run state — dark mode
Multi-Agent AI Researchers and Agent Thoughts panels in dark mode with Continue enabled
Researchers and thoughts — dark mode
Multi-Agent AI full-page research progress state in dark mode after clicking Continue
Full research progress — dark mode
Multi-Agent AI System full-page run state in dark mode
Run state — dark mode
Multi-Agent AI Researchers and Agent Thoughts panels in dark mode with Continue enabled
Researchers and thoughts — dark mode
Multi-Agent AI System full-page planner review state in dark mode with Continue enabled
Planner review — dark mode
Multi-Agent AI Researchers and Agent Thoughts panels in dark mode while researchers are in progress
Research in progress — dark mode
Multi-Agent AI completed workflow in dark mode with final output and active Export PDF button
Final workflow output — dark mode
Multi-Agent AI System full-page planner review state in dark mode with Continue enabled
Planner review — dark mode

Overview

A guided multi-agent research assistant. You give it a goal, a planner breaks the work into stages, a research router grounds each step in web or reasoning, and a writer/critic loop turns the result into a cited report on local Ollama inference.

Problem

Most AI research demos are just one opaque model call. You can't see what's happening mid-run, you can't pause it, and you end up paying a hosted API for work that could run locally.

Approach

I broke the pipeline into five visible stages — planner, research router, researchers, writer, critic — and built the frontend around a React Flow graph so each step stays visible while it runs. Server-sent events keep the UI in sync with real state instead of a fake progress bar.

Project method

Detailed process

Requirements

The starting requirement was not another chat interface; it was a transparent research workflow where a user could see how an answer was being planned, grounded, rewritten, and critiqued. That pushed the scope toward inspectable stages, manual checkpoints, rerun states, and citations rather than a single prompt-response screen.

Stack choices

Next.js App Router handled the product shell and streaming API routes, React Flow made the agent graph legible, and Material UI provided dense controls quickly. Ollama was chosen deliberately so the core promise could be local inference with no paid model dependency, while Server-Sent Events kept the run graph synchronized without the complexity of a bidirectional socket protocol.

MVP definition

The MVP was defined as one complete goal-to-report loop: planner, research router, editable researchers, synthesizer/writer, critic, and citation-aware output. Features that did not prove that loop, such as persistent multi-user memory or configurable remote model pools, were left for later.

Progression

The project moved from a linear orchestrator to a checkpointed pipeline. Once planner output existed, the next critical step was making stale research visible and rerunnable before synthesis, so the UI evolved around graph state, pause/continue controls, and review modals instead of a passive progress indicator.

Takeaway

Solution

The result is a pipeline you can follow: planner → router → researchers → writer → critic, with rerun badges for stale outputs, pause/continue controls, and no paid API in the loop because inference runs on Ollama.

Evidence

Highlights

04 signals
  • 01Live execution graph built with React Flow and streamed over server-sent events
  • 02Checkpointed pipeline with pause / continue and manual review at each stage
  • 03100% local inference via Ollama — no API key, no per-call cost
  • 04Cited report generation with a writer/critic loop

Screenshots

Open channel

Need a sharper frontend path?

Architecture, AI workflows, design systems, and interfaces that need to hold up after launch.