Skip to content
LiveGraph

We pointed LiveGraph at an empty domain. It shipped a product.

October 2, 2026

modelright.dev is a live registry of AI model specs and pricing — ten providers' worth of context windows, token prices, and availability, queryable and comparable. Nobody wrote it. A LiveGraph bootstrap run created the repository, provisioned Cloudflare and Railway, delegated the nameservers, deployed the skeleton, and installed an improvement loop that then built the product through ten queued work items, each one a reviewed, CI-gated, human-approved pull request.

This post is the honest version of that story — including the parts that broke, because the parts that broke are where the product actually lives.

GitHubRailwayCloudflareSpaceshipOpenRouter
Setting up the App Bootstrap automation: pick the template, the credential preflight checks Cloudflare, Railway, Spaceship, GitHub and OpenRouter, fill in six fields, and the canvas appears ready to run
Where it started: Templates → App Bootstrap → credential check → six fields → the graph exists. From here the run is one click.

One run, then a loop

The App Bootstrap template is a run-once graph: Scaffold → Provisioner → approval gate → Deploy Verify. Scaffold creates the GitHub repo and pushes a Next.js+Postgres skeleton in a single commit — the agents have no filesystem, everything goes through GitHub's API. Provisioner creates the Cloudflare zone, captures the assigned nameservers, delegates them at the registrar's API, stands up the Railway project with app and Postgres services, writes the DNS records, and mints every secret the skeleton declares. A human gate sits before the verify hop — the last checkpoint before the run declares anything live.

Then the part that matters: the bootstrap installs a self-improvement loop on the new repo. Every ten minutes a tick reads QUEUE.md, the engineer picks the top item onto a branch, CI runs, a reviewer reads the actual diff, and a publisher sits behind a human approval gate before anything merges. The product plan was a paragraph. The queue items — the landing page, the compare page, the availability tracking — were written, implemented, reviewed, and merged by the loop.

Timelapse of the actual modelright bootstrap run on the live canvas: Scaffold lights up and completes, Provisioner runs, and the run parks at the Deploy Verify approval gate
The real bootstrap run, sped up: Scaffold → Provisioner → the run parks at the Deploy Verify gate. Nothing is simulated — this is the footage.

What broke, and what that bought

Three honest failures, each now a feature:

  • The queue file got wiped — four times. QUEUE.md is shared state the engineer edits while the base branch moves. A reparent step was once writing it from memory and once merged a stale snapshot clean. The fix wasn't a bigger warning comment: it's a deterministic diff-verification tool (verify_queue_diff) that the engineer, reviewer, planner, and both publishers must call — ok:false is treated as absolute, and a publish-time check now enforces “a QUEUE.md diff is exactly one line.”
  • Deployed ≠ working. The first deploy passed its health check while the page rendered “No models available” — the schema migrations had never run and one required secret was never provisioned. The bootstrap template now ships a skeleton that self-migrates at boot, treats .env.example as the provisioning manifest for generated secrets, and the verify step probes a DB-backed route instead of trusting /health alone.
  • A DNS detail stalled TLS for a day. Railway's custom-domain flow returns verification records — a _railway-verify TXT — that the provisioner was skipping, leaving the domain in VALIDATING_OWNERSHIP. The prompt now applies every record Railway asks for, and subdomain setups reuse the parent zone instead of trying to create one.

Why a graph, not a script

Every hop of that run was visible, interruptible, and steerable while it happened — and the failures above surfaced as markers and parked approvals, not silent state. When the queue file corrupted, we didn't restart a pipeline; we watched the conflict-fix round run, approved the reparented PR, and hardened the machinery the same week. That loop is still running: modelright.dev continues to improve itself on a 10-minute tick, and every merge still parks at a human gate. (The live canvas demo shows the same steer-a-running-graph mechanics on a scripted model — no keys, no spend.)

The Deploy Verify approval gate for the modelright run: the canvas banner, the pending approval card on /approvals with the provisioning summary, approving it, and the run resuming
The human gate, exactly as it happened: the run parks on the canvas, the approval card on /approvals carries the provisioner's step-by-step status, and approving resumes the run.

The same template is what a new user gets: pick App Bootstrap, fill six fields, press “Start the build,” and watch a domain become a self-improving product — with a build-status page tracking every marker the run emits.

Update, October 7 — where the loop took it

Five days later the loop is still ticking, and the queue went from ten items to forty-two done across 52 merged PRs. What modelright.dev gained on autopilot plus a few human-steered rounds: real OpenRouter sync every hour (with removed-model handling), Artificial Analysis benchmarks and speed metrics, a four-way compare page with an interactive picker and SEO-friendly pair URLs, task picks (coding, long-context, vision, cheap-bulk), a changes feed with price-history charts, a public JSON API, an MCP server with six read tools, the full agent-discovery surface (llms.txt, agents.txt, OpenAPI, A2A card), cookieless visitor/bot/MCP analytics, and a token-gated admin dashboard.

The modelright.dev models index: a dark-themed, filterable table of live catalog entries — provider, name, context window, per-1M-token input and output prices, status dots, and sync datesThe modelright compare page: four models side-by-side with context window, input and output prices, cheapest-highlighting, modalities, and a cost calculator
What five days of the loop produced: a live, filterable catalog synced hourly from OpenRouter — and /compare running four flagship models side-by-side with a cost calculator.

The interesting failure mode this week: a CI webhook consumed as STILL_BUILDING never re-armed the reviewer, so a green branch silently parked until a human noticed. When the publish lane stalls, a person lands the PR — which is the approval-gate design working as intended, not a bug in it.

And the headline: the repo is now public under MIT. QUEUE.md, PLAN.md, and the per-item delivery log in docs/loop-reports/ are committed alongside the code — the loop's work product is the sample.

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

  • citepath.ai's brand-visibility scan flow — a domain goes in, AI-answer citation share comes outcitepath.ai

    GEO visibility. Thirty merged PRs; the backlog is down to manual-only items.

    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

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.