Skip to content
← all systems

Forge

A control center for software-delivery agents - plan, implement, test, and review a feature through a typed 9-step pipeline, with scored gates and a human approval before anything ships.

9-step pipeline · 4 agents · 6 scored gates

role
Architect and sole engineer
stack
Next.js 16 · React 19 · TypeScript strict · Zod 4 · Tailwind v4 · Vitest · SSE
status
oss

Forge is a control center for software-engineering agents. You submit a feature request; four specialist agents take it through a fixed nine-step pipeline - analyze the requirement, plan the architecture, break down tasks, simulate the implementation, write a test plan, then run accessibility, security, and performance reviews. Six quality gates score the result, and the run pauses for a human to approve before it produces a pull-request-ready artifact. It is a deterministic simulation, not a live LLM wrapper: every agent output is generated the same way every time, and the model and database sit behind clean adapter seams, so the platform runs with zero API keys today and goes live by swapping an adapter rather than rewriting the app.

// 01 - PROBLEM

Most "AI agent" demos are a single prompt and a spinner: one call, one blob of output, no structure. Real software delivery needs a team and a process - decompose a feature, plan it, simulate the implementation, write a test plan, run quality checks, and ask a human before anything ships. Forge models that entire control loop end to end, with the traceability and swappable seams a real agentic delivery tool would need.

// 02 - APPROACH

  • A typed runtime engine drives a fixed 9-step pipeline: it runs each step in order, threads every step's output forward as context, and retries a failed step before it fails the run.
  • Four specialist agents own their slice - a Planner (analyze, architect, break down), a Code agent (simulate the implementation), a QA agent (test plan, accessibility), and a Review agent (security, performance, PR summary).
  • Six quality gates score the finished work 0-100 each - TypeScript safety, accessibility, performance, security, test coverage, maintainability - with security and coverage weighted highest.
  • The run halts at a human approval gate: approve to build the pull-request-ready artifact, request changes to reject it. Scores inform the human; the human decides.
  • Deterministic by design: agents generate structured output the same way every run, so the platform demos with zero API keys and every screenshot reproduces exactly.

// 03 - AGENTS

  • Planneragent

    requirement analysis · architecture planning · task breakdown

    Clarified requirements, open questions, the approach and its boundaries, and an estimated task breakdown.

  • Codeagent

    implementation simulation

    Concrete, minimal file changes - paths, added and deleted lines, and illustrative snippets - for each planned task.

  • QAagent

    test plan · accessibility review

    Typed test cases, edge cases, and regression risks, plus a WCAG 2.2 checklist of pass, warn, and fail items.

  • Reviewagent

    security review · performance review · PR summary

    Severity-ranked security and performance findings, and an approval recommendation with a confidence score.

// 04 - ARCHITECTURE

▸ runtime engine · sequential · retry ×2

  1. Planneragent

    01Requirement analysis

    Clarify the request, surface missing details

    02Architecture planning

    Design the approach and its boundaries

    03Task breakdown

    Decompose into estimated technical tasks

  2. Codeagent

    04Implementation

    Propose concrete file changes per task

  3. QAagent

    05Test plan

    Author test cases and regression risks

    06Accessibility review

    Semantics, keyboard, contrast, motion

  4. Reviewagent

    07Security review

    Input, authz, and secret-handling risks

    08Performance review

    Bundle delta and hot-path risk

    09PR summary

    Synthesize an approval recommendation

  5. 6 scored gates

    Score 0-100 each; advisory to the human

  6. Human approvalcontrol point

    The only control on artifact creation

  7. PR-ready artifact

    Summary, files, tests, risks, rollback plan

6 scored gates · ≥80 pass · ≥60 warning · below fail

  • TypeScript safety

    Strict-typing baseline of the proposed change

  • Accessibility

    Warnings and failures on the QA agent's WCAG checklist

  • Performance risk

    Performance findings plus bundle and line delta

  • Security riskweighted

    Severity of the security agent's findings

  • Test coverageweighted

    Test-case count against a target from the acceptance criteria

  • Maintainability

    Change complexity and surface area

Mock mode as a first-class seam
The model and the database sit behind clean adapters - a LanguageModel interface and a Repository interface. The whole domain model is JSON-serializable, so the same objects flow from the in-memory store into Postgres unchanged. The platform runs with zero API keys today; going live means implementing an adapter, not touching the engine, agents, gates, or UI.
Typed contracts over runtime schemas at the seams
Zod validates the untrusted feature request at the Server Action boundary, where malformed input must fail loudly. Between pipeline steps the contract is a TypeScript discriminated union - the compiler guarantees each step returns exactly the shape the next step reads, with no any and no runtime cost.
Hand-coded SVG visuals over a charting library
The dashboards, the span-waterfall trace, and the agent graph are all hand-written SVG rendered in Server Components - no Recharts, Tremor, or React Flow. It stays dependency-free where it counts, renders with zero client JS, and "I built the renderer" is a stronger signal than "I imported a chart." Only two client libraries earn their place: Motion for transitions and cmdk for the command palette.
Streaming that is actually streaming
The live run trace is real Server-Sent Events from a Next route handler, consumed by the browser's native EventSource. It replays a completed run with paced timing - an honest way to demo server-push on deterministic data instead of faking it client-side.

// 05 - PRODUCTION-GRADE

  • Per-step observability: agent, status, attempts, duration, token estimate, cost estimate, and logs for every one of the 9 steps
  • Six quality gates score every run 0-100 and feed the human approval decision
  • Human approval is the sole control on artifact creation - no artifact without an explicit approve
  • Retries built into the engine: a failed step retries before it fails the run and skips the rest
  • Runs with zero API keys in mock mode; CI runs lint, typecheck, test, and build on every push
  • 32 automated tests (Vitest) across the runtime, gates, schema, agents, and a full create-to-approve-to-artifact path

// 06 - SCREENS

Forge dashboard showing throughput, quality, cost, and the awaiting-approval queue
Dashboard: throughput, quality, cost, and the awaiting-approval queue.
Workflow detail view with agent graph, live trace, span waterfall, quality gates, approval, and logs
Workflow detail: agent graph, live SSE trace, span waterfall, quality gates, approval, and logs.
A run replayed as a live server-sent stream with a ticking token, cost, and elapsed counter
Live trace: a run replayed as a real server-sent stream, with a ticking token, cost, and elapsed counter.
Analytics page with per-gate pass rates, quality-score trend, and spend over time
Analytics: per-gate pass rates, quality-score trend, and spend over time.
Side-by-side diff of two runs with green and red deltas
Compare: a side-by-side diff of two runs with green and red deltas.
Command palette for keyboard-first navigation and fuzzy search across workflows
Command palette: keyboard-first navigation and fuzzy search across every workflow.
Pull-request-ready artifact summary, copyable as Markdown
Artifact: a pull-request-ready summary, copyable as Markdown.

// 07 - ARTIFACTS