task-based agent swarms with dynamic parallelization, routing, and execution topology.
Benchmark · Process · Quickstart · Why Smythe · Documentation
Give Smythe a goal. It generates an inspectable task graph and executes it with bounded concurrency, execution budgets, verification, traces, and recovery. The graph defines the work; the durable execution envelope governs the run.
Measured against CrewAI on the matched framework suite: 77% fewer tokens and 28% less wall time. Five tasks, three repetitions, the same executor model and pipeline, with blind cross-vendor judging.
Example task: compile, validate, and export an original SVG glyph catalog for a screensaver application.
Complete 192-glyph sheet · Complete 256-glyph sheet · 16 px · 32 px · 64 px · Individual SVGs and manifest · Run the web explorer · All current materials.
This animation shows Smythe-generated glyphs created as part of this benchmark exercise. Build from source: Windows · macOS · Linux. Precompiled screensaver binaries are not distributed. The native ports use layered trails; the web explorer provides the REGL effect, 3D navigation, and pixel settings.
The web renderer adapts m8e, a fork of Rezmason. Native packages also include the reference artwork. Smythe's 256 added screensaver shapes have independently authored contours informed by reference measurements. Credits, licenses, and artwork provenance.
The glyph workload measures parallel artifact generation. Separate matched suites measure recovery, framework overhead, and generated plans. Each result links to its protocol and committed records.
256 SVG glyphs in 8.06 seconds median, including contour compilation, validation at four sizes, every pair comparison, and file export. The best tested configuration uses 8 process workers and is 2.20× faster than its concurrency-one baseline. The 192-glyph set completes in 6.66 seconds median.
All 36 workflows pass, with identical SVG and pixel hashes across three repetitions per setting. The designs are authored before timing; each measured node compiles a fresh SVG through Smythe. Zero API calls and $0 provider API charges; hardware, electricity and design work are unpriced.
Process workers trade more memory for shorter completion time:
Results and scope · Raw trials · 256-glyph contact sheet · Historical v1 study.
200 matched Astra/Sol workflows, with completed human review. The frozen automatic rule accepts 191/200; human review accepts all eight flagged answers at 4/4. The study is claimable within its documented scope. Generated graphs took more time on average on these tasks; every run and the unresolved cost range remain in the records.
Study report and review status · Cost and timing distributions · Paired differences · Every trial.
192 verified glyphs in 20.5 seconds. At concurrency 64, the glyph workload ran 56.2× faster than serial execution. This is a controlled offline measurement with 5.8 seconds of simulated provider latency per call. All measured 64-, 128-, 192-, and 256-node runs produced complete sets of valid, unique tiles.
5,000 accepted artifacts after a hard process kill and recovery. Safe resume completed 2,500 pending operations and preserved the 2,492 already accepted outputs. Eight interrupted operations required explicit rerolls; their original unknown call records remain in the ledger. No accepted operation was reissued; resuming the completed job made zero new calls.
One Windows campaign, concurrency eight, identical 1×1 PNG fixtures, and $0 provider API charges. This tests durable recovery on the frozen schema-v3 runtime; glyph generation, model quality, and the later schema-v4 operator features have separate evidence. Results, complete archive, and independent reconciliation.
A separate matched durability test measures work repeated after a hard kill. Smythe repeated 8 calls versus LangGraph's 32, a 75% reduction, across three repetitions. Recovery protocol.
The framework suite compares orchestration on a fixed pipeline. Smythe used 77% fewer tokens and 28% less wall time than CrewAI across five tasks and three repetitions per framework. All runs use the same executor model and three-stage pipeline, with blind cross-vendor judging.
Smythe also recorded 6% less mean wall time than LangGraph. Its observed quality score was 9.73/10, versus 9.53 for both comparisons. These are suite results; token counts describe model usage, not invoice savings. Protocol and records.
The task-shape suite compares generated plans with a fixed pipeline across five task shapes. Smythe recorded 14% less wall time, including planning. It used one node for a simple transformation and an average of 5.3 for parallel research. Observed quality averaged 9.47/10 versus 9.33/10, within measured judge variation.
Task-shape protocol and records.
Charts are generated from committed records. The benchmark index documents each comparison, its scope, and its evidence status.
| Generated execution topology | Durable execution envelope |
|---|---|
Generate a DAG from the goal with LLMArchitect |
Bound active calls with max_concurrency |
Select approved templates with ConstrainedArchitect |
Reserve supported text-workflow phases in one run_store ledger |
Build exact workflows with DeterministicArchitect |
Save node results and resume from checkpoints |
| Inspect and export plans with their complete task | Validate artifacts and recover verification decisions |
| Reuse successful graphs as templates | Trace calls, costs, failures, and revisions |
Agents use MCP tools, generate images, and pass artifacts to downstream nodes. Durable Jobs add manifest validation, plan approvals, an attempt journal, selective rerolls, detached workers on supported hosts, durable pauses, read-only inspection, and portable exports. Inspect prompts, responses, costs, and artifact receipts in a local HTML report. Lease epochs reject stale-worker journal writes after ownership changes. Persistent artifact namespaces and exclusive file publication preserve accepted outputs across custom run IDs and shared output directories. File checkpoints flush complete snapshots before atomic publication, using independent temporary files for separate store instances. Iterative graph traversal passes 5,000-node dependency-chain checks, including complete offline serial execution and atomic revision validation. Saved graph policies bound node count, execution models, retries, and regeneration across planning and recovery.
Architecture · Task handoffs · Jobs and CLI · Failure policies · Cost guardrails · MCP · Verification · Native Astra and Sol Responses · Durable text accounting · All guides and examples.
Repository development adds Autotune campaign ownership: one leased runner owns trial writes and decisions, with stale-owner rejection and conservative recovery. Planner history validates recalled records and labels summed node time. Autotune reports show saved decisions, comparison charts, and exact costs in a standalone page. These updates are unreleased after 0.7.0.
Python 3.11+. Install Smythe 0.7.0 with the provider used below:
pip install "smythe[openai]==0.7.0"Set OPENAI_API_KEY, then generate and inspect a text-only plan with
GPT-6 Astra:
from smythe import OpenAIResponsesProvider, SQLiteWorkflowStore, Swarm, Task
with SQLiteWorkflowStore("smythe-runs.db") as store:
swarm = Swarm(
model="gpt-6-astra",
provider=OpenAIResponsesProvider(
reasoning_effort="medium",
max_output_tokens=8192,
),
run_store=store,
max_budget_usd=5.00,
parallel=True,
max_concurrency=8,
)
task = Task(
goal="Compare SQLite, PostgreSQL, and DuckDB for a local analytics app.",
constraints=[
"Keep the comparison under 400 words",
"Explain the tradeoffs and recommend one database",
],
)
graph = swarm.plan(task)
print(graph)
result = swarm.execute(graph)
print(result.output)This example makes paid API calls under a $5 run allowance. The
Responses provider supplies native usage receipts
and model-specific prices; the SQLite workflow ledger
includes planning and execution, reserves each request before dispatch, and
replays saved responses locally during recovery. Up to eight execution nodes
run concurrently. Anthropic and Gemini use the smythe[anthropic] and
smythe[gemini] extras outside this managed text-workflow path.
Try the complete acquisition-diligence workflow without an API key:
git clone https://github.com/petehottelet/smythe.git
cd smythe
pip install -e ".[dev]"
python examples/acquisition_diligence/run.pyThree specialists work in parallel, an editor assembles their findings, a red team challenges the draft, and a final node writes the decision memo. Graph, trace, and expected output.
For library-only work, use a slim checkout. The unreleased distribution updates add compact source packages, installed typing checks and a separately verified Repo Doctor ZIP.
- Native exploration: bring the web exposure pipeline, camera controls, and settings to Windows, macOS, and Linux, with platform checks against the web explorer.
- Native platform support: native Wayland integration. Precompiled distribution remains paused.
- Renderer performance: meet the 1080p frame-interval target with the new glyphs, then verify visible presentation and GPU timing. The six-session headless study measured 56.21–56.24 draws/second and retained every result; its pacing target was not met.
- Broader evidence: bounded paid scale trials, repeated live glyph sweeps, and human-calibrated quality comparisons with saved outputs and judge reasoning.
- Fable 5.1: 12-pilot/100-main study, with completed native and Ultracode pilots. The separate ten-task Code Workflow study is also complete, with all diagnostic attempts retained. Human pilot ratings gate the 100-run native comparison. Both studies share the same $100 allocation.
- Astra follow-ups: compare concurrency one and eight on identical graphs, match modern framework adapters, and measure durable tool workflows. These separate studies extend the completed, human-reviewed 200-workflow text comparison.
Outstanding benchmark checklist · Specifications and priorities.
Smythe is pre-1.0; minor releases may change APIs. Release verification · Release history · Contributing · Security · MIT license.