Events go in: a ticket, an email, a form, an alert, a schedule. Workflows pick them up, your agents do the work on the harness you choose, people approve where it matters, and results come out: a reply, an updated record, a document, a pull request. It scales to zero, stays on budget, and learns from every run.
Four stations, one assembly line. Describe your world in a catalog, write the workflows in YAML, and Factoryal runs them.
A person starts a run, or an event arrives: a form, a message, a catalog change, a webhook from any system, a schedule.
The workflow whose trigger matches takes it. The catalog gives agents their context: teams, systems, customers, whatever you model.
Claude calls, scoped agents and coding agents, each on its own worker pool that scales by itself.
A reply in the Slack thread or on the ticket, an updated record, a document, a pull request. Where the work came from.
Agents, skills, rules and runners are files in your factory's git repo. Factoryal runs them on the harness each step needs, enforces what each agent may touch, and keeps track of every run.
kind: Agent
identifier: triager
owner: support
effort: high
scopes: [catalog:read, "catalog:write:ticket"]
skills: [severity-guide]
system_prompt: You triage incoming tickets...Who does the work, and what it may touch. The API enforces the scopes, whatever the prompt says.
kind: Skill
identifier: severity-guide
owner: support
instructions: |
critical: a customer can't work or data is at risk.
high: a workaround exists but hurts.
...Reusable know-how, listed on agents by name. Steps can swap skills per run without a new agent version.
kind: Rule
identifier: no-secrets
owner: platform
scope: org # or team / repo
instructions: Never commit secrets, tokens or .env files.Standing instructions every agent in scope follows, without listing them.
kind: Environment
identifier: py312
owner: platform
backend: claude_code # or codex, managed_agents
setup: ["uv sync"]
allowed_hosts: [pypi.internal.acme]Where coding agents run: the harness, the setup, and the hosts they may reach.
Merging to main applies a change. Every run records the exact version of each agent, skill and rule it used.
An agent can't widen its own permissions, edit its rules or approve its own lessons.
Run a step on Claude Code, Codex or Managed Agents, and override model, effort or skills, without touching the agent.
One generic interpreter runs every workflow. Steps pass data with templates, and a waiting approval costs nothing.
kind: Workflow
identifier: refund
inputs:
order: { type: string, required: true }
amount: { type: number, required: true }
steps: - id: review # one Claude call
type: llm
prompt: Summarize the request for order {{ .inputs.order }}. - id: approve # waits, holding no worker
type: approval
message: "Refund ${{ .inputs.amount }}?"
expires: 72h - id: refund
type: http
url: https://billing.internal/refundsA factory that runs all day needs more than workflows. Factoryal grows and shrinks with the load, keeps every token accounted for, and learns from what its runs produced.
Every run is its own durable execution. Claude calls, coding agents and workflow logic each have a worker pool that scales on its own queue, and on AWS every pool goes down to zero tasks when there's nothing to do.
Monthly budgets per workflow, team or project, and a cost cap per run. When a budget runs out, new runs are skipped or queued until it allows them. Every step lands in a spend ledger by model, agent, team and token type.
Factoryal records what became of each run's work: merged, revised, approved or rejected. Retros look back at the runs that went wrong and name the cause; when the same cause keeps coming back, it becomes a cluster, and fixes arrive as pull requests on the factory.
Every step is scored on whether its work held up, then compared on cost per success. Recommendations point to a cheaper model or effort that does as well, prompts that miss the cache, and candidates a replay of past runs has already checked. One click opens the change as a pull request.
From trigger to result, with permissions, approvals, budgets and scale built in.
Blueprints, validated entities and relations, with a Port-compatible search language and transitive graph queries.
Versioned and run by one interpreter. Steps like llm, agent, code, approval, http, map and parallel.
Each agent has an owner, explicit scopes and a version. The API enforces the scopes, whatever the prompt says.
When the work is code, a code step has Claude Code, Codex or Managed Agents change a repo and the platform opens the PR.
Each factory is its own git repo. Pull requests get the plan as a comment, merging applies it, and every run is stamped with the commit.
Replay past tasks under several agent configurations and compare correctness against cost, before you change what runs in production.
Work comes in from where your team already works, and results go back to the same place. Anything with an API can join.
The quickstart takes about 15 minutes: Docker and an Anthropic API key. No AWS, no GitHub App, no Slack needed to begin.