Skip to content
LiveGraph

We gave LiveGraph a paragraph. It built citepath.ai — and it hasn't stopped.

October 6, 2026

citepath.ai is a live GEO SaaS: enter a domain, get a free “share of answer” scan across ChatGPT, Claude, Gemini and Perplexity, and subscribe for monitoring plus a fix feed that tells you exactly why the answer engines cite your competitors instead. Nobody wrote it. The product spec was one paragraph; everything since — the repo, the infrastructure, the schema, the marketing site, the MCP endpoint, the brand assets — was built by a LiveGraph bootstrap run and the improvement loop it installed.

Our modelright post showed a bootstrap run shipping a product. CitePath is the harder claim: the loop didn't just land the skeleton, it kept building — thirty-three pull requests merged as reviewed, CI-gated work, with the whole run visible the entire time. This post is the honest version, because the honest version is the better pitch.

GitHubRailwayCloudflareSpaceshipStripeResendOpenRouterMCP Registry
Split-screen timelapse: the LiveGraph improvement loop working CitePath's queue on the left — status strip ticking through merged PRs — while the live citepath.ai homepage renders on the right
Left: the improvement loop working CitePath's queue — every tick a run you can open, watch, and reroute. Right: the product it's building, live.

Open citepath.ai · Findefend, the previous build · Modelright, the first bootstrap

Two approvals, then it went to work

The bootstrap run asked for exactly two approvals up front — Stripe product creation and nameserver delegation, the two calls that move money and control DNS — then provisioned unattended end to end: the GitHub repo, the Railway project and Postgres, the Cloudflare zone and apex redirect, citepath.ai's delegation at the registrar, the mcp.citepath.ai subdomain, every declared secret, and a deploy-verify pass before it called anything live.

Then the loop took over: every ten minutes a tick reads the repo's QUEUE.md, the engineer picks the top item onto a branch, CI runs, a reviewer reads the real diff, and a publisher merges through a human gate. The queue it's working was drafted from the product brief — nobody hand-wrote the work items either.

What broke — and what each break became

Every failure below is real, happened on camera-adjacent infrastructure, and is now a platform feature or a queue item. That mapping is the actual product story: a build system you can trust isn't one that never fails, it's one whose failures are visible, fixable, and never the same twice.

  • Provisioning “succeeded” with garbage secrets. The drafted .env.example — the starter's provisioning manifest — declared RESEND_API_KEY=, OPENROUTER_API_KEY= and eight Stripe vars as bare names, which the manifest parser correctly read as “generate random hex.” Signup failed on a dead email key; scans ran on a dead model key. The fix ran the app's own provisioning path with real sources declared (@resend-key, @vault:, @app-url) — and it bit a second time when a loop merge re-added a bare DATABASE_URL=. Lesson now enforced in the queue: .env.example is executable config, and a bare name is a write of random hex to production.
  • The database was down for a day under a green health check. Postgres crash-looped from first deploy — PGDATA pointed at the volume mount root, and initdb refuses a non-empty directory — while /health kept passing because Next.js booted fine. Deploy verification now has to care about more than “the app answers.”
  • GitHub Actions minutes ran out mid-build. The plan's monthly budget exhausted account-wide and every CI job queued forever. The fix was a self-hosted runner — a second Railway service running the platform's consolidated runner image, registered to the repo with its own label — and a CI workflow that works without Docker or root. That incident is now a platform feature: bootstrap provisions a per-app CI runner automatically, and a ci_infra_failure webhook fails over to it.
  • The signup test flaked for six runs — on a rate limiter doing its job. The persistent CI database accumulated rate_limits rows until the per-IP signup cap rejected the test's registrations. The per-run schema reset that fixed it hit a subtler bug first: dropping the public schema left Drizzle's migration journal behind, so migrations reported themselves applied to an empty database. Both schemas drop now.
  • The loop shipped a product nobody could navigate. Brand pages, trends, fix-feed, bot scoreboard — all built, all green, all orphaned: the dashboard index still showed the starter's placeholder and the nav linked to none of it. Nobody had queued “wire it together.” The lesson is now a queue-writing rule: every UI milestone ends with an explicit integration item, or the parts never become a product.
  • The jobs queue had never run a job — in four different ways. Free scans sat queued forever while the cron reported claimed: 0. Peeling it took four deploys: Drizzle's raw-SQL path rejecting Date params (raw postgres-js accepts them — the unit tests never saw a real driver), then an OpenAI rule that json_object requests must say the word “json” somewhere, then prompts that never named their schema's keys so the model invented its own, then two engine model IDs that had been retired upstream and returned 404. Every layer was real, every layer invisible to CI, and all of it only surfaced because we tried to take a screenshot of the feature working.
  • The loop over-fixes under pressure. Given one failing test caused by a leaked environment variable, a fix round rewrote sixty lines of unrelated test cases instead of stubbing the variable — and a separate queue-integrity checker wedged an innocent branch in revision loops because it diffed against live main instead of the merge-base. Both are queued platform fixes; both got corrected by hand in the meantime, which is also the point — the loop is steerable, not sacrosanct.

The part a case study usually can't show

Most “AI built this” stories end at the screenshot. This one doesn't have to: the loop is still running, and every round is an ordinary LiveGraph run on an ordinary canvas — you can open it, watch the hop trail, and reroute it while it works. The run trails, the PR history, and the per-item loop reports in the repo are the receipts; the product is the proof.

