AI Agent Execution Engine · Live in production

Forge AI agents. Freeze them. Sell them.

A production-grade engine that runs tool-using AI agents, watches every execution live, and captures any successful run as a reusable Skill — a frozen workflow that replays for new inputs at zero LLM cost, packaged and sellable on its own built-in marketplace.

Try the live app Watch the 5-minute story
Live at agentforge.agentcraft.info 7/7 production E2E checks passed Bilingual EN ⇄ AR, full RTL MCP-ready: Notion, GitHub, Slack
AgentForge — live chat with real-time tool-call cards
0 tokens used
Replay in 2–4 seconds
0
Tokens per deterministic replay
2–4s
Replay latency (vs 8–15s)
2
Commercial pillars, one engine
7/7
Production E2E checks
6
Automated test suites
≤200
Tokens on the worst-case rescue
Why it matters

Stop paying full reasoning cost for patterns you already solved.

Running an AI agent through an LLM for every task is expensive and slow — even when the task is one the agent has already solved. A support agent that searches the same three sources for every pricing question doesn't need a fresh reasoning pass; it needs to remember the pattern and replay it. AgentForge turns one-off agent runs into reusable, packageable automations.

Pillar 01

SaaS — conversational agents

Standalone agents with persistent memory, consumed via API or the built-in chat UI. Full reasoning where it is genuinely needed.

~500–4,000 tokens / conversation
Pillar 02

Marketplace — Skills as products

One-time-recorded Skills, sold and re-run as products. The recorded pattern does the work; the LLM does not.

0 tokens deterministic · 20–90 guided
How it works

The 5-minute story — one flow, every pillar, watched live

From a fresh account to a sellable product in seven steps, entirely inside the UI:

1

Register

Land on the dashboard — agents, skills, tokens-saved counters.

2

Create an agent

Name it, write a system prompt, tick web_search + read_url.

3

Chat live

Watch tool-call cards execute in real time: search → URL → page read → streamed summary.

4

Freeze it

One click: save this execution as a Skill. Variables detected automatically.

5

Replay it

A different topic — the same pipeline runs against the new target's official docs.

6

See the banner

That is the entire cost of run #2, #3 … #10,000.

0 tokens used
7

Publish it

Price it at $0.05/run — live on the built-in marketplace for anyone to run.

Inside the engine

A ReAct core, disciplined by economics

ReAct executor

Standard tool-calling loop, capped at 5 iterations. Every message — user, assistant, each tool result — is persisted with token counts and model name: full replay and auditability survive restarts.

executor.py · 5-iter cap

Recipe abstraction

A successful trace becomes a parameterized template: concrete arguments turn into typed variables with recorded defaults. Deliberately conservative — dynamic URLs are left untouched by default.

abstractor.py · skip_urls

Deterministic replay

For independent steps, the trace replays directly: fill placeholders, call tools, collect results. No LLM call happens at all — the cheapest possible path, and the default.

recipe_executor.py · 0 tokens

Guided replay

For chained steps, a tiered strategy resolves each variable cheapest-first: user input (free) → heuristic match (free) → a tiny LLM rescue (≤200 tokens, validated against candidates) → recorded default. Every step shows which strategy won, as color-coded chips.

guided_executor.py · tiered resolve

Smart URL selection

Every search candidate is scored free: trusted keywords, TLDs, query-token matches, spam penalties. Ambiguous rankings only escalate to the cheap rescue — fed with the search engine's own answer as ground truth.

smart_extract_url()

Arabic auto-translation

Arabic queries are auto-translated to English before searching — technical terms preserved — because official-documentation results are measurably better. Both queries are kept, for full transparency.

web_search · term-preserving

MCP integration

Connect any MCP server — Notion, GitHub, Slack, custom — over HTTP/SSE. Remote tools register namespaced into the same registry; the executor never knows whether a tool is local code or a remote call. stdio deliberately unsupported, for multi-tenant safety.

mcp__{server}__{tool}

Marketplace packaging

A Skill carries its own commercial fields: product name, tiered pricing, and a customer-input schema that auto-generates a public form. The storefront hides execution traces and internal arguments — customers see the product, the price, the form.

publish · auto-forms · no leaks
The economics of Skills

The first run records the pattern. Every next run replays it.

Scenario LLM cost Typical latency
Full ReAct run (search → read → summarize)8–15 s
Deterministic replay0 tokens2–4 s
Guided replay — heuristics win0 tokens2–4 s
Guided replay — LLM rescue needed+1 s per rescue

