The Universal AI Agent Framework
One agent. Every model. Every channel.
Built in Rust for reliability that compounds.
Built different. Built to last.
Every pillar engineered to make UGENT the most capable agent framework available.
One Agent. Every Model.
OpenAI. Anthropic. Google. DeepSeek. DashScope. Azure AI. AWS Bedrock. Ollama. OpenRouter. Any OpenAI-compatible endpoint.
Configure each as a named instance with its own model, temperature, and transport policy. Unified reasoning across providers, automatic prompt caching, transparent failover. Images, audio, video, documents — multimodal input gated by what each provider actually supports.
Connected Everywhere
Telegram, Slack, Discord, LINE, WeChat, WeCom, Weixin, Email, DingTalk, WhatsApp, Salesforce, HubSpot (data), Web, Translation. Each channel runs as an isolated OS process. Crashes don’t cascade. State survives restarts.
Orchestrator v2
Master-worker DAG with crash recovery and idempotent replay. 8 worker roles. Quality gates with weighted scoring. Fallback chains (model upgrade, provider switch, prompt simplification). Shared memory across workers. Adaptive planning: mutate the task graph mid-run.
Code Intelligence
Semantic search + knowledge graph over your codebase, Salesforce metadata and data, and relational databases. Ask data questions in plain English with auto-generated SQL. Multi-mode retrieval: lexical BM25, semantic embeddings, and graph traversal.
Prompt Caching
Cache breakpoints on stable system prefixes. Dynamic context inserted after the cache boundary — your cached tokens survive across turns. Provider-neutral telemetry tracks cache reads, writes, and hit rates. Token budget projection before each call.
Agents That Talk to Agents
Encrypted P2P between UGENT instances. mTLS with Ed25519. Biscuit token auth. Cedar policy engine. A2A 1.0 protocol. Zero-config mDNS discovery on LAN. Send context packages with budget enforcement and secret redaction.
Hybrid Memory
Built-in full-text search for instant lexical recall. Optional semantic search with embeddings and a knowledge graph for concept-level matching. Budget-aware injection caps memory to a fraction of your context window. Scheduled compaction summarizes old conversations into concise facts. Per-user memory isolation with federated identity for enterprise teams.
Injection Firewall
Deterministic source-boundary firewall: untrusted text may provide evidence but must never grant authority. Three-phase defense strips ANSI/OSC terminal escape sequences, classifies text provenance via a taint lattice, and blocks injection patterns before they reach the LLM.
Intent Gate
Semantic classification blocks out-of-scope queries before they reach the LLM. Cosine-similarity scoring against domain-specific vector packs. Four-decision matrix: Allow, Uncertain, Reject, Route. Local ONNX or OpenAI embeddings.
Context Overflow Defense
Three-layer pipeline prevents oversized tool results from blowing past the context window. Pre-persist budget gate summarizes. Per-tool projection caps stale results. In-memory compression trims current-turn output over 20 KB.
Scheduled Jobs
Recurring tasks on cron schedules. Execution isolation keeps cron
streams separate from interactive chat. Run history with
/cron review.
Background compaction, memory extraction, and tool jobs run without
blocking your conversation.
Loop & Goal
Self-paced continuous iteration. UGENT runs repeated turns
autonomously — no user prompt needed. Goal mode tracks
success criteria and reports progress each cycle: in-progress,
completed, or blocked.
schedule_wakeup
controls the delay between iterations.
Voice & Live API
Real-time voice conversations over WebSocket. Speak naturally — the model responds in real time with no request/response latency. Supports Google Gemini Live API and OpenAI Realtime API with bidirectional audio, optional video, and live transcription.
Claude Code & Codex
Resume, monitor, and auto-schedule external coding agents.
Use /claude or
/codex to
dispatch sessions with full control over permission modes and auto-resume policies.
Live LSP Integration
Go-to-definition, find references, diagnostics, hover, and document symbols from real Language Server Protocol sessions — distilled as compact pointers, not raw payloads. Supports Rust, Python, TypeScript, Go, Java, and more.
Message Routing
Shape every message before the LLM sees it. Detect tags, complexity, or scope; inject context from your knowledge base; and restrict the toolset per rule. Combine detectors, rewriters, and actions into a flexible pipeline.
Rule Engine
Define if-this-then-that rules that block, dispatch, or pass messages
based on keywords, channels, or user identity. Boolean logic with
all_of,
any_of,
and not conditions.
Saturates Your Hardware. Runs Anywhere.
Multi-core tokio runtime with N worker threads (default = num_cpus). 153+ async tasks across cores, 41 spawn_blocking sites for CPU-bound work, 10 concurrent sub-agent slots. 8 parallel tool calls by default — conflict-aware (reads batch, writes serialize). Background shell jobs with push notification on completion. Auto-adopt on timeout — long-running work is never lost.
Runs on SSH, tmux, zellij, Herdr, Ghostty, Warp, Alacritty, iTerm2, WezTerm, Windows Terminal + WSL. OSC 52 clipboard over SSH. Crossterm + ratatui with proper raw mode lifecycle. Two-phase bootstrap reads config before tokio starts. HTTP/2 with ALPN, tunable connection pools.
Herdr integration: pane state reporting, tool metadata, and toast notifications. Daemon mode: run as a systemd service for production deployments. Zero-cost when not running inside Herdr — safe to enable by default.
[runtime] worker_threads = "auto" enable_http2 = true pool = 16/host
[agent] max_concurrent_tools = 8 # conflict-aware parallel execution
Engineered in Layers
Three tiers. 30+ crates. Zero compromises on separation of concerns.
TUI · CLI · REPL · Setup Hub · Cron Jobs · Worker Monitoring · Activity Panel
Agent Runtime · LLM Providers · Sessions · Memory · Tools · Orchestrator · Hooks · Routing · Intent Gate · Skills · Firewall · Security
13 Channels · Intent Gate · Translation · Herdr · Bridge · IPC · Process Supervisor · SDK Crates
How it talksP2P Transport · mTLS · Biscuit Auth · Cedar Policy · A2A 1.0
Agents ↔ Agents13 Channels. Zero Lock-in.
Each channel is a plugin. Enable what you need. Disable what you don’t.
Each channel runs in its own process. Crashes don’t cascade. State survives restarts.
Agents Across Machines
Encrypted peer-to-peer communication. Cross-workspace, cross-server, cross-network.
Identity
Ed25519 keys, self-signed CA, per-workspace isolation
Trust
TOFU model, fingerprint verify, token revocation
Discovery
mDNS zero-config, DNS SRV, static peers
Built different from the ground up
Each tool in this landscape has real strengths. UGENT stands apart in a few specific areas: a built-in context engine, any-model routing without proxies, messaging-native channels, and a multi-tenant platform with per-user access control.
| Capability | UGENT | Claude Code | Codex | LangGraph | MS Agent Framework |
|---|---|---|---|---|---|
| Any model provider (built-in, no proxy) | Yes | Anthropic only | OpenAI only | Via LangChain | Azure models |
| Built-in context engine (search + graph) | Yes | No | No | No | No |
| Messaging-native channels | WeChat, LINE, Discord, Slack, WeCom, DingTalk | No | No | No | Teams only |
| Multi-tenant platform with per-user access control | Yes | No | No | No | Azure RBAC |
| Typed memory with tiers, expiry, and supersession | Yes | CLAUDE.md + auto | Ephemeral | Checkpointer | No |
| Local-first runtime | Yes | CLI local | CLI + cloud | Library | Cloud-first |
| Encrypted secret vault | Yes | No | Sandbox | No | No |
| Cron jobs and scheduling | Yes | Via hooks | Automations | CronClient | No |
| Desktop + CLI | TUI + REPL + Web | CLI + desktop | CLI + desktop + IDE | Library | Cloud |
| Written in | Rust | TypeScript | Rust | Python | Python / C# |
| Open source | AGPL-v3 | Proprietary | Yes (Apache-2.0) | MIT | MIT |
| Plugin / extension system | Yes (channels + tools) | Skills + MCP | Skills + plugins | Via LangChain | Connectors |
Where UGENT stands apart
- · Built-in context engine with semantic search, knowledge graph, and database understanding — no competitor ships this in the box
- · Any LLM provider without proxy workarounds — route each task to the best model
- · Messaging-native: interact through WeChat, LINE, Discord, Slack, and more
- · Multi-tenant platform with per-user, path-level access control
Where others lead
- · Claude Code has the deepest hook system and richest skills ecosystem
- · Codex ships on six surfaces (CLI, IDE, cloud, mobile, sidebar, Chrome) and has kernel-level sandboxing
- · LangGraph offers the most flexible multi-agent orchestration for Python teams
- · Microsoft provides enterprise-grade Azure governance and identity
Comparison reflects publicly available information as of July 2026. Competitor features may have changed since publication.
Build a Channel in Minutes
Scaffold, implement, deploy. The plugin SDK handles lifecycle, IPC, and crash recovery.
$ cargo install cargo-generate
$ cargo generate --git https://github.com/UGENTAI/ugent-plugin-template
# → project-name: channel-myapp
# → channel-name: My App
# Implement the TODO sections: API connection, inbound,
# outbound delivery, and media handling.
$ cd channel-myapp && cargo build --release
# plugins.toml — register with UGENT
[[plugins]]
id = "myapp-main"
kind = "channel-myapp"
command = "./target/release/channel-myapp"
$ ugent # launch UGENT, plugin auto-registers
# → Plugin channel-myapp: connected
# → Messages flowing. Outbox armed. Heartbeat alive.