TaskFlow: an agent that plans, executes, verifies — and remembers what it did

TaskFlow (FSA-002) is an autonomous agent framework built on Next.js 15, React 19, and LangGraph. Where most agent demos are a single prompt wired to a single tool call, TaskFlow is structured as a disciplined, typed orchestration loop with persistent memory and thirty files of documented deployment paths — the difference between a weekend proof of concept and something a team could actually run in production.

The problem

Most autonomous agent demos work great for exactly one thing: a single happy-path prompt, run once, in a fresh session. The moment a real task requires multi-step planning, error recovery, or memory that survives across sessions, the wheels come off. Agents either loop forever chasing a goal they've lost track of, or they lose context between runs and repeat work they already finished — because there was never a durable, inspectable record of what the agent actually believed it had done.

The failure isn't usually a crash. It's an agent that looks like it's working — issuing tool calls, producing output — while quietly drifting away from the original goal with no verification step to catch it.

The approach

TaskFlow enforces a strict three-phase loop for every task, rather than trusting a single model call to plan, act, and judge its own work all at once:

• Plan — decompose the goal into a typed task graph before any execution begins
• Execute — run each node in the graph, with LangGraph managing state transitions and retries
• Verify — an explicit verification pass checks the output against the original goal before a task is ever marked complete

That last phase is the one most agent frameworks skip. It's tempting to trust the execution step blindly — the tool call succeeded, so the task must be done — but success at the tool-call level and success at the goal level are different things. Verify is a separate, dedicated pass specifically so those two can't be silently conflated.

Architecture

Under the hood, TaskFlow's orchestration graph is a typed LangGraph — every node and edge has a defined shape, so state transitions between Plan, Execute, and Verify are checked rather than assumed. The codebase is organized across 30 files with a clear separation of concerns: planning, execution, verification, memory, and deployment each live in their own space rather than being tangled together in one monolithic agent loop.

That last concern — deployment — gets the same seriousness as the agent logic itself. TaskFlow ships with 36,000 words of documentation covering three separate deployment targets: Vercel (serverless), Docker (containerized), and a bare VPS. A framework that only runs on the author's laptop isn't a shippable asset — it's a demo. TaskFlow is documented to run wherever a team already deploys.

Results

TaskFlow is complete and fully documented: the three-phase orchestration loop, the typed LangGraph graph, and the deployment paths are all implemented and written up end to end.

Lessons learned

The most interesting decision in TaskFlow wasn't the LangGraph orchestration — it was choosing plain markdown files for persistent memory instead of a vector database. A vector DB would have been the more "impressive" choice on paper. But when an agent's plan goes wrong, what you need most is to be able to open the memory file and read, in plain English, exactly what the agent thought it had done and why it made the next decision it made. A hidden embedding store can't give you that. A markdown file can. Trust and debuggability turned out to matter more than sounding sophisticated.