Flowtrace
Write end-to-end tests in plain English — an AI agent runs them, watches the page, and heals them when the UI changes.
Why I built this
End-to-end tests are the ones teams need most and maintain least. You write a selector-heavy script, a designer renames a class or moves a button, and the test goes red — not because the product broke, but because the script did. So teams stop trusting E2E, stop writing it, and ship with a thinner safety net than they think. I wanted to flip the brittle part. A test should describe intent — "log in, add an item to the cart, check out" — and something else should figure out how to carry that out on the actual page in front of it. That "something else" is exactly the kind of agent I build day to day: give it tools, let it observe state, let it recover. Flowtrace is me turning that agent pattern on testing itself.
About
Flowtrace is an open-source platform for writing and running end-to-end tests in natural language. You describe a flow in plain English; a LangGraph agent plans it, drives a real browser with Playwright, and reasons step by step about what it sees on the page. When the UI shifts — a renamed button, a moved field, a slow-loading element — the agent adapts instead of failing on a stale selector, with layered self-healing for recovery. Every run produces a visible reasoning trace, so you can inspect exactly how the agent decided to act rather than staring at an opaque pass/fail. It ships with both a CLI and a web dashboard, and works across multiple LLM providers.
Features
- Plain-English test cases — no selectors or test code to maintain
- LangGraph agent that plans and executes each flow autonomously
- Self-healing runs that adapt to UI changes instead of breaking
- Visual reasoning trace to inspect every decision the agent makes
- Playwright-based cross-browser automation
- Multi-provider LLM support (Anthropic, OpenAI, Gemini, Ollama, OpenRouter)
- Both a CLI and a web dashboard
Tech Stack
The problem with E2E tests
Most end-to-end tests fail for the wrong reason. The product works fine, but a class got renamed, a button moved, or an element loaded a half-second late — and a selector that was hard-coded months ago no longer matches. The test goes red, someone spends an afternoon fixing the script rather than the software, and slowly the team stops trusting E2E altogether. Flowtrace exists to remove the brittle layer: you describe what the test should accomplish, and an agent works out how to do it against the page as it actually is right now.
How it works
You write a test as a sentence — for example, "sign in, add the first product to the cart, and complete checkout." A LangGraph state machine turns that intent into a plan and runs a ReAct-style loop: observe the page, decide the next action, act, observe again. The agent drives a real browser through Playwright and has a focused toolbox to work with — navigating, acting on elements, extracting values, observing structure, asserting outcomes, taking screenshots, inspecting the page, and waiting — so each step is grounded in what is genuinely on screen rather than a brittle, pre-recorded selector.
Self-healing instead of red builds
Because the agent re-reads the page on every step, a renamed button or a relocated field is just a new observation, not a failure. When an action does not land, layered healing logic lets it re-observe, re-plan, and try a different path to the same goal before giving up. The result is a test suite that bends with normal UI churn and only fails when the behaviour it is checking is genuinely broken.
A trace you can actually read
The hardest part of any autonomous agent is trust — a green or red light tells you nothing about why. Flowtrace records the agent's reasoning as it goes, so for every run you can replay the decisions: what it saw, what it chose to do, and where it had to heal. That visible trace is the difference between an agent you debug and an agent you cross your fingers over.
Architecture
Flowtrace is a Turborepo monorepo split into focused packages: a Next.js dashboard for managing and monitoring tests, a Playwright-based agent for browser control and artifact capture, a core LangGraph engine that holds the state machine and ReAct loop, a multi-provider AI layer that lets you swap between Anthropic, OpenAI, Gemini, Ollama, and OpenRouter, a CLI for running tests from the terminal, and a SQLite persistence layer via Drizzle. Keeping the engine, the browser agent, and the model layer as separate packages means each can evolve without dragging the others along.