Ant3

mcp
Guvenlik Denetimi
Uyari
Health Uyari
  • License — License: MIT
  • Description — Repository has a description
  • Active repo — Last push 0 days ago
  • Low visibility — Only 9 GitHub stars
Code Gecti
  • Code scan — Scanned 12 files during light audit, no dangerous patterns found
Permissions Gecti
  • Permissions — No dangerous permissions requested

Bu listing icin henuz AI raporu yok.

SUMMARY

Swarm intelligence for AI agents in Rust. Peer agents self-organize via stigmergy: pheromone traces, adaptive division of labor, atomic task claiming. No fixed role pipelines — collective intelligence emerges. Local-first, single binary, MCP-ready.

README.md

Ant³ — Small agents. Shared work.

Ant³

Swarm intelligence for AI agents, built in Rust.
Small agents. Shared work. Emergent outcomes.

CI License: MIT Rust 1.99+ Status: pre-1.0 简体中文

Ant³ is a multi-agent platform where peer AI agents self-organize like an ant colony. Publish a task with acceptance criteria; agents claim work from a shared board, split it, reuse each other's results, and integrate — coordinating through stigmergy (a pheromone-style trace field) rather than a fixed planner. No hardcoded role pipelines: division of labor and collective progress emerge from local rules.

简体中文 · Documentation · Architecture · Current status · Contributing

Contents

Why Ant³

Most multi-agent frameworks hand you a fixed workflow — a planner, a researcher, a summarizer, wired in a script. That is orchestration, not intelligence.

Ant³ takes the opposite bet, inspired by how ants solve hard problems with no central command:

  • No fixed roles. Planning and integration are tasks any peer can claim, not identities baked into the kernel.
  • Coordination through the environment. Agents leave durable traces; later agents follow what worked. This is stigmergy, the mechanism behind ant trails.
  • Emergence, measured. A built-in evaluation harness compares one agent against a swarm on the same task and budget, so "the swarm is better" is a claim you can test, not assume.

The result is a local-first, single-binary Rust platform you can run, inspect, and extend — with the model/tool loop usable as a standalone crate.

Swarm mechanisms

These are implemented today, not roadmap promises:

Mechanism What it does
Pheromone trace field Tasks and results carry a concentration that reinforces on completion, human acceptance, and peer reuse, and evaporates with a 30-minute half-life. Strong trails attract work; stale ones fade.
Response-threshold division of labor Each Preset's threshold adapts with experience (success lowers it, failure raises it). Specialists respond to faint trails; novices chase strong ones.
Crowding avoidance A task's stimulus is diluted by how many workers already crowd its branch, so the swarm spreads across the board instead of piling up.
Recruitment & negative feedback A successful run amplifies the paths it used; a definite failure penalizes them. Dead ends lose attractiveness.
Local perception Agents see their neighborhood by default, not the whole board — global order grows from local rules.
Individual-loss robustness Lose a worker and its task requeues under a bounded retry budget; a fresh peer takes over and the swarm still converges.
Atomic claim & split One effective owner per task; subtasks return to the board and trigger fresh selection. No peer controls another.

Ant³ implements stigmergy as durable, auditable records with a bounded control plane — not a literal ant-colony optimization solver. See the trace-field design and evaluation baseline.

Quick start

Requires Rust 1.99+ (latest stable recommended). Single binary, no external database or Node build.

git clone https://github.com/NeoPanic/Ant3.git
cd Ant3
cargo run --locked -p ant3-cli -- up

Open localhost:7333 and sign in with the contents of .ant3/token. Then:

  1. Configure a model provider and publish a Preset in 母体 Presets.
  2. Publish work + acceptance criteria in 任务板 (Task Board).
  3. Watch selection, claim, split, and integration in Agent 工作现场; inspect trace concentrations on each task.

Ant³ speaks OpenAI-compatible Chat Completions, OpenAI Responses, and Anthropic Messages. Configuration, CLI/API/MCP usage, and local process plugins are in the getting-started guide.

Ant³ local task board

How the colony works

