Anda
A Rust framework for building composable AI agent runtimes that combine models, tools, memory, and other agents.
Trust: workflows declare minimal permissions (contents: read) and pinned dependency versions with a security-motivated idna comment earn dependency_security 2; but the framework's risky features (shell execution, filesystem, fetch, TEE signing) have no evidenced permission boundaries, user confirmation, data-flow documentation, sensitive-data handling, or rollback — scored 1 from the README feature list only; rollback is absent, 0.
Reliability: clean workspace layout with independent per-crate versioning and centralized deps gives self_consistency 2; mature crates.io dependencies give dependency_availability 2; no tests, error-handling, or failure-message evidence present, so failure_messages stays 1.
Adaptability: README names two audiences (app builders, developers) with scenarios and a clear Rust/ICP/TEE environment — 2 each; capability boundaries and trigger precision (model routing labels, tools_groups) are only summarized without behavioral detail — 1 each.
Convention: documented project structure and consistent anda_* naming earn 2 each; but no install instructions, no known-limitations section, no CHANGELOG evidence (0/0/1); license is contradictory — README says MIT with LICENSE-MIT, Cargo.toml says MIT OR Apache-2.0, the task brief says Apache-2.0 — scored 1; no stated maintenance responsibility, scored 1.
Effectiveness: architecture diagram and layering make the output reasonably usable but no quickstart or sample output, 1; composable agents plus discovery-aware tool bundles offer real marginal value over peers, 2; cost/benefit unverifiable statically, 1.
Verifiability: README claims roughly correspond to Cargo.toml deps, but core claims (CompletionRunner behavior, KIP memory tools) lack code in this evidence set, 1; linked related projects (anda-brain, KIP) give partial corroboration, 1; fact/inference separation is decent — the README distinguishes shipped features from optional extensions, 2.
- License information is inconsistent across three sources (README: MIT; Cargo.toml: MIT OR Apache-2.0; task brief: Apache-2.0); verify the LICENSE files before use.
- The framework ships high-risk capabilities (shell execution, filesystem access, fetch, TEE signing) but this evidence set shows no permission controls or user-confirmation mechanisms; audit anda_engine source before integrating.
- No install instructions, CHANGELOG, or known-limitations documentation were found; validate further before production adoption.
- Publisher identity is unverified and no maintenance responsibility is declared; assess long-term maintenance risk before depending on this framework.
What does this agent do, and when should you use it?
Anda (repository ldclabs/anda) is a Rust framework for building AI agents that combine models, tools, memory, and other agents into a single runtime. Its core engine lets developers register agents and tools, route model requests by capability labels such as primary, pro, flash, and lite, call local or remote functions, and isolate context state. Runtime orchestration is handled by CompletionRunner, which manages iterative model turns, tool calls, usage accounting, cancellation, and compact continuation handoffs for long sessions. Optional extensions add conversation storage, KIP-based memory tools, filesystem access, shell execution, and file-backed skills. The project comprises anda_cli, anda_core, anda_engine, anda_engine_server, and anda_web3_client, and has already produced two products: Anda Brain and Anda Bot. Note: repository metadata lists Apache-2.0, but the README's license section states MIT — verify before adopting.
Anda registers agents and tools through stable traits and function definitions in anda_core, so specialized components compose into larger workflows. The anda_engine engine routes completion requests through labeled model tiers, with provider-specific adapters behind a common request and output contract. CompletionRunner iterates model turns, tool calls, and agent-to-agent calls while tracking usage, artifacts, steering messages, and follow-up messages, with cancellation and compact continuation for long-running sessions. BaseCtx and AgentCtx give each agent or tool isolated state, cache, object storage, HTTP calls, signed calls, cancellation, and child contexts. For tool discovery, static tools, dynamic providers, and MCP servers expose capability groups; agents survey them with tools_groups and expand a group's schemas with tools_select only when needed. Operationally, you run and interact with configured engines via anda_cli and anda_engine_server; anda_web3_client provides a Web3 client for non-TEE environments.
- Rust developers who want to build custom agents and tools against type-safe trait extension points instead of a fixed application shape.
- Teams that need to route completion requests across model tiers like primary, pro, flash, and lite to balance cost and latency.
- Applications requiring long-running agent sessions with usage accounting, cancellation, and compact continuation handoffs.
- Setups that combine MCP servers, dynamic tool providers, and static tools, with on-demand tool schema discovery.
- Builders of memory/cognition products who can follow the paths proven by Anda Brain and Anda Bot, both built on Anda.
What are this agent's strengths and limitations?
- Composability is an explicit design goal: agents and tools register via stable traits and function definitions, avoiding hard-coded application shapes.
- Labeled model routing (primary/pro/flash/lite) keeps provider adapters behind one contract, easing model switching or mixing.
- CompletionRunner delivers production-grade runtime control: usage accounting, artifacts, steering/follow-up messages, cancellation, and compact continuation.
- The tools_groups / tools_select discovery mechanism avoids loading all tool schemas upfront, with MCP support built in.
- Requires a Rust toolchain, raising adoption costs for teams outside the Rust ecosystem compared to Python agent frameworks.
- No install commands, dependency versions, or configuration examples in the README; onboarding requires reading architecture.md and self-directed exploration.
- License inconsistency: repository metadata says Apache-2.0 while the README states MIT; commercial adopters should verify.
- Constraints around the Web3 components (anda_web3_client, non-TEE environments) are not explained in the README.
How do you install or deploy this agent?
The repository does not document concrete install commands or dependency versions. The confirmed path is: clone https://github.com/ldclabs/anda, then run engines through anda_cli and anda_engine_server, or build custom agents on the anda_core traits as a developer. Missing information: required Rust version, crates.io availability, and exact build/startup commands for anda_cli and anda_engine_server.
How do you use this agent?
Per the README's role split: application builders use anda_cli and anda_engine_server to run and interact with configured engines; developers build custom agents and tools with the anda_core traits, extend anda_engine with reusable runtime features, and improve model adapters, context capabilities, memory integrations, and server APIs. Exact startup commands and model provider configuration are not provided in the current README.
How does this agent compare with similar options?
The README names no specific competitors; similar frameworks exist in other languages, but the source provides no comparable facts, so none are asserted here.