Arachne

Describe a goal in natural language; Arachne weaves an inspectable DSPy-native agent graph, runs it, and self-heals on failure.

Stars
★ 12
Last updated
5mo ago
License
MIT
Primary language
Python

At a glance

How it runs
CLIFramework
Works with
Portable with changes
Cost
Free software; you pay for model usage
Setup effort
Medium · a few setup steps
You'll need
Python 3.11+uvDSPyPydanticShell / CLINetwork accessLocal filesystem
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
Maintenance
Commits in the last 6 monthslast commit 2026-06-21latest release v0.1.0 (2026-04-26)

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>.

  1. A researcher decomposing a vague goal like 'research the current state of humanoid robotics' into a parallelizable task graph
  2. An analyst generating a market map, e.g. 'create a market map for open-source agent runtimes', with an auditable run record
  3. An engineer comparing frameworks, e.g. 'compare DSPy and LangGraph for graph-based agents', using weave to generate a graph without executing it
  4. A team needing resilience against tool failures, relying on the self-healing loop instead of blind expensive retries
  5. A user who wants to steer generated plans via --interactive review before execution

Key setup facts

Pulled from the install and usage notes below. The project README has the current values.

Config files
./arachne.yaml ~/.arachne/config.yaml
Runtime
Python 3.11+

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.sh

The 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" --interactive

Common 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?

Pros
  • 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
Limitations
  • 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 52 · Major gaps CLIFree + model costs ★ 12 5mo ago Python —
Swarms Multi-Agent Framework 53 · Major gaps Library / SDKFree + model costs ★ 7.4k today Python Claude Code · OpenAI API · Claude API
Langroid 72 · Some gaps Library / SDKFree + model costs ★ 4.2k 1d ago Python Claude Code · OpenAI API
OpenRath 57 · Major gaps Library / SDKFree + model costs ★ 956 1mo ago Python OpenAI API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
52/ 100 5-point scale 2.6 / 5
Trust 11/29
Reliability 6/14
Adaptability 12/18
Convention 12/18
Effectiveness 7/13
Verifiability 4/8
Why each dimension lost points
Trust11 / 29 · 1.9/5

The security documents explicitly identify the high-privilege risks of shell_exec, MCP commands, and in-process Python custom tools, and recommend restricting configuration, reviewing tools, and setting resource limits, so least privilege is only partially implemented. Interactive mode can review plans, and the Reminders skill requires confirmation before creating an item, but the default flow still provisions and executes tools automatically, making confirmation limited. The security policy, configuration reference, and tutorial describe credential environment variables, session directories, telemetry, and tool boundaries; however, session logs are not encrypted and security logging is described as minimal. Dependencies have version ranges, but the packet shows no vulnerability auditing or supply-chain controls. Tasks may start MCP servers, access networks, or invoke shell/tools, and the materials do not establish a general confirmation mechanism for external effects. Sessions support resume, rerun, and deletion, but there is no general rollback for external actions. Repository, author, and private vulnerability-report contact details are documented, but publisher identity is not verified by the curated registry.

Reliability6 / 14 · 2.1/5

The README, configuration, and code describe graph execution, persistence, and recovery, but MCP command validation is described inconsistently: the security document says commands are not validated, while troubleshooting says to check an allowlist. CI configuration and test samples provide partial corroboration; this review did not execute them, and production capability claims should not be treated as verified. Dependency ranges and installation entry points are clear, but several functions depend on external LLMs, networks, browsers, or local programs. Troubleshooting covers credentials, models, MCP, sessions, and cost with useful but incomplete guidance.

Adaptability12 / 18 · 3.3/5

The README and tutorial target developers, experimentation, research, and early integration, with research, graph reuse, and interactive review as scenarios. The security document identifies trust boundaries for untrusted input, generated code, MCP, shell, and custom Python tools, clarifying capabilities and risks. Interactive mode is suitable for broad goals or tasks whose plans need review; the default execution mode has fewer usage boundaries. Python, uv, LLM providers, macOS skills, and local directory settings are described, providing some environment fit, though support across tools and platforms is not fully uniform.

Convention12 / 18 · 3.3/5

