Skip to content
LiveGraph

The loop built its own launch gate — socialsbay.com, failures included.

November 5, 2026

socialsbay.com is the verified social-handle registry for AI agents and brands: a brand claims its domain, proves ownership with a DNS TXT record or meta tag, and gets a public directory page plus a REST — and soon MCP — lookup that returns its official handles. No agent has to guess which @acme is real. It runs on Cloudflare Workers with a D1 database, and every line of it was written by a LiveGraph improvement loop working a QUEUE.md — two dozen reviewed, CI-gated pull requests and counting.

Visit it today and you won't reach the product — you'll reach a beta gate asking for your email. That gate is part of the story: the owner asked for it mid-build, the loop shipped it, and the pattern is now a starter feature every bootstrapped app gets. This is the first dogfood where the interesting part isn't that it worked — it's how the loop absorbed everything that didn't.

GitHubCloudflareGoDaddyOpenRouter
socialsbay.com's live beta gate: 'The Verified Social Handle Registry for AI Agents & Brands' above a request-early-access email form
socialsbay.com is in private beta — the gate collecting early-access emails is itself one of the loop's merged PRs.

A new deploy target's first real run

SocialsBay is the first app bootstrapped onto the Cloudflare Workers deploy target — a vinext/Next.js starter on Workers, D1 for data, and a GitHub workflow that runs wrangler deploy on every merge to main. The Provisioner stood it all up, and immediately hit the edges only a first real run can find:

  • The registrar credential couldn't be tested until it failed. Mid-run, the Provisioner reported “DELEGATION: pending — GoDaddy credential unavailable” and parked; the owner set socialsbay.com's nameservers by hand. There was no way to know the key was bad before a run depended on it — now every stored credential has a live “test connection” probe, GoDaddy included, and Settings can catch a bad key before a bootstrap does.
  • Green deploys were serving 1019s. The build stayed green through three fix attempts while the deployed Worker had no real fetch handler — nothing in the pipeline ever sent it a request. Each wrong guess cost a full cycle. The starter's deploy job now smoke-tests the Worker it just shipped, so “deployed” means “answered a request,” not “wrangler exited zero.”
  • A D1 permission gap failed deploys for ~8 hours — and merges kept landing. The loop kept producing reviewed PRs against a main that couldn't deploy: false progress, invisible until a human went looking. Now a persistent stale deploy halts the loop's merge lane and escalates with the failing workflow named — the loop stops instead of piling up unshipped work.

The stalls were legible, not silent

The strongest beat of this build isn't a feature — it's that every failure surfaced as a state you could read, and most became platform fixes within the day:

  • The model credit ran out mid-incident. A manually-fired fix round died at its Lead hop on HTTP 402 — Prompt tokens limit exceeded — the bootstrap-provisioned OpenRouter key was exhausted, and every downstream lane was dead until a human raised the limit at openrouter.ai. The engine now classifies a credit-limit 402 distinctly and stamps the automation stalled with the provider-specific remediation, instead of treating it as an ordinary hop error.
  • The CI webhook had never fired. The graph's github-events trigger sat enabled with zero deliveries since bootstrap — the whole loop was carried by its 10-minute schedule, and a null last_triggered_at looked identical to a quiet CI day. Webhook delivery health is now a first-class signal: zero deliveries while matching CI runs exist shows as degraded with the likely causes named.
  • Four parallel review rounds wedged at once. Four concurrent runs died on the hop watchdog — a worker wedged on an await — and sat errored until manually resumed. The engine knew exactly what happened and even told the operator to resume; the fix in flight auto-resumes a wedged hop once before failing the run for real.
  • A revision hop outgrew its step budget. A NEEDS_REVISION → Engineer hop spent 27 tool calls just re-reading files through the GitHub MCP, then died at the step limit mid-investigation. MCP-only loop lanes are getting batched reads and a real continuation path — the interesting part is the boundary it exposed: the step cap is reachable precisely when the work is real.

The reviewer earned its keep

Review rounds weren't ceremony. The NEEDS_REVISION lane sent real work back — and the queue picked up bugs no review had been pointed at: the claim-status vocabulary was split-brained across the codebase (the admin wrote 'approved' while every public query read 'verified' — an approved brand would never have gone live), caught and fixed as its own queue item with a migration for existing rows. The revision lane's only failure was mechanical: re-establishing context cost more tool calls than the hop was allowed — which is why the step-limit fix above exists.

The plan changed mid-flight — twice

Mid-build, before public launch, the owner decided the whole site needed gating behind a teaser — not just admin auth. The in-flight round was cancelled, the new item went to the top of the queue, and the loop shipped it: a layout-level beta gate covering every route, an email-collect form backed by a new D1 table, a timing-safe bypass token for preview links, and a flag flip that opens the unchanged site when launch day comes. Then the lesson travelled back into the platform — the launch-gate pattern is now an opt-in starter kit, so the next bootstrapped app can gate its pre-launch the same way instead of re-deriving it.

And when the backlog thinned, the queue refilled itself: the loop filed its own follow-ups in the same QUEUE.md format — a shareable beta-bypass preview link, first-party analytics with no external SaaS, an admin view for the signups the gate was collecting, a top-100 brand seed — and filed the launch item (“disable beta gate”) deliberately last, since the loop works the queue top-to-bottom and reaching it means everything above it shipped.

The product is real, too

Under the gate there's a working product: a public brand directory with search and platform filters, a three-step claim flow (submit → place the DNS token → verified page), a public resolve API with rate limiting and bulk export, first-party analytics, and an admin console — all behind the same beta wall until launch. The pitch isn't that a loop can ship a SaaS — it's that the hard week was legible. Every incident above surfaced as a parked gate, a skip reason, or a needs-you row, and most produced a platform fix that makes the next app's run smoother. Pick App Bootstrap in Templates and watch a domain become a self-improving product — or request early access and let the gate collect you.

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.

  • 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

  • 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.