DEV Community: Sean

I built a no-code multi-agent orchestration platform — parallel execution, targeted feedback, runs in your browser

Sean — Mon, 29 Jun 2026 04:11:23 +0000

The problem with most agent builders

They're sequential. They fail without recovery.
They require code. They route your data through
their servers.

Parlance is built to fix all four.

What it is

A free, open-source, no-code visual workspace
for orchestrating multi-agent Claude workflows.
Build on a canvas, connect nodes with edges,
run with real API calls.

What the engine actually does

Parallel execution
Modified Kahn's algorithm computes topological
waves. Each wave dispatched with Promise.all.
A→B→C runs sequentially. A and B feeding into
C runs A and B simultaneously, then C. Automatic.

Three-tier retry
Self-retry → upstream escalation → Overseer
intervention. When an agent fails, the engine
tries to resolve it without user input.

Targeted feedback
Overseer evaluates output against your conditions.
On rejection: parses TARGET: [agent name], re-runs
only that agent and its downstream forward chain.
Agents upstream of the fix point untouched. Cost
savings proportional to where in the chain the
problem is.

Workflow chaining
Chain Input nodes pull output from other Parlance
workspaces. Optional caching avoids re-running
expensive upstream workflows.

Architecture

1,258-line execution engine (orchestrator.js, runEngine.js, claudeClient.js, mockClient.js, engineEventBridge.js)
React 19 + ReactFlow canvas
Single useReducer, 26 pure-function action types
Backend: 3 Vercel serverless functions (CORS proxy only — all orchestration runs client-side)
BYOK — key in localStorage, sent per-request, never written server-side

56 source files. 8,310 lines. MIT licensed.

The full suite

This is the fifth tool built in two weeks.
All free, all open source, all BYOK:

Reality Check: realitycheck-project.vercel.app
Singularity: singularity-workspace.vercel.app
LoopLens: looplens-project.vercel.app
Claude Batch: virerra.github.io/Claude-Batch
Parlance: parlance-project.vercel.app

Links

Live: parlance-project.vercel.app
Source: github.com/Virerra/parlance
License: MIT

I built a paced Claude API queue in a single HTML file — 29 tests, 10 bugs found and fixed

Sean — Sun, 28 Jun 2026 10:44:55 +0000

The problem

Rate limits on bulk API work are painful. You
start processing a spreadsheet row by row, hit
a 429 after a few requests, wait, continue,
hit it again. You end up babysitting an API
for hours.

What I built

Claude Batch is a paced request queue in a
single HTML file. No build step, no npm install,
no server. Open it in a browser and it works.

Two input modes:

Type prompts (one line = one request)
Upload CSV/Excel and write a {ColumnName} template — one request per row, only the columns you reference get sent (typically 70–80% fewer tokens)

Set an interval (1–180s), press Start, walk
away. Exports as JSON, CSV, or plain text.

Engineering details

Retry with exponential backoff (2s, 4s, 8s, cap 20s)
Respects retry-after header — server guidance overrides calculated backoff
AbortController on every fetch — cancels the actual HTTP connection on Stop
504 in the retryable set (gateway timeouts are transient)
sleepAbortable() polls isRunning every 100ms during backoff — Stop resolves immediately
29 tests across 95 assertions in a jsdom harness that loads the actual index.html and drives real UI events

10 real bugs found and fixed

Every bug has a regression test:

No retry on 429s — fixed with backoff logic
Timer leak on repeated start/stop — fixed with tracked setInterval
Stuck processing row after Stop — fixed with status reset sweep in stopRun()
Clear All orphaning in-flight rows — fixed by disabling during run
retry-after header ignored — now read and respected
No AbortController on fetch — added
504 missing from retryable set — added
Draggable state not synced with isRunning
stopRun() only re-rendered conditionally
Dead code currentRowTimer — removed

Links

Live: virerra.github.io/Claude-Batch
Source: github.com/Virerra/Claude-Batch
License: MIT

I built a pre-run cost simulator for agentic loops — 13 models, zero API calls, works offline

Sean — Sat, 27 Jun 2026 08:56:32 +0000

The problem

Agentic loops compound costs in ways that aren't
obvious until the bill arrives.

