Arachne
Describe a goal in natural language; Arachne weaves an inspectable DSPy-native agent graph, runs it, and self-heals on failure.
- Source repo
- Strategic-Automation/arachne
- Stars
- ★ 10
- Last updated
- 9d ago
- License
- MIT
- Primary language
- Python
- FA score
- 50/100 · Major gaps
At a glance
- How it runs
- Works with
- Portable with changes
- Cost
- Free software; you pay for model usage
- Setup effort
- Medium · a few setup steps
- You'll need
- Typical use
- A researcher decomposing a vague goal like 'research the current state of humanoid robotics' into a parallelizable task graph
- Not a fit if
- Teams needing a stable API guarantee beyond the 0.1.x beta
- Users who want a GUI instead of a terminal-first workflow
- Source review
- 50/100 · Major gaps
What does this agent do, and when should you use it?
Arachne is a DSPy-native autonomous agent runtime that turns natural-language goals into structured GraphTopology models rather than hidden prompt chains. Its GraphWeaver component weaves a directed graph, WaveExecutor runs nodes in parallel topological waves, and ToolResolver provisions both built-in and MCP-integrated tools through one resolver path. After execution, an Evaluator scores output via rules and semantic scoring, with optional human review gates, and an AutoHealer can retry, re-route, or re-weave failed runs. Every run produces a durable local session record supporting audit, resume, and graph reuse. The project is at 0.1.x beta, suited to experimentation, research workflows, and early integrator feedback.
You submit a goal via the CLI (uv run arachne run "goal"); the runtime clarifies the goal, GraphWeaver produces a typed GraphTopology built from DSPy signatures and Pydantic models, and ToolResolver provisions built-in plus MCP tools. WaveExecutor executes independent nodes concurrently in topological waves once dependencies are satisfied. The Evaluator assesses results using rules and semantic scoring, with human review gates available; AutoHealer applies targeted retry, re-route, or full re-weave on failure. Runs are recorded in a local session store, surfaced through arachne ls, arachne cat last, arachne graphs, arachne rerun <graph-id>, and arachne resume <session-id>.
- A researcher decomposing a vague goal like 'research the current state of humanoid robotics' into a parallelizable task graph
- An analyst generating a market map, e.g. 'create a market map for open-source agent runtimes', with an auditable run record
- An engineer comparing frameworks, e.g. 'compare DSPy and LangGraph for graph-based agents', using weave to generate a graph without executing it
- A team needing resilience against tool failures, relying on the self-healing loop instead of blind expensive retries
- A user who wants to steer generated plans via --interactive review before execution
How do you install or deploy this agent?
Prerequisites: Python 3.11+ and uv. Clone the repository and run the setup wizard:
bash
git clone https://github.com/Strategic-Automation/arachne.git
cd arachne
./quickstart.shThe wizard checks your Python and uv setup, installs dependencies, and helps create local configuration files. Configuration uses either project-level ./arachne.yaml or user-level ~/.arachne/config.yaml (they are not merged; project-level wins), with runtime overrides taking highest priority.
How do you use this agent?
Weave and execute a goal:
bash
uv run arachne run "Research the current state of humanoid robotics"Enable interactive human review:
bash
uv run arachne run "Research the current state of humanoid robotics" --interactiveCommon commands:
bash
uv run arachne weave "Compare DSPy and LangGraph for graph-based agents"
uv run arachne ls -n 5
uv run arachne cat last
uv run arachne graphs
uv run arachne rerun <graph-id>
uv run arachne resume <session-id>What are this agent's strengths and limitations?
- Graph topology is explicitly modeled with Pydantic models and DSPy signatures — inspectable, cacheable, and reusable (arachne graphs / rerun) rather than hidden prompt chains
- WaveExecutor runs independent nodes concurrently in topological waves, faster than sequential plans
- The self-healing loop distinguishes targeted retry, re-route, and re-weave, avoiding blind expensive retries; failed sessions can be resumed
- Built-in and MCP tools share one ToolResolver path, giving a unified extension point
- 0.1.x beta status: interfaces may change, creating migration risk for production adoption
- Requires Python 3.11+ and the uv toolchain plus YAML configuration — more than a one-command install
- Depends on LLM calls; operating costs depend on your chosen model provider's API pricing
- Configuration loader does not merge project-level and user-level YAML — multi-environment deployments must mind the selection logic
How does this agent compare with similar options?
The README's problem table and example commands reference LangGraph as a graph-based-agent alternative, but no formal benchmark is provided; Arachne's stated differentiators are DSPy-native modeling, wave-parallel execution, and its self-healing session model.
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| Arachne This agent | 50 · Major gaps | CLIFree + model costs | ★ 10 | 9d ago | Python | — |
| Swarms Multi-Agent Framework | 0 · Major gaps | Library / SDKFree + model costs | ★ 7.2k | 1d ago | Python | Claude Code · OpenAI API · Claude API |
| Langroid | 70 · Some gaps | Library / SDKFree + model costs | ★ 4.1k | 4d ago | Python | Claude Code · OpenAI API |
| OpenRath | 47 · Major gaps | Library / SDKFree + model costs | ★ 1.1k | 1mo ago | Python | OpenAI API |
How does FollowAgents rate this agent?
Why each dimension lost points
SECURITY.md discloses serious gaps: custom Python tools loaded via exec_module without sandboxing, path traversal in read_file/write_file, and unencrypted mission-critical session data — these directly depress least_privilege, external_effects and rollback. Interactive review is one line with no concrete confirmation flow. Sensitive data handling earns 2 via SecretStr, .gitignore'd .env, and a Deno sandbox. The very wide dependency surface (playwright, browser-use, googlesearch) lacks audit evidence. Attribution is a single unverified personal email.
README, pyproject and tests are mutually consistent, even honestly documenting the non-merging config quirk (2). Dependency availability is deducted for 24+ runtime dependencies with a uv wizard as the only install path and no fallback. Failure messages show partial evidence (asserted 'Tool discovery failed' error, safe default from mock LM), so 2.
Beta status, target scenarios, and command surface are clearly stated (audience 2, trigger 2). Capability boundaries are thin beyond a one-line planned-areas list, and environment fit rests on multiple unargued prerequisites (Deno, uv, 3.11+), both 1.
Docs structure (tutorials/explanation/reference) is clear, quickstart complete, naming consistent (2s). known_limitations earns 3 — the candid self-disclosure in SECURITY.md is a rare highlight. License 3 with consistent LICENSE and badge. Deductions: CHANGELOG is a link with no file, maintenance responsibility concentrated in one unverified individual, no substantive examples or FAQ.
CLI offers ls/cat/rerun/resume making output retrievable and reusable (2). The DSPy-native-graph-vs-prompt-chain framing gives some marginal value (2). Cost-benefit deducted: a default_max_usd budget exists but the dependency bloat (browser-use, playwright, and langchain-openai simultaneously) and unproven Beta-stage payoff yield 1.
Core claims (self-healing, parallel waves, full observability) are not traceable to code in the provided files; tests cover only a narrow slice of weaver/executor (1). README, pyproject, CI and tests corroborate each other on version, commands and the role model (2). Fact/inference separation is good: Beta labelled, known issues explicitly listed, planned areas separated from current state (2).
- SECURITY.md admits path traversal in read_file/write_file and unsandboxed exec_module loading of custom Python tools; restrict filesystem permissions and prefer the Deno sandbox.
- Session logs are unencrypted and may contain mission-critical data; avoid for sensitive workloads or encrypt at rest yourself.
- The dependency surface is very wide with loose ranges (browser-use has no upper bound); assess supply-chain risk yourself.
- Maintenance responsibility rests with a single unverified personal email; confirm response commitments before enterprise adoption.
- 0.1.x is Beta with unstable interfaces and no CHANGELOG file; check commit history before upgrading.