Record once. Sell forever.

Use cases

Where the record-replay pattern transfers

Four domains were researched and held up under scrutiny — each already converged on the same idea independently:

Robotic process automation

The closest existing analogue: RPA records a human's exact steps once, then replays them. What it always lacked is a principled way to handle the step that genuinely varies. The tiered resolution — free heuristics, then a narrowly-scoped cheap model call, then a recorded default — is exactly the fix: never re-reason a task that is 95% mechanical.

DevOps / SRE incident playbooks

Record the investigation an engineer actually ran once; replay the mechanical parts — query this dashboard, pull these logs — for free; reserve the LLM call for the one step that genuinely requires judgment: correlating today's symptoms against the closest historical incident. Typed inputs and outputs at every step keep the runbook deterministic.

Customer-support runbooks

Most tickets are variations on a small number of known patterns. Record how a senior agent resolves a recurring ticket type, abstract the account details as the only variables — and get a per-run cost breakdown showing exactly how much of each resolution was mechanical versus judgment. That per-step transparency is what existing runbook tools lack.

Sales lead research & enrichment

Search a company, find funding and headcount signals, identify the decision-maker, check recent news — structurally identical to the engine's own demo flow, run hundreds of times with only the company name changing. Record one analyst's actual process once; near-zero-cost enrichment for every lookup of the same shape.

The honest edge — a fifth domain, AI creative content generation, was examined and rejected: replayed content systematically reproduces whatever made the first output generic. Some workflows are valuable precisely because they are not reused. And the real engineering contribution is not the caching — it is the parts that don't replay for free: the tiered resolution, the anti-hallucination validation, the conservative abstraction.
Engineering discipline

Every claim verified — and the gaps documented

Outcome-correctness tests

Six automated suites assert correctness, not absence of errors — e.g. the replay result must mention Celery, not FastAPI. First production E2E (register → chat → freeze → 0-token replay → sell → customer run): passed 7/7.

Security model

JWT + bcrypt; ownership isolation (foreign resources 404, never 403 — no existence leaks); constant-time API-key comparison for service routes; no stdio MCP on shared hosts; bounded tool outputs and a 20-message conversation window.

Marketplace information hiding

Storefront and customer-run endpoints never leak execution traces or internal tool arguments. Customers see the product, the price, and the auto-generated input form — nothing else.

Radical transparency

An explicit tech-debts file ranks known gaps with proposed fixes and effort estimates. A review-notes directory documents every build stage's audit — the bugs caught and how each was closed. The claim is not 'no bugs'; it is 'bugs get caught, documented, and closed'.

Dependency discipline

30 npm dependencies in the entire frontend — deliberately lean, zero UI-kit lock-in. The LLM client is raw httpx against OpenRouter, model-agnostic: GPT, Claude, Llama or Gemini swap by slug.

Hardened operations

Crash-loop-safe entrypoint (waits for Postgres, runs migrations, then boots); health endpoint with live DB check; databases internal-only behind a TLS proxy; streaming shipped with proxy buffering disabled.

Methodology

A two-model pipeline with adversarial review

Five build stages, zero known critical defects outstanding — and an audit trail that proves the process:

01

Spec-first

Contract-precise design specs carrying exact API response shapes, so every component fits real data.

02

Delegated build

A design assistant implemented each part under strict output rules — source files only, ≤30 dependencies enforced.

03

Adversarial review

Every delivery audited against the live backend contract — catching a mocked engine that passed typecheck and a test asserting absence-of-errors instead of correctness.

04

Guided correction

Findings returned as mandatory patch prompts; regressions closed and documented before the next stage.

Status

Live in production

ReAct engine · tool calling · multi-turn · persistence
Skills: abstraction + deterministic replay
Guided replay · tiered resolution · smart URLs
MCP integration over HTTP/SSE
Marketplace packaging · pricing · auto forms
SSE streaming · storefront dual auth
Frontend: 10 routes · 53 components · EN/AR RTL
Known gap (documented): MCP auto-reconnect after backend restart
Technology
FastAPI 0.115SQLAlchemy 2 · asyncPostgreSQL 16 + pgvectorRedis 7 · CeleryAlembicNext.js 15 · App RouterTypeScript strictTailwind · shadcn/uiOpenRouter · httpxTavily searchMCP · JSON-RPC/SSEJWT · bcryptDocker Compose

Watch an agent work. Freeze it. Sell it.

The live app is one click away — register free and run the 5-minute story yourself.

Get started free Sign in