Iteration 1: $0.19. Iteration 30: $2.48. Same
agent, same task — the model re-reads full context
on every turn. By iteration 20 you're paying for
the same context 20 times over.

What I built

LoopLens is a pre-run cost simulator. Configure
your loop before you run it and get a full
per-iteration breakdown.

What it models:

4 context accumulation strategies (full, sliding window, summarization, stateless)
Tool call overhead (web search, code execution, RAG, browser, external API)
Multi-agent fan-out (orchestrator + N subagents)
Prompt caching break-even analysis
13 models across Anthropic, OpenAI, Google, DeepSeek — compared side by side

Real numbers from a test configuration

30 iterations · Claude Sonnet 4.6 · 4 parallel
subagents · web search + code execution:

Total: $39.96
Same loop on DeepSeek V4 Flash: $1.85 (95% less)
Caching break-even: 1 run, $23.33/month saved
Sliding window vs full accumulation: 85% savings

Architecture

Pure deterministic math — zero API calls, works
completely offline. Prices pulled live from the
LiteLLM community pricing JSON on page load,
session-cached 6 hours, hardcoded fallback updated
weekly via GitHub Actions. Status badge shows
which layer is active.

The gap: every other cost tool (Langfuse, Helicone,
Braintrust, Bifrost, W&B) is post-hoc observability.
LoopLens is the only pre-run simulator I'm aware of.

Links

Live: looplens-project.vercel.app
Source: github.com/Virerra/looplens
License: MIT

I built a four-view visual workspace with no external UI libraries and a 60fps drag system

Sean — Fri, 26 Jun 2026 14:22:52 +0000

The problem

Every workspace forces one paradigm. Singularity
lets you view the same dataset as a node graph,
kanban board, timeline, and table — simultaneously,
all in sync.

What it does

Six node types (Note, Task, Character, Event,
Research, Location) with labeled directed connections.
Four views of the same data. Change one, update all.

Engineering decisions

No external UI libraries. Every node, edge, panel,
modal, kanban column, timeline row, and table cell
is hand-crafted with inline styles and a shared
design token object.

60fps drag system using requestAnimationFrame with
pointer capture — no React re-renders on every
pointer move event.

Unique IDs via uid(prefix) combining Date.now() and
a monotonic counter — no external library.

Everything in localStorage. No backend, no cloud,
no accounts. Works offline. Ships as a Windows
desktop app via Electron + electron-builder.

Links

Live: singularity-workspace.vercel.app
Source: github.com/Virerra/singularity
License: MIT

I built a free, client-side fact-checker using Claude — BYOK, no backend, four structured checks

Sean — Thu, 25 Jun 2026 10:37:31 +0000

The problem

Most fact-checking tools give you a verdict without explaining the reasoning. That's not useful long-term — users get an answer but no framework for thinking about the next headline themselves.

What I built

Reality Check runs four independent checks on any headline using Claude with live web search:

Source Check — who created this, is the source credible?
Evidence Check — what evidence supports the claim, can it be verified?
Context Check — is this recent and in its original context?
Emotional Check — is the framing designed to manipulate rather than inform?

Each check returns a verdict and reasoning. An overall credibility score from 0–100 summarizes the full picture.

Architecture

Fully client-side. No backend server. No database. No serverless functions operated by me.

BYOK — users supply their own Anthropic API key. It lives only in React component state, never written to localStorage or cookies. Cleared on page close. API calls go browser → api.anthropic.com directly using the anthropic-dangerous-direct-browser-access header.

Stack: React 18 + Vite, Tailwind CSS, claude-sonnet-4-6 with the web_search_20250305 tool (capped at 2 searches per analysis).

Live example

Tested on: "Senate Passes Resolution Directing Trump to End Hostilities With Iran"

Score: 88/100 — Likely Reliable. Source and Evidence both Looks OK (confirmed by NBC, CBS, NPR, PBS, ABC, AP). Context and Emotional flagged as Use Caution — the word "Directs" implies legal compulsion but the resolution is actually symbolic and non-binding. Concept Spotlight: Clickbait.

Technically accurate. Deliberately misleading framing. The tool catches the difference.