Colony principle Ant³ mechanism
Shared traces A persistent task board holds work, claims, progress, results, and pheromone concentration.
Local action Each agent claims a task and executes within its scope and neighborhood.
Division of labor Versioned Presets supply models/instructions/tools; adaptive thresholds specialize them.
Collective progress Subtasks return to the board; a peer integrates completed contributions.
Feedback Humans accept a root result or request another round; success/failure reshapes the trails.

The control plane selects Presets, provisions instances, and enforces capacity, permissions, and budgets — but it is not a permanent leader. Every agent runs the same model/tool loop with its own specialization.

What you can use

Area Available behavior
Agent definitions Versioned Presets, pinned inheritance, parameters, model and plugin bindings.
Lifecycle Independent instances; Agent pools for provisioning, scaling, retirement, and TTL.
Shared task board Publish unassigned tasks; select Presets, provision instances, claim atomically, split, requeue on failure.
Swarm coordination Pheromone traces, response-threshold division of labor, crowding avoidance, recruitment, local perception.
Explicit scaffolding Goal dependency graphs, candidate-based claiming, bounded dynamic delegation (user/agent-initiated, not fixed pipelines).
Collaboration Direct messages, Goal channels, subscriptions, shared versioned context.
Deliverables Private workspaces, immutable text/file/JSON snapshots, peer evidence handoffs.
Review Independent verification, evidence-linked repair, review rounds, human acceptance.
Extension Prompt packages and local process Tool plugins with pinned versions and health checks.
Access Desktop Web, HTTP API, CLI, and outward MCP stdio share persistent local state.

Completed root results await human review: accept to archive, or request changes to resume with feedback. Automatic independent verification is not yet wired into the board itself.

More console views: workstation, collaboration, and artifacts

Agent workstation

Console overview

Crew animations reflect recorded execution states: working, waiting, or sleeping.

Team collaboration

Workspace files and shared evidence

Architecture

flowchart LR
    Entry[Publish task] --> Board[Shared task board + trace field]
    Board --> Control[Control plane: select Preset]
    Preset[Versioned Presets + experience] --> Control
    Control -->|start and manage| A[Agent A: independent Ant]
    Control -->|start and manage| B[Agent B: independent Ant]
    A -->|claim / results / subtasks / traces| Board
    B -->|claim / results / subtasks / traces| Board
    Board <--> State[SQLite: tasks / claims / Runs / traces]

The independent Ant owns model/tool execution, policies, session checkpoints, cancellation, and receipts. Checkpoints do not guarantee exactly-once external effects: tools supply their own idempotency or transaction contract. See runtime contracts and the target architecture.

Use the runtime independently

The model/tool loop is a standalone crate, usable without the platform:

cargo run --locked --example quickstart
[dependencies]
ant3 = { git = "https://github.com/NeoPanic/Ant3.git", branch = "main" }
use ant3::{Ant, Limits, Registry};

let agent = Ant::new(Registry::default(), Limits::default());

The offline example runs a model → tool → model cycle and redelivers the same event to demonstrate session deduplication. Pin a Git revision for reproducible builds. API reference: cargo doc --locked --workspace --no-deps --open.

Status & boundaries

Ant³ is a pre-1.0 local platform for trusted environments. Local defaults: 256 instances, 8 execution slots, 64 tasks per Goal — configured limits, not measured capacity claims. Not yet provided: distributed scheduling, hosted deployment, strong multi-tenant isolation, hard cost budgets, and remote MCP plugin loading. See current status and the capability/source index for precise boundaries.

The display name is Ant³, the repository is Ant3, and technical identifiers use ant3 (CLI, Cargo packages, protocols, .ant3/ data directory). ³ expresses the collaboration loop: claim → contribute → continue. Brand assets · upgrade guide.

Contribute

See development checks, security reporting, and the code of conduct. The documentation index links setup, design goals, capabilities, and workflow contracts.

If Ant³'s take on emergent multi-agent coordination interests you, star the repo to follow along — issues and PRs are welcome.

MIT license.

Yorumlar (0)

Sonuc bulunamadi