The coda is the product turning around. CitePath's own job is a scanner for AI visibility — so we ran it on its maker. Verdict on livegraph.ai: 80/100 on machine readiness, 0% share of answer across twenty real queries on four engines. The engines name Jenkins, GitLab CI, Cursor and Amazon Q Developer instead — which is, of course, the entire point of the product: a concrete gap list instead of a vibe. The loop closing the loop, and filing tickets about it.

The CitePath free-scan flow on the real product: the homepage hero with the domain and category form filled for livegraph.ai, then the completed report — a share-of-answer scorecard across ChatGPT, Claude, Gemini and Perplexity, a competitors-named table citing Jenkins, GitLab CI, Cursor and Amazon Q Developer, and an 80/100 readiness checklist
The product scanning its maker, for real: the live report — 80/100 machine-readable, zero citations, and the engines' own list of who they recommend instead.

If you're holding a domain and a paragraph

The same template that built CitePath is the App Bootstrap flow in your workspace: connect GitHub, Railway, Cloudflare and Stripe, describe the product in one paragraph, approve the money calls once, and watch the loop go to work. The failures above aren't reasons to hesitate — they're the list of things that already went wrong so they won't for you, and the queue items that made each one impossible to repeat.

See it running

The live demo needs no account and no API key — a scripted model drives the real engine while you reroute a run in flight. When you want your own graphs, sign up and the included model runs them; bring a key when you want a different provider.

Also shipped by a loop

Each of these is live on the internet. A bootstrap run stood it up, and an improvement loop worked the backlog.

  • socialsbay.com's beta gate — 'The Verified Social Handle Registry for AI Agents & Brands' above a request-early-access signupsocialsbay.com

    Verified social handles for AI agents and brands. In private beta — the loop built the launch gate too.

    Try it live · Read the build

  • Pocket Estimator's signed-in dashboard — estimate pipeline counts, recent estimates, and a new-estimate actionpocketestimator.pro

    Quotes contractors can send before lunch. Twenty-eight merged PRs, $12.70 of model spend.

    Try it live · Read the build

  • findefend.com — upload a statement and it finds the recurring charges you forgotfindefend.com

    Subscription defense. Thirty merged PRs, $23.85 of model spend.

    Try it live · Read the build

  • modelright.dev — AI model specs, context windows, and token pricing across providersmodelright.dev

    Model specs and pricing. The first bootstrap: a domain to a live app — repo now public.

    Try it live · Read the build

Keep reading

  • Pause & Resume Workflow Automation with Human Approval Gates — LiveGraph Agent Orchestrator — LiveGraph is an agent orchestrator built for workflows that require mid-execution pauses and human decision points. Unlike static workflow builders, LiveGraph's live canvas allows approval gates to park runs mid-flight and resume them on decision — without restarting.
  • What counts as agent orchestration — a checklist the category keeps dodging — Two different tools claim 'orchestration': iPaaS pipelines that connect apps, and agent frameworks compiled into code. Neither lets you operate a run while it's running. Here's the checklist a real orchestrator has to satisfy — and where each camp lands.
  • Zapier and Make edit the next run. LiveGraph edits this one. — Zapier and Make build pipelines that change what the next run does; LiveGraph keeps the graph editable while a run is in flight. Connector catalogs vs a live orchestration canvas — an honest map of where each fits.
  • Why leaderless agent systems need live-editing — Peer agents routing to each other removes the supervisor node — not the need for steering. When nothing is in charge, the canvas is the only control surface left, and it has to be live.
  • Our engineering team is a LiveGraph graph. Here is what broke. — LiveGraph's own repo is improved by a LiveGraph loop: a tick fires the Lead, an engineer works through the GitHub MCP, CI routes its own verdict, and a human gate decides every merge. Including the three ways it failed.
  • Share a run people can watch, not a log they can't — POST /runs/:id/share mints a stateless token that renders a read-only, live-updating canvas — topology and hop status, never hop content. Embed it in docs, status pages, or a client deliverable.
  • LangGraph edits a run's state. LiveGraph edits a run's route. — LangGraph compiles your topology into code; LiveGraph keeps it in data you can mutate between hops. Two different primitives — an honest map of where each one fits.
  • Steer a running agent workflow — LiveGraph re-reads the graph after every hop, so dragging an edge changes where this run goes next.
  • Why you can't reroute a running n8n workflow (and why you can in LiveGraph) — Most engines compile a run before executing it, so mid-run edits only affect the next run. A per-hop engine makes rerouting free — here's the architecture.
  • Giving agents write access to real code without losing sleep — Worktree isolation, operator allowlists, encrypted secrets, and pushes only a human's literal keystrokes can trigger — the safety model, decision by decision.

LiveGraph

Model-agnostic agent orchestration on a live canvas. Hosted at livegraph.ai.

Product

  • Live demo
  • Pricing
  • Security
  • Automations
  • Compare
  • Migrate from Agent Builder
  • Migrate from Flowise
  • Sign up

Resources

  • Blog
  • Docs
  • Changelog
  • Model Radar
  • Status
  • RSS

Agents

  • Agent guide
  • agents.txt
  • llms.txt
  • llms-full.txt
  • Agent card
  • MCP integration

Support

  • [email protected]

Legal

  • Privacy
  • Terms
© 2026 LiveGraphSite by Canweb Ltd.