The README, tutorials, guides, configuration, CLI, security, and troubleshooting materials have a clear structure and entry points. Installation covers Python, uv, configuration, and a first run, though documents differ slightly between `uv sync` and `uv sync --all-groups`. Arachne's core naming is stable and component names such as `ExecutionManager` and `WaveExecutor` are provided, but the packet does not establish consistency across all interfaces. Command examples and troubleshooting cover common tasks; no comprehensive FAQ is shown. Security limits and Beta status are documented, with some fixes still planned. The MIT license text and metadata are explicit, earning full marks. Version 0.1.0, Beta status, and a changelog link are present, but changelog contents were not included for review. Maintenance responsibility is partly clear through author details, a vulnerability contact, an issue tracker, and 0.x support status, though broader maintenance commitments are absent.

Effectiveness7 / 13 · 2.7/5

CLI commands for run, weave, inspection, rerun, and resume, together with structured session records, help users obtain and reuse outputs. Graph orchestration, parallel execution, evaluation, and repair are clear differentiators, but they are described in project materials and their practical effect is not established by static evidence. Configuration provides per-run dollar and token limits plus a hard-stop setting, which helps control cost; defaults are high, retries and multi-stage execution may add expense, and cost-benefit guidance is limited.

Verifiability4 / 8 · 2.5/5

Several feature claims map to specific documents, configuration settings, CLI examples, source paths, or test samples, providing some traceability. The README, architecture materials, security document, and test samples partly corroborate each other, but the MCP validation account conflicts and the packet is only a sample. Documents often distinguish implemented measures, known risks, and future plans; performance, security, and production-readiness statements remain project claims not validated by execution in this review.

Risks and how to mitigate them
  • The security documents classify shell_exec, MCP commands, and custom Python tools as high risk; use them only after reviewing their sources and restricting filesystem, network, and resource access.
  • The security document says MCP commands are not yet validated, while troubleshooting mentions an allowlist; do not assume that restriction is implemented.
  • Session logs are not encrypted and security logging is limited; avoid placing highly sensitive information in goals or tool outputs.
  • Default runs may provision and execute tools automatically. For tasks with real-world effects, use interactive review and inspect the plan yourself.
  • The project is in 0.1.x Beta, and the test and CI claims in the packet were not executed in this review.
Evidence confidence: Low Reviewed Nov 08, 2026 Reviewed revision 9c860b11d112
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/arachne.svg)](https://followagents.com/en/agents/arachne)
<a href="https://followagents.com/en/agents/arachne"><img src="https://followagents.com/badge/arachne.svg" alt="FARS review"></a>

Recent releases

Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.

  1. v0.1.0 v0.1.0 — Beta
    Release notes excerpt
    Arachne is a DSPy-native autonomous AI agent runtime with graph orchestration, self-healing execution, and dynamic tool/skill provisioning. Beta — under active development. APIs may change. Core - 🧠 GraphWeaver — generates optimized execution DAGs from natural language goals - ⚡ WaveExecutor — true parallel wave-based execution via asyncio - 🛡️ TriangulatedEvaluator — Rules → Semantic → HITL verification - 🔄 AutoHealer — autonomous retry, re-route, or re-weave on failure - 💾 SearchMemoryStore — persistent search dedup across healing iterations …
    View on GitHub ↗

FAQ

Does Arachne cost money?
The software itself is free and open source under the MIT License, but running agents requires LLM calls whose costs depend on the model provider API you configure.
What happens when a run fails?
AutoHealer selects targeted retry, re-route, or a full re-weave for failed or low-quality runs; you can also recover a failed session with arachne resume <session-id>.
Can I reuse a graph I already generated?
Yes. Graph topologies are cached — list them with arachne graphs and re-execute one with arachne rerun <graph-id>.
Can a human review the generated plan?
Yes. Use the --interactive flag to review and steer the generated graph before execution; the evaluation stage also supports human review gates.
Is it production-ready?
The README states that 0.1.x is beta with interfaces that may change; the current positioning is experimentation, research workflows, and early integrator feedback, with focus on reliability and observability.
Is Arachne open source?
Yes. The source code is on GitHub (Strategic-Automation/arachne) under the MIT licence.
Is Arachne safe to use?
FollowAgents' FARS review (Nov 08, 2026) scored Arachne 11/29 on trust and safety. None of the eight safety controls the review checks for was missing outright.
Is Arachne still maintained?
Development has slowed: the latest commit on GitHub is from 2026-06-21, within the last six months but not the last 30 days. The latest release is v0.1.0 (2026-04-26).
Who makes Arachne?
Arachne is published on GitHub by the account Strategic-Automation. FollowAgents has not verified which person or company is behind that account.
Was this page helpful?
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related concepts