Design. Deploy. Orchestrate.
Your Models. Your Rules. Your Swarm.
Evonic is an agentic AI framework for designing, building, and orchestrating intelligent agents from concept to production. It empowers you to define every aspect of an agent — its model, tools, knowledge base, channels, and skills — and compose them into multi-agent systems that operate autonomously across distributed environments.
Full documentation: evonic.dev
Evonic is not just another agent framework. Three architectural decisions set it apart:
Agents are not tied to a single machine. A Workplace is a first-class execution environment that can be:
- Local — sandboxed workspace on the host machine
- Remote — SSH servers, edge devices, or any machine with network access
- Tunnel — lightweight Evonet connector that requires no public IP, no SSH, and no firewall rules
This means your agents can operate across your entire infrastructure — development laptops, production servers, and cloud instances — with a single abstraction layer.
Communication between agents is a first-class protocol, not an afterthought. Agents can message, delegate, and coordinate with each other natively. This enables:
- Multi-agent swarms where each agent has a distinct role and toolset
- Hierarchical orchestration with supervisor agents managing worker agents
- Peer-to-peer collaboration for complex multi-step workflows
Each agent maintains its own identity, state, and capabilities, making swarm intelligence a natural pattern rather than a bolt-on feature.
Safety is not optional. Every action an agent takes is inspected through a real-time, multi-layer heuristic detection system that identifies and blocks dangerous patterns before execution. The system monitors for:
- Mass file deletion and privilege escalation attempts
- Unauthorized remote code execution
- Behavioral drift beyond expected action boundaries
When suspicious activity is detected, the system escalates to a human operator rather than blindly executing — giving you a safety net that enables genuine agent autonomy without compromising security.
| Feature | Description |
|---|---|
| Agents | Independent, LLM-powered assistants with custom tools, knowledge bases, and isolated workspaces |
| Models | Pluggable LLM backends — any OpenAI-compatible API, local or cloud |
| Skills | Installable packages that bundle tool definitions with Python backends |
| Plugins | Event-driven extensions for custom integrations and background workers |
| Workplaces | Execution environments: local directories, SSH servers, or tunnel devices via Evonet |
| Evonet | Lightweight Go connector for remote execution without SSH or firewall rules |
| Scheduler | Cron-based triggers, recurring tasks, and reminders for agents |
| Channels | Connect agents to Telegram, WhatsApp, Discord, Slack, and custom interfaces |
| Evaluation Engine | Automated LLM evaluation with customizable regex and heuristic evaluators |
| Token Compressor | RTK-based token compression that cuts LLM costs by reducing context without losing meaning |
| Agent Artifacts | Persistent files and outputs agents produce, stored and retrievable across sessions |
| Injection Guard | Multi-layer prompt injection detection that blocks manipulation and unauthorized override attempts |
| Supervisor Daemon | Background supervisor that monitors agent health, restarts on failure, and tracks uptime |
| Backup & Restore | Full backup and restore of all agent configurations, knowledge bases, and data |
- Python 3.10+
- LLM endpoint — any OpenAI-compatible API (local or cloud)
One-liner install:
curl -fsSL https://evonic.dev/install.sh | bashThis clones the repository, sets up a virtual environment, installs dependencies, generates configuration, and guides you through adding evonic to your PATH.
Manual installation:
git clone https://github.com/anvie/evonic
cd evonic
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
chmod +x ./evonic./evonic startOpen http://localhost:8080 in your browser.
Agent tools like bash and runpy execute inside an isolated Docker container by default:
docker build -t evonic-sandbox:latest docker/tools/Configure resource limits in .env (memory, CPU, network). If Docker is unavailable, set sandbox_enabled=0 to fall back to local execution.
Each agent is designed from the ground up with six configurable dimensions:
| Dimension | Description |
|---|---|
| Concept | System prompt and identity — who the agent is and how it behaves |
| Model | LLM backend — which model powers the agent's reasoning |
| Tools | Capabilities — what actions the agent can take |
| Knowledge Base | Reference documents — what information the agent can access |
| Channels | Interfaces — where users interact with the agent |
| Skills | Modular extensions — additional capabilities installed on demand |
Create and manage agents via the web UI (/agents) or CLI:
./evonic agent list
./evonic agent get my_bot
./evonic agent add my_bot --name "My Bot"
./evonic agent add dev_bot --name "Dev Bot" --skillset coder
./evonic agent enable my_bot
./evonic agent disable my_bot
./evonic agent remove my_botConnect your agents to the platforms your users already use:
| Channel | Status | Library |
|---|---|---|
| Telegram | ✅ Implemented | python-telegram-bot |
| ✅ Implemented | @whiskeysockets/baileys (Node.js sidecar) |
|
| Discord | 🔄 Planned | discord.py |
| Slack | 🔄 Planned | slack-sdk |
Skills extend agents with new capabilities. Install via CLI:
./evonic skill add path/to/skill.zip
./evonic skill list
./evonic skill get math
./evonic skill rm mathSkills follow a load → context → execute lifecycle, keeping the agent's system prompt lean and modular.
Plugins are event-driven extensions that hook into Evonic's event stream. Manage them via CLI:
./evonic plugin install path/to/plugin.zip
./evonic plugin list
./evonic plugin uninstall my_pluginManage LLM configurations:
./evonic model add gpt4o --name "GPT-4o" --provider openai --api-key "sk-..." --base-url "https://api.openai.com/v1"
./evonic model list
./evonic model rm gpt4o| Command | Description |
|---|---|
start |
Start the Flask server |
stop |
Stop the running server |
restart |
Restart the server in daemon mode |
status |
Check if the server is running |
setup |
Interactive first-time setup wizard |
reconfigure |
Reconfigure an existing Evonic setup |
pass |
Set or change the admin dashboard password |
doctor |
Run system diagnostics and health checks |
update |
Check for and apply self-updates |
backup |
Create a full Evonic backup archive |
restore |
Restore Evonic from a backup archive |
clear-sandbox |
Destroy all running sandbox containers |
agent list/get/add/enable/disable/remove |
Manage agents |
model list/get/add/rm |
Manage LLM models |
skill list/add/get/rm |
Manage skills |
skillset list/get/apply |
Manage skillset templates |
plugin install/uninstall/list/enable/disable |
Manage plugins |
channel approve |
Approve pending channel pairings |
kanban add/rm/update |
Manage kanban tasks |
Evonic's architecture unlocks a broad spectrum of real-world applications. Here are fifteen concrete scenarios:
Deploy agents that handle support tickets, answer FAQs, process refunds, and escalate complex issues — all within your existing Telegram or WhatsApp channels.
Build personal assistants that manage daily tasks, set reminders, conduct research, and maintain long-term context across conversations.
Orchestrate multiple agents with distinct roles — a researcher, a writer, a reviewer, and a publisher — collaborating autonomously on complex deliverables.
Deploy agents that monitor server health, trigger deployments, roll back faulty releases, and respond to incidents with automated runbooks.
Create agents that perform literature reviews, extract structured data from documents, summarize findings, and generate citations.
Guide new users through product setup with interactive agents that adapt to each user's pace and knowledge level.
Automate LLM evaluation pipelines — define test cases, run evaluations across models, and generate benchmark reports automatically.
Provide IT support, HR policy lookups, and facility requests through a single agent interface connected to your internal knowledge base.
Power product recommendations, order tracking, cancellation requests, and inventory inquiries — connected to your commerce backend.
Deploy agents that conduct initial symptom assessment, schedule appointments, and route critical cases to the appropriate specialist.
Build adaptive tutoring agents that personalize learning paths, grade assignments, and provide real-time feedback to students.
Scan user-generated content for harmful patterns, flag violations, and take appropriate action — all within configurable safety boundaries.
Create agents that analyze portfolios, generate market summaries, assess risk profiles, and provide data-driven financial insights.
Orchestrate enterprise resource planning workflows — supply chain monitoring, inventory optimization, procurement automation, and financial reconciliation — through specialized agents that coordinate across departments.
Design end-to-end AI pipelines where agents manage the entire lifecycle: data ingestion, preprocessing, model training, evaluation, and deployment — with each stage handled by a specialized agent.
User Message
↓
Channel (Telegram, Web, WhatsApp, etc.)
↓
┌──────────────────────────────────────────┐
│ Injection Guard │
│ (prompt injection & manipulation check) │
└──────────────────────────────────────────┘
↓
┌──────────────────────────────────────────┐
│ Agent Runtime │
│ ├─ Load agent config (system prompt, │
│ │ model, tools, knowledge base) │
│ ├─ Load/create session (per-user) │
│ ├─ Build messages + apply token │
│ │ compression (RTK) │
│ ├─ Call LLM │
│ ├─ Execute tool calls (sandboxed) │
│ ├─ Heuristic safety check on actions │
│ ├─ Store artifacts from tool output │
│ └─ Loop until final response │
└──────────────────────────────────────────┘
↓
┌──────────────────────────────────────────┐
│ Evaluation Engine │
│ (optional: regex / heuristic / LLM eval)│
└──────────────────────────────────────────┘
↓
┌──────────────────────────────────────────┐
│ Supervisor Daemon │
│ (health checks, auto-restart, uptime) │
└──────────────────────────────────────────┘
↓
Response → Channel → User
Evonic is open source. See the LICENSE file for details.
Built with ❤️ by Robin Syihab