Agentica
One person, a team of agents: a multi-session CLI where sessions collaborate, /goal keeps long tasks running, and WeChat/Feishu gateways call agents back when you walk away.
Evidence shows deliberate least-privilege design: read-only subagents by default, file tools narrowed to apply_patch/write_file, an ask permission profile, and layered guardrails; however, the actual permission-checking implementation is not visible in the provided files, so full marks are withheld. Deductions: sandboxing/confirmation details for high-impact external behaviors (execute tool, cron, IM gateways, desktop auto-installing a Python runtime) are not verifiable in the source; API keys rely on env/.env with no encryption or rotation guidance; no dependency audit or SBOM evidence; rollback rests only on asserted worktree/resume features. Attribution is clear (author XuMing, acknowledgements to phidata and openai-agents-python), but the publisher is unverified.
Self-consistency is good: README, pyproject (v1.4.15), News entries, and CLI/gateway entry points agree. Dependency availability benefits from fallback models, many providers, and an agentica doctor command. Deduction: actual failure message and recovery quality cannot be verified from source; only command names are visible.
Audience and scenarios (CLI/Web/Desktop/SDK/IM) are well described; the task/delegate/peer table draws capability boundaries; @session addressing, /goal, and /cron give precise triggers. Deductions: these are documentation assertions; cross-platform Python 3.10+ support is unverified by execution, and limits of self-evolving skills are not quantified.
Information architecture is the repo's strength: docs site, examples directory, installation troubleshooting FAQs (macOS quarantine, SmartScreen, AppImage permissions), bilingual docs; full Apache-2.0 license text; detailed per-release News and CHANGELOG link. Deductions: unsigned installer risk is left to manual user workarounds rather than mitigation; maintenance rests on a single individual (bus factor 1).
Output usability is supported by trace views, /export JSONL, and streaming. If true, the claimed same-model speed/token advantages over Codex represent real marginal value. Deduction: performance and cost-benefit claims are self-run benchmarks (self-published predictions.l), unverifiable in static review; the 'two-thirds fewer tokens' figure has no independent corroboration.
Key claims link to benchmark pages and per-release notes, giving reasonable traceability. Deductions: all benchmark and comparison data are single-source (author self-run) with no third-party replication; the README mixes promotional assertions ('all coding problems correct') with factual statements without fact/inference separation.
- Desktop installers are unsigned and the README instructs users to bypass macOS Gatekeeper and Windows SmartScreen; verify installer hashes and provenance before deploying in controlled environments.
- BuiltinExecuteTool and delegate processes have full local execution capability, and IM gateways (WeChat/WeCom/Feishu/Telegram) inject external messages into agents; enable the ask permission profile by default and restrict which sessions/directories gateway accounts can reach.
- All benchmark comparisons are author self-run; reproduce the evaluation independently before accepting the performance and token-saving claims.
- The project depends heavily on a single maintainer and iterates rapidly (releases every few days); pin a specific version for production and watch the CHANGELOG for breaking changes.
- This was a static review with no code executed; actual behavior of permissions, guardrails, and failure recovery is unverified at runtime.
What does this agent do, and when should you use it?
Agentica is an Apache-2.0 multi-agent framework and product by shibing624, pitched as "one person, a team of agents." Each terminal session is a collaborating agent: in-process `task` spawns read-only subagents, process-level `delegate` launches a full independent process for big jobs, and cross-terminal peer messaging lets sessions talk to each other — with nothing extra to deploy. Shipping surfaces include a CLI, a local Web UI via `agentica-gateway`, a Desktop App, an async Python SDK (`Agent` / `DeepAgent`), and a TypeScript client `@agentica-ai/sdk`. The core engine is an async-first Agentic Loop with built-in file/execute/search tools, two-layer context compaction, four-layer guardrails, persistent memory, and a self-evolving Skill system that compiles run experience into reusable `SKILL.md` files. It adapts to many providers — OpenAI, DeepSeek, Claude, Zhipu, Qwen, Ollama and more — and publishes a benchmark claiming roughly 2x speed and two-thirds fewer input tokens than OpenAI Codex on the same model, with reproducible commands and per-item metrics.
After running agentica, the agent reads and writes files (read_file/write_file/apply_patch/grep/glob), executes commands (execute), and performs web search to complete coding and data-analysis tasks. Multi-session collaboration works through three mechanisms: task (same-process read-only subagent), delegate (launches a full agentica --query --print process, managed via /ps, wait, /stop), and peer messaging (list_agents / send_message). /goal sustains long-running tasks; /cron schedules runs. Experience is automatically compiled into SKILL.md files reused across sessions. On the Python side, Agent(model=OpenAIChat(...), tools=[...]).run_sync(...) embeds agents in any code, while DeepAgent() gives the full stack (built-in tools + compaction + long-term memory + skills + MCP). agentica-gateway serves a local web app at http://127.0.0.1:8881/chat and bridges WeChat/WeCom/Feishu/Telegram, with per-account sessions and memory; Docker Compose supports self-hosting.
- A solo developer debugging failing unit tests or refactoring code in the terminal, using
taskfor read-only code search anddelegatefor independent heavy jobs - A Python engineer embedding
DeepAgentin their own codebase for one-line access to search, file writing, execution and long-term memory - An operator or researcher who steps away from the machine and drives local agents remotely via WeChat or Feishu with
@session-nameaddressing - A team wanting open models like DeepSeek instead of the Claude- or OpenAI-only lock-in of Claude Code/Codex, validating via the published benchmark
- Data or finance analysts using the examples' 6-agent financial research pipeline, RAG knowledge-base QA, and data pipelines
- Multi-device users sharing the same
~/.agenticahistory, config and workspace across CLI, browser and Desktop App
What are this agent's strengths and limitations?
- Cross-terminal multi-session collaboration (
task/delegate/peer) is absent from both Claude Code and Codex CLI and requires no extra deployment - No model lock-in: free provider switching with deep adaptation for open models like DeepSeek; the official benchmark reports ~2x speed and ~2/3 fewer input tokens than Codex on the same model
- Self-evolving skills: experience compiles into
SKILL.mdfiles reused across sessions, so similar tasks don't start from scratch - CLI, Web and Desktop share the same
~/.agenticastate, plus WeChat/WeCom/Feishu/Telegram gateways so you can drive agents remotely - Full async Python SDK, TypeScript SDK, MCP/ACP support and an extensive examples catalog make it embeddable in any codebase
- Young project (v1.4.x stage); its ecosystem and community are far smaller than Claude Code/Codex, so long-term maintenance risk needs evaluation
- Desktop builds are unsigned — macOS/Windows/Linux all require one-time manual workarounds, adding friction for non-technical users
- The performance claims come from the project's own benchmark (public coding and data-analysis suites); independent third-party validation evidence is limited
- IM gateway, Web and multi-account features require installing
agentica[gateway]and runningagentica-gatewaylocally; self-hosting means maintaining a Docker environment - The full feature chain (gateway, Desktop, managed runtime) involves Python 3.12/uv runtime details, making deployment more complex than a plain CLI
How do you install or deploy this agent?
Base install: pip install -U agentica (Python 3.10+). Web gateway: pip install -U "agentica[gateway]" then run agentica-gateway; first startup creates a default account and prints a random initial password to the terminal. Desktop builds ship as macOS dmg / Windows NSIS / Linux AppImage and deb (unsigned: on macOS run sudo xattr -rd com.apple.quarantine /Applications/Agentica.app; on Windows choose "Run anyway" in SmartScreen; on Linux run chmod +x on the AppImage). Self-hosting: cp .env.docker.example .env, fill in OPENAI_API_KEY, then docker compose up -d --build. TypeScript SDK: npm install @agentica-ai/sdk (the full scoped package name is required, not agentica-sdk).
How do you use this agent?
1) Set any provider's API key (priority: shell env > .env > config.yaml), e.g. export OPENAI_BASE_URL="https://api.openai.com/v1" and export OPENAI_API_KEY="sk-xxx", or the free-to-start export ZAI_API_KEY="your-api-key"; alternatively run agentica setup to generate ~/.agentica/config.yaml. 2) Type agentica in a terminal and chat directly; use /model to switch models, /goal for long tasks, /ps//stop to manage delegated processes, /cron for scheduled runs. 3) Python embedding: from agentica import Agent, OpenAIChat, BuiltinWebSearchTool, BuiltinFileTool, BuiltinExecuteTool, build the Agent, then call agent.run_sync("Search Python 3.13 features and write them to features.md"). 4) Open the web app at http://127.0.0.1:8881/chat; admins add accounts on the user-management page. 5) Node scripts against a running gateway: new Agentica({baseURL: "http://127.0.0.1:8881", apiKey: process.env.AGENTICA_GATEWAY_TOKEN}), then iterate agentica.chat.stream(...).
How does this agent compare with similar options?
The README compares Agentica with Claude Code and OpenAI Codex CLI: Agentica offers free multi-provider model switching, cross-terminal multi-session collaboration, Web/Desktop/IM entry points, self-evolving skills, a full Python SDK, and Apache-2.0 open source; Claude Code supports only Claude models and is closed source; Codex CLI supports only OpenAI models and lacks cross-terminal collaboration and self-evolving skills. The project's benchmark (same model, public question sets) claims accuracy no worse than Codex with lower wall-clock time and input tokens; reproducibility details are on its benchmark page.
FAQ
Which model provider is required? Can it start for free?
Does my data leave my machine?
~/.agentica, and self-hosting uses Docker with named volumes. However, inference still calls your chosen provider's API unless you use a local model via Ollama.When should I use task, delegate or peer messaging?
task for short read-only work (code search, lookups); delegate for big jobs needing independent context or another directory (managed via /ps, wait, /stop); peer messaging only to sync information between two interactive sessions.The Desktop App won't open — what now?
sudo xattr -rd com.apple.quarantine /Applications/Agentica.app; on Windows click "More info → Run anyway" in SmartScreen; on Linux run chmod +x on the AppImage. You can also run from source: cd desktop && npm install && npm start.How do I connect WeChat or Feishu?
agentica[gateway] and run agentica-gateway; then WeChat/WeCom/Feishu/Telegram can reach your local agents directly, addressed with @session-name or routed by the gateway agent across all sessions. See the project's Gateway documentation.