Workflow Engine — Describe Any Team in English

What it does

You write a brief like this:

“I need Alex as PM to set requirements, Sam to do the research, Jordan to analyze the results, Riley to write the blog post. Alex controls all transitions and validates each handoff.”

Forge parses it (any language), generates a WorkflowSpec of named personas + transitions + a management agent, lets you edit + approve, then runs it. Each persona’s output becomes a commit on a branch of your git repo. Alex — the management agent — checks every handoff and decides: advance to the next persona, send the current persona back with enrichment instructions, or escalate to you for review.

Same engine handles a marketing brief, a research workflow, a software delivery pipeline, a customer support triage cycle, or any other team workflow you can describe.

Three example workflows on the same engine

Content workflow — Alex/Sam/Jordan/Riley:

Software delivery — the most mature archetype:

Support triage workflow:

Same architecture across all three. Same NL-driven authoring. Same git audit trail. Different personas, different role hints, different work.

The management agent sits between every transition and decides whether to advance, enrich, or escalate:

stateDiagram-v2
    [*] --> AwaitingHandoff
    AwaitingHandoff --> Validating: previous persona finished
    Validating --> Advancing: verdict = advance
    Validating --> Enriching: verdict = enrich (within budget)
    Validating --> Escalating: verdict = escalate (or budget exhausted)
    Enriching --> AwaitingHandoff: re-dispatch previous persona
    Advancing --> [*]
    Escalating --> OperatorReview
    OperatorReview --> Advancing: operator force-advances
    OperatorReview --> [*]: operator aborts

The three pillars

1. Natural-language workflow generation

You type a brief. Forge parses it into a workflow spec — characters, transitions, management agent — and waits for operator approval before running. Multilingual by default: your team can author workflows in the language they work in. Ambiguities (two personas with the same name, an unfamiliar role hint) get flagged for resolution rather than silently guessed.

2. The management agent pattern

Every transition between personas runs through a designated management agent (typically a PM-shaped persona, but it can be any character). Inputs: the previous persona’s handoff + the original brief + accumulated context. Output: a verdict — advance, enrich, or escalate.

• Advance — handoff is good; downstream persona starts immediately.
• Enrich — handoff has specific gaps; previous persona re-runs with explicit enrichment instructions. Bounded retry budget.
• Escalate — gaps the LLM round won’t fix; operator gets notified for review.

This generalises the proven review-fix-rounds pattern from our SDLC pipeline. Every workflow gets self-correcting behavior without operator intervention, up to a configurable budget.

3. Git as the storage layer

Every persona writes its output to a workflow-scoped branch:

1
2
3
4
5
6
7
8

forge/workflow/{workflowId}/run/{runId}
├── .workflow/spec.json          ← the workflow spec (self-describing)
├── .workflow/brief.md           ← the original natural-language brief
├── .agents/alex/handoff.json   ← Alex's structured output
├── .agents/alex/handoff.md     ← Alex's freeform output
├── .agents/sam/handoff.json   ← Sam's research summary
├── .agents/sam/handoff.md
└── .agents/<other personas>/...

Two modes:

• Linked repo — workflow commits to a customer-owned repository. The customer can git fetch the branch and inspect anytime. PR optional on terminal handoff.
• Shared repo — no link; Forge maintains a hidden per-organization repository (forge-shared-workflows-{orgId}). Operator views handoffs through the SPA. Migration to a customer repo is one click.

Either way, the branch is the audit log. Compliance auditors get a git log and they’re done.

What this isn’t

Forge sits in the generic agentic tooling category. We’re explicit about what we’re not:

• Not a personal AI assistant. You can talk to Forge from Telegram — dispatch work, ask questions, even change configuration, and it remembers the conversation. But it answers as your organisation’s team, not as your personal assistant: what it can reach is your org’s workflows and characters, scoped and audited.
• Not a no-code app builder — Lovable, Bolt, v0 generate code for an app and hand you the hardening. This page is about workflows for teams; if what you want is a product your own customers sign into, that is Atrium , and it composes from parts that already run rather than generating them.
• Not an integration iPaaS — Zapier, n8n, make.com are integration-first. We’re workflow-first.
• Not an agent toolkit — LangGraph, AutoGPT, CrewAI are libraries engineers wire up. We’re a managed product non-engineer buyers configure.
• Not an IDE copilot — Cursor, Copilot help engineers who already exist. We replace the need for engineers in specific team workflows.

Compared to alternatives

How it works for operators

The product flow is intentionally short — no JSON, no terminal, no scripting:

1. Open “New Workflow” in your Forge dashboard.
2. Describe what you want, in plain English. Forge handles any language.
3. Hit “Generate Workflow.” Forge maps named personas in your brief to characters from your existing roster. For any role without a matching character yet, Forge generates one on the spot — tailored to the role hint, your past workflows, and the brief. Review the auto-drafted persona, tweak it, accept.
4. Visual flowchart appears: characters as avatar cards, transitions as arrows, the management agent highlighted. Click any node to edit, drag to reorder, swap a character with one click.
5. Run now to execute immediately, or Schedule to run on a cron (every Monday 9am, end of each sprint, when a webhook fires). Forge handles the rest.

Other ways in

• Label a GitHub issue with forge-pipeline — the SDLC entry point. The 5-role preset kicks off automatically and ships a reviewed PR. (See the SDLC pipeline page. )
• Workflow API — for CI scripts and integrations, POST /api/v1/workflows/from-brief accepts the same brief programmatically.
• Inbound webhook — pre-built integrations for Slack mentions, GitHub events, and external tools that should kick off a workflow.

Software delivery is the archetype we have polished most, because it is the one we run on ourselves every day. It is not the boundary of the engine — see the jobs teams hand over .