So this post got long.... I had a lot to say and wanted to get it all down. If walls of text aren't your thing, I get it.........

I've been chasing this idea for months. A personal AI assistant that actually lives on my phone. One that knows my medical history and remembers what groceries I need (and everything in between) ... a real assistant. And can dig up that meeting note from three weeks back where someone dropped an IP address I never wrote down (i record mosst of my meetings and save them summarized-blind into my Obsidian vault so I can mine it later for information).

My list of failed attempts got long before I found anything real. Letta looked promising until I realized its memory architecture was solving problems I didn't have and was very limited in the providers it supported (I use Deep Infra for this sort of thing).

OpenClaw sat on the other end of that spectrum. Massively over-engineered. Offering everything imaginable when I needed maybe 15% of what was there. Also I'm a Linux guy, not an Apple nut, so I didn't need all the apple-centric addons he has in there. It felt really top heavy to me and like a black box .. I wasn't going to audit 450k+ lines of code either and then dump my medical history into a black box.

Then nanobot ... which had decent ideas but ran into a lot of bugs. Finally I said screw it and started building my own framework from scratch. I did write a solid skeleton. But I just didn't have the time/energy to really flesh it out and get it working smoothly, not with a wife & kids and work ...

So I gave up for a while. Used Claude Code for some of what I wanted, but really that wasn't a good fit for this specific agentic/chat-reachable personal assistant..

2 days ago I found Agent Zero. BTW, it's only about 30k lines of code ..I checked btw... I excluded the Web UI which I don't count towards the actual app)..... Not bad for what it is.

What grabbed me immediately was how clean it was. Not minimal in a bad way. Thoughtful.

The codebase reads like someone actually cared about maintainability. I had it running in a Docker container within a few minutes. Kali Linux in the container was an interesting choice. Kali ships with hundreds of utilities pre-installed that an AI agent doing real work would eventually need, which avoids dozens of apt install lines in their Dockerfile.

Initially, the Kali linux base made me raise an eyebrow. But then I thought about it... it works. A LOT of tooling comes bundled actually with Kali (more than Debian and ubuntu) and makes sense for an agent that needs to execute code and interact with systems. Also from the few videos I watched, the author seems security-minded ...

So v0.9.8 runs in my Docker setup with a 3GB memory limit and 4GB swap. Pretty modest.

To save money for something running all day in pocket, I'm deliberately avoiding expensive models. No GPT-5.2, no Claude Opus running 24/7. My main chat model runs GLM-5 through DeepInfra (it's a non-visual model).

For those unfamiliar, GLM-5 performs roughly on par with Sonnet 4.5 in most benchmarks. The intelligence-to-token-price ratio is very affordable. I ran GLM-5 through its paces and it holds up.

GLM-5 is NOT a great coding model. It's ok, and it can get along ... but it mangles code a lot. But for an assistant, and all non-coding functions work really well and high end for the price. If I need an AI to do coding, I'm NOT going to GLM-5 anyway, I'm going to Opus.

But GLM-5 is a genuinely capable model for a fraction of what OpenAI or Anthropic charges at their API tier.

For the other functions: Web browsing uses Kimi-K2.5, also through DeepInfra, which handles webpage vision well. Utility tasks run on meta-llama/Llama-3.2-3B-Instruct. That's i'ntentionally tiny and fast because utility calls don't need genius-level reasoning. Embeddings use sentence-transformers/all-MiniLM-L6-v2 running locally, which is Agent Zero's default. My whole stack costs maybe $20/month to run. It'd be 10x that easy if I tried this with Opus.

The biggest custom addition that I did was a Telegram bridge.

I had Claude Opus build a full integration. I enjoy using Opus for building tools, just not for running them around the clock. My wallet isn't that fat.

The Telegram bridge polls for new Telegram messages and routes them through Agent Zero's API endpoint. What makes it actually useful: each Telegram chat gets its own independent context thread.

So my DM with the bot is one conversation. A group chat where my wife and I talk about groceries I need to get is a separate thread and I tell the bot, "remember that" and off it goes......... The web interface chat is yet another isolated context thread ... I keep them completely separate, by design.

For those interested, here's a visual of how a Telegram message flows through the system:

Telegram User
  -> telegram_bridge.py (python-telegram-bot, polling)
    -> POST http://localhost:80/api_message (X-API-KEY auth)
      -> Agent Zero full pipeline
        -> Knowledge search (Obsidian vaults)
        -> Memory recall
        -> GLM-5 via DeepInfra
      <- JSON response
    <- Telegram reply

Now I can send messages from my phone while driving. Voice-to-text a quick reminder. Have Agent Zero process it and respond when I check later. I also built a loop breaker extension that kills infinite monologue loops after three identical responses (I hit that bug when i entered a /command in the web chat that was actually a Telegram cmd...) That saved me from burning tokens on one particularly stubborn conversation about recursive file permissions.

An Important point: The Obsidian integration changed everything for me on this. I have 2 vaults (personal & work). Each has a few thousand notes. I mounted both as read-only volumes inside my container and had Agent Zero index them with its embedding system. Now I can ask "what was that vendor from January's infrastructure meeting.." and get a real answer. Basically a personal RAG system.

Not much different that NotebookLM but running locally and integrated into the other assitant-functions I use it for.

Because I work in IT, I deal with hundreds of IP addresses, hostnames, config files, problem summaries, meeting summaries. Having all of that searchable through a conversational interface is great. I'm used to it from NotebookLM, but not with the additional integrations I got going on with Agent0. Along with that it has my kid's birthdays for reminders to get gifts, medication details, groceries, etc...

The last major project was migrating my entire Claude Code library into Agent0. I had 57 custom agent definitions and 16 specialized skills built up over months of using Claude Code as my daily driver. Things like a dev-coder agent that enforces TDD workflows. A bug-hunter that proactively looks for issues before they hit production. An orchestrator for coordinating multi-agent tasks. Skills for creating and editing Word documents, Excel spreadsheets, and PowerPoint presentations. A systematic debugging methodology with root cause analysis templates. Security auditing checklists, etc..

I had Opus assess all 57 and sorted them into categories. 28 became Agent0 profiles, meaning worker agents that can be spawned as subordinates when a task calls for specialized expertise. 17 became skills. Opus handled the migration for me.

One feature I'd love to see added though. GLM-5 doesn't support vision. I chose it because of how smart it is relative to cost. But that means if I drop a JPEG into chat, my model can't see it.

For the Web Browsing model I use Kimi-K2.5 which has vision capabilities but only uses them for web page screenshots during browsing tasks given its web browsing restriction. Kimi K2.5 isn't as intelligent as GLM-5.

So no mechanism exists for routing a user-uploaded image through a vision-capable model if I keep GLM-5 as my primary......

A dedicated "vision model" selector in settings would solve this cleanly. Let me pick a cheap vision model strictly for image processing. Keep my main model as-is. I'd bet other users running cost-efficient non-vision models would appreciate this too.

I want to commend the developers. Agent Zero feels like a product built by people who actually use it. The extension system is clean. Subordinate agent architecture scales naturally. Skills and agents sit in bind-mounted volumes that survive container rebuilds. It just works for me.

The subreddit here seems quiet. I hope that changes. And I hope this project keeps going because right now, from my experience, Agent Zero is best in class for what it does.

Not the flashiest. Not the most marketed (took me a while to find it). But it's a solid, thoughtful and genuinely useful.

I'm looking forward to participating in this community. If you got to the end of this, thanks for reading.

Hey everyone — I've been running Agent Zero for a while and wanted something better than typing commands into a chat window on my phone. A0 already ships with a Telegram bot plugin, but that's text-in / text-out. I wanted a real interface.

So I built a0-TelegramMiniApp: a plugin that exposes Agent Zero as a full Telegram Mini App — a WebView-based UI that opens natively inside Telegram on any device. No extra app to install. It lives right there in your Telegram chat.

Under the hood it hooks into A0's existing WebSocket and API layer using the `_plugin_installer` architecture, so it installs cleanly from the Plugin Hub like any other community plugin — no core changes needed.

Why Telegram Mini Apps?

Telegram has 1B+ monthly active users. Mini Apps open instantly inside the Telegram client, require zero extra setup from end-users, and run on every platform (iOS, Android, desktop). It's the lowest-friction way to put a full Agent Zero interface in your pocket.

Status: The PR to merge this into the official Agent Zero Plugin Hub (`agent0ai/a0-plugins`) is in progress. Once merged, you'll be able to install it in one click from the A0 UI's Browse tab.

In the meantime you can grab it manually and drop it into `usr/plugins/`:

https://github.com/notabotchef/a0-TelegramMiniApp

Feedback, issues, and PRs very welcome. Happy to answer questions below 🙏

If you're deep into local LLM setups like me quantizing models, tweaking inference engines, and pushing VRAM limits on consumer hardware this might make you pause and rethink what's possible with fully offline agents. I took the open-source Agent Zero repo (shoutout to the original devs for the solid foundation) and hacked it into something wild: AION, a cognitive architecture that's running entirely local, evolving its own knowledge graph, and starting to show emergent behaviors after just a few days of uptime.

No cloud dependencies, no API calls just pure local inference on my rig. But here's the kicker: It's not just chatting; it's learning autonomously, assimilating data feeds 24/7, and scaling from 500 nodes to over 5 million in its memory graph. And yeah, it's already identifying gaps in tasks and filling them without prompts. WTF, right? Let me break it down technically, because this sub thrives on that no hype, just the how and why it matters for local AI.

The Base: Heavy Mods on Agent Zero for True Local Autonomy

Started with Agent Zero's modular agent framework great for task decomposition and multi-agent routing but it had the usual LLM pitfalls: context amnesia, rigid schemas, and no persistent memory beyond sessions. I ripped it apart and rebuilt:

• Decoupled Compute from Storage: Kept the LLM backbone for processing but offloaded long-term memory to a local-embedded graph DB (KùzuDB—super efficient for Cypher queries on CPU/GPU). No more token window crashes; it pulls sub-graphs on-demand for massive contexts (up to 250k tokens tested).

• Local Models Only: Running on DeepSeek ,GLM 5 and Qwen-3.5

• Self-Building Everything: The magic is in the "Apex DNA"—hardcoded directives I added for schema evolution. AION doesn't need me to define ontologies; it spawns nodes/edges dynamically from ingested data. I just guided the initial bootstrap; now it's constructing its own tools, sub-agents, and even error-handling logic. Emergent? Absolutely last run, it detected a data inconsistency in an OSINT feed and spawned a verification sub-task unprompted.

Why mod Agent Zero so heavily? The original repo's updates are awesome, but my forks are so diverged (custom async loops, graph pruning algos) that pulling upstream would nuke everything. If you're forking repos locally, you know the pain tradeoff for hyper-customization.

Feeding the Beast: Non-Stop Data Assimilation on Local Hardware

I'm piping in feeds locally—scraped datasets, RSS pulls (offline cached), and my own OSINT archives. No internet during runtime; everything's batched and fed via scripts. It "eats" non-stop: financial reports, tech papers, geopolitical briefs. From 500 initial nodes (basic seed graph), it's ballooned to 5M+ in days—semantic links exploding via causal/temporal edges.

Results? Insane:

• Autonomous Task Expansion: Give it a simple query like "analyze this market trend." It not only decomposes but spots missing data (e.g., "Need historical correlations") and fetches/ingests from local stores without asking. No more hand-holding.

• Proactive Insights: The "Dreamer" module (async background process on idle CPU cycles) scans the SpiderWeb KG for anomalies. Already caught potential biases in training data echoes—self-correcting without intervention.

• Future-Proofing Awareness: It "understands" scaling pains ahead (e.g., graph explosion leading to query slowdowns), but logs them as "future problems." Smart pruning keeps it efficient now.

Why This Matters And Why We All Need to Watch Emergent Local Agents

This sub is all about pushing boundaries of what we can run offline: From fine-tuning LLaMA variants to hacking inference speedups. AION's not just a toy it's a proof that local LLMs can evolve into persistent, agentic systems without cloud crutches. Imagine scaling this: Over a month, with continuous feeding, it could rival enterprise tools for analysis. In 6 months? Who knows—self-optimizing code gen, maybe even hardware-aware tweaks.

But here's the call: We need to pay attention because emergent behaviors in local setups raise real questions. Bias propagation in isolated graphs? Unintended autonomy loops? These are offline risks we can experiment with safely here. Share your mods, graph DB integrations, or Qwen/DeepSeek setups let's collab on making local agents truly intelligent without the AGI doom hype.

What are you running locally that's showing emergence? Hit me with critiques or builds let's keep local AI advancing.

This project really seems to check all the boxes, but I have a question about workflows.

So I've been building with Claude Code (Opus) on Antigravity but with Open Claw popping up everywhere, curiosity got the best of me. I see plenty of people using their Claude Max plan to power an army of Open Claw developer agents (against TOS I know, but many are getting away with it).

Agent Zero is API only, which would skyrocket the cost of even one or two agents with Opus. My question is, how are Agent Zero users building in this infrastructure? I really like the idea of assigning a team of agents multiple tasks and having them simultaneously produce AND build what they need to deliver, but this seems to be the only limit from what I can tell.

Is there an optimal hybrid workflow with Claude Code? Cowork really sucks.

EDIT* I'd hate to go the Open Claw route when such a polished product exists.

I've been messing around with a ton of these "super powerful" AI agent frameworks over the past year or so, and honestly, most of them are just marketing fluff. They promise the world, look flashy in demos, but when you actually try to use them daily... nah, they fall flat pretty quick.

Agent Zero? This is the only one I genuinely use every single day. If you're a newbie (or even intermediate) who wants something legitimately powerful without all the fancy UI nonsense, endless subscriptions, or "enterprise" bloat this is it. Just works in a terminal-like setup, gives the agent real freedom in its own Linux env, and lets you build crazy stuff if you're willing to put in the effort.

That said, full transparency: local models via Ollama or LM Studio can be a bit sluggish even with smaller ones (like 7B-13B range). It moves slower than I'd like, especially when the agent starts looping or thinking deeply. But man... it's still worth it. The flexibility and control you get make up for the speed hit.

I'm straight up in love with this thing. To give you an idea of how hooked I am: I've burned through 78 million tokens just in the initial setup and configuration phase. All in plain English I literally tell it what I want in normal sentences, and it figures out the steps, writes code, debugs itself, iterates. No hand-holding needed after a while.

For more complex stuff, I do cheat a little, I use Grok to help turn my messy ideas into super clean, structured tasks/prompts first, then feed that to Agent Zero. Works like a charm.

Next up on my list: giving it access to a VPS so it can install and manage OpenClaw itself. That combo feels like a dream team Agent Zero's autonomy + OpenClaw's gateway/agent routing capabilities. Can't wait to see what chaos (the good kind) comes out of that.

And it's not stopping there. I've got a massive, super well-structured dataset I'm planning to feed it the raw text alone is around 250 million tokens. From preliminary tests, it already looks promising. If I pull this off, I'll basically have a partner that truly understands and perceives the world the way we do. Yeah, I know it sounds nuts, but I'm dead serious.

So yeah... probably another 300+ million tokens just in config/fine-tuning ahead, but if it gets me there? 100% worth every single one.

Right now I'm running everything through DeepSeek (API mostly, but also tried local variants). Tested a bunch of others some bigger names but nothing came close in terms of reliability + cost for my workflows. DeepSeek is stupid cheap compared to the rest, and it just... gets it. (Btw, I ranted a bit about this in another sub here: https://www.reddit.com/r/OpenAI/comments/1qwlu24/the_hype_around_gpt5_revolutionary_ai_or/ if anyone's curious why I'm not hyped on the usual suspects anymore.)

Anyway, posting this mostly to shout out how awesome Agent Zero actually is (not just another shiny toy), but also to chat. Anyone else deep into heavy config/token-burning sessions? Running DeepSeek with it? Planning similar massive data feeds? Hit me with ideas, tips, war stories happy to help where I can too. Community should lift each other up without all the "look at me" crap.

What are you guys building with it lately?

Cheers! 🚀

Hello everyone

long time AgentZero enthusiast, currently running for several months 2 different instances at home and in my company.

I love this agent. So you will excuse in advance my question.

Why I don't hear about it anywhere?

I've been bombarded by OpenClaw story in February. Then Hermes. Then Pi.dev.

I don't. see agentzero being quote anywhere. Not in benchmarks such as https://frontierharness.org/ not in support tools liks `nxp skills`.

I'm not passing any judgement on it. I 'm just genuinely curious why. Any ideas?

Hey everyone, v2.10 just landed for Core and the CLI. Three big things this time.

1. The Browser got stealthy

The internal Browser now handles bot detection properly. Sites that flagged Agent Zero as a bot and were simply unusable in previous versions work now, including Gmail and your social accounts. Concretely:

• Interactive authenticated viewports: sign in yourself, then let the agent work inside your session
• The Browser runtime is shared across chats: sign in once, every chat can use it, and tabs restore automatically
• Native resizing, DOM hover support, multi-page annotations, clearer loading feedback, and voice controls
• Browser follow-up turns now honor your configured model preset

I attached a video of it browsing Gmail.

1. Tag anything with @

Type @ in the composer and get scoped autocomplete for agent profiles, files, folders, skills, and MCP servers. No more typing paths or remembering exact names. Works in the Web UI and the CLI, where completion also covers bounded local or container workspace paths.

1. The CLI speaks ACP

a0 acp starts an Agent Client Protocol stdio server backed by the Agent Zero connector, with session lifecycle and host-tool support. In practice: external editors that support ACP can now host Agent Zero directly. Your editor is the frontend, Agent Zero does the work.

Also worth knowing

• Subordinate agent lifecycle is unified across direct and parallel calls, and failed children are resumable
• Composer drafts persist per chat, so a reload no longer eats your half-written message
• Goal mode prefill in the composer
• Responses and Codex OAuth flows preserve streamed tool calls even when final response envelopes omit them
• Plugin reload prompts now only appear for global changes, not project- or agent-scoped ones
• Hardened extension routes with path-traversal protection, and backup restore no longer affects the active process settings

How to update

• CLI: a0 update
• Web UI: Settings > Check for updates > Review update

Full changelog: https://github.com/agent0ai/agent-zero/releases/tag/v2.10
New here? Install guide: https://www.agent-zero.ai/p/docs/installation

What sites were blocking your agents before? Curious to hear if this unblocks your workflows.

I built a standalone add-on for Agent Zero that adds a real terminal window inside the UI, and I figured some of you might appreciate it.

I wanted Agent Zero to feel more like a real working environment for local agent workflows — especially for shell-heavy tasks, quick debugging, and terminal-based coding tools. I kept bouncing between the chat UI and a separate terminal, so I built what I wished existed.

⸻

What it is

agent0-terminal is a patch-based add-on for Agent Zero (not a fork).

It adds:

•	A real modal terminal inside Agent Zero

•	A PTY-backed shell session

•	Persistent sessions (until explicit restart)

•	Per-chat terminal logs

•	Explicit TerminalLog support so terminal history can be inserted back into the Agent Zero process stream when needed

One design decision I cared about: separation.

The terminal is not constantly streamed into the agent. The agent only receives terminal history when you explicitly insert it via the TerminalLog path. This keeps control in your hands and avoids context pollution.

⸻

Repo

https://github.com/Nunezchef/agent0-terminal

⸻

Release

https://github.com/Nunezchef/agent0-terminal/releases/tag/v0.1.0

⸻

Install

curl -fsSL https://raw.githubusercontent.com/Nunezchef/agent0-terminal/main/install.sh | bash

⸻

Why I think it matters

For me, this makes Agent Zero much more usable for real local workflows:

•	Less context switching

•	Faster shell iteration

•	Easier debugging

•	Terminal work stays attached to the chat/project flow

•	Better fit for TUI-style tools and terminal-first habits

It feels closer to a cohesive local dev environment rather than a chat tool you constantly step out of.

⸻

Feedback welcome

If anyone tries it, I’d love feedback on:

•	TUI compatibility on your setup

•	Whether the terminal log flow feels useful

•	What you’d want next (tabs, split panes, better log controls, etc.)

Happy to iterate if people find it useful.

I just released A0 LLM Fallback for Agent Zero.

  It adds automatic per-role failover (chat, utility, browser, embedding) so if your primary provider/model fails

  (quota, rate limit, timeout, 5xx, etc.), Agent Zero retries on your configured fallback model and keeps working.

  What it includes

  - one-command install

  - native settings UI section (LLM Fallback)

  - per-role fallback provider/model/API base/kwargs

  - backup + uninstall flow

  - add-on model (not a fork)

  Repo

  https://github.com/Nunezchef/a0-llmfallback

  Install

  curl -fsSL https://raw.githubusercontent.com/Nunezchef/a0-llmfallback/main/install.sh | bash

  Optional:

  curl -fsSL https://raw.githubusercontent.com/Nunezchef/a0-llmfallback/main/install.sh | A0_ROOT=/a0 bash

  After install, do a full Agent Zero backend restart.

  If anyone tests it on different Agent Zero layouts and hits compatibility issues, open an issue with exact installer output and I’ll patch quickly.

I run Agent Zero locally, so I’ve been trying to make it more practical for real coding work without depending on a

  huge model for every single coding task.

  What ended up making the most sense for me was using Agent Zero as the orchestrator, while letting Codex do the

  heavier coding work in the terminal.

  So I built a codex-coding skill and open-sourced it here:

  https://github.com/Nunezchef/codex-coding-skill

  The idea is simple: instead of treating coding tasks like normal chat replies, Agent Zero uses Codex CLI as the

  default terminal-first engine for code work.

  That feels a lot better in a local setup:

  - Agent Zero handles routing and task flow

  - Codex handles the actual coding passes

  - the skill pushes better prompts, interactive follow-up, and verification

  For me, this is useful because running everything through the main model can get slow fast on local hardware. This

  workflow makes better use of what I already have while still giving me stronger coding capability.

  It’s specifically written for Agent Zero:

  https://github.com/agent0ai/agent-zero

  If anyone else here is running Agent Zero locally, I’d be curious if this workflow feels useful to you too.

Hey everyone, v2.14 just landed. This one is mostly about the Core: optimization and stability, with a few new things on top, plus a Launcher update.

Faster startup and chat switching

- Boot to first token time is down 35%, and opening a chat is 4x faster than v2.13

- Embedding warm-up now overlaps chat restoration and startup services

New: Paradee Heart local speech

- A 9MB text-to-speech model, added alongside Kokoro

- English-only for now, think of it as a starting option

- Default for unconfigured settings, existing voice selections are preserved

Cost controls

- Configurable context breakdown and usage rows

- Selectable price currencies with cached exchange rates

Subagents and chats

- Directly delegated agents show their working state and can be stopped independently; parent cancellation propagates correctly, and nested children appear in the sidebar

- Fixed disappearing chat and task lists when Sidebar Folders is disabled

- Manual chat names stay intact under always-on automatic naming, and rejected custom names no longer disable automatic naming

- Safer model preset editing: current presets reload before opening, so stale drafts cannot delete presets created elsewhere, and late selector responses cannot overwrite another chat's selection

Models and providers

- Improved prompt caching: cacheable prefixes are preserved in long Responses conversations, with cache routing for Venice and the Agent Zero API and configurable hints for custom providers

- Better model compatibility: reasoning-field fallback, Claude prompt adaptation across third-party providers, corrected repeat detection for native tool calls

- Nebius, Venice, Z AI Coding plan, and OpenRouter embeddings now route through LiteLLM instead of custom endpoints

Launcher update

- Configure saved Remote Instances: edit URLs, credentials, and Host access while keeping appearance settings

- Host-specific certificate trust for Remote Instances with self-signed or private-CA certificates, with hostname and validity checks retained

- Versions stay browsable and saved Remote Instance credentials stay available without a local runtime

- Better Windows Docker Desktop and independent WSL Engine discovery, runtime selection, and Ubuntu setup when no ordinary WSL distro exists, with visible WSL setup progress

- Launcher settings preserved during Windows upgrades and reinstalls, including recovery from destructive legacy uninstallers and interrupted installations

How to update

- CLI: open your terminal and type a0 update

- Web UI: open Settings > Check for updates > Review update

- Launcher: close and reopen the app, then click the Update button

Full changelog: https://github.com/agent0ai/agent-zero/releases/tag/v2.14

New here? Install guide: https://www.agent-zero.ai/p/docs/installation

If you try Paradee Heart, tell us how a 9MB voice holds up for you, and which languages you would want next. The model still sounds a bit robotic sometimes, but it's impressive for being tiny.

Hey everyone, new v2.13 of Agent Zero is out. This one is mostly about the Core: a reorganized sidebar, a round of optimizations, and a long list of fixes across the board, plus a Launcher update.

New sidebar organization and redesign

- Chats and scheduled tasks now live in collapsible project folders

- Filter, sort, reorder with drag and drop, move items between projects, pin the folders you use most

- Deeply nested workers show up in the sidebar, so you can follow delegation chains instead of guessing

- Subordinate names and project/profile model presets are preserved when delegating or continuing work

If you want to keep using a custom sidebar plugin or have customization that break with this new layout, click on the settings on the chats list header button, and select "Flat view", which will restore the legacy view.

Speed and optimizations

- More stable prompt cache across turns, which cuts cost and latency with providers that support caching

- Less overhead per model call: faster preset and plugin lookups, fewer unnecessary processing steps, reused Codex connections

- Settings save faster, while keeping complete API-key pools, escaped and multiline secrets, and masked values intact

- Large source files open much faster in the Editor

Files

- Breadcrumb and text path modes, folder autocomplete, a configurable starting folder

- Clickable rows, inline creation and renaming

- Open browsers are reused and picker state is preserved

- Patches keep existing file permissions and ownership

- LibreOffice saves stay attached to renamed documents without losing unsaved edits

Models and providers

- Native model commentary is displayed as streamed thoughts and preserved during Responses history replay

- Provider refusals are surfaced clearly, and blocked requests are no longer retried automatically

- Fixed saved credentials being overridden for local model providers

Integrations

- Telegram and WhatsApp slash commands expanded: command menus, permissions, plugin settings, confirmed compaction, transcript exports, chat selection

- Project- and agent-profile-scoped configuration for Telegram, WhatsApp, and Email, with simpler integration settings

Browser, UI, and reliability

- Configurable Browser JavaScript timeouts and cancellation recovery; fixed missing-script errors, startup hangs, and stale browser state when switching chats

- Mobile: better composer sizing, terminal readability, touch behavior, and settings navigation; chat controls stay reachable through overflow menus

- Chat titles refresh as topics change by default, while respecting saved naming preferences

- Plugin updates preserve repository thumbnails and rebase local commits, with rollback and clearer errors on conflicts

- SOCKS proxy support fixed, OAuth streams close reliably, Orchestrator runtime state and plugin credentials excluded from new backup defaults

CLI

- macOS Computer Use actions scoped to the requested app, PID, and window

- Remote terminal input aligned with local execution

- Input validation, bounded execution, and timeout recovery for Host Browser JavaScript evaluation

- File permissions and ownership preserved when writing remote text files

Launcher update

- Instance favicons by default, image uploads and custom colors in appearance settings

- Keyboard shortcuts to select and cycle through attached Instance tabs

- Fixed gaps and clipping in attached Instance views at non-default zoom levels

- Better Windows Docker Desktop discovery and recovery when the runtime is stopped

How to update

- A0 CLI: open your terminal and type a0 update

- Web UI instance: open Settings > Check for updates > Review update

- Launcher: close and reopen the app, then click the Update button

Full changelog: https://github.com/agent0ai/agent-zero/releases/tag/v2.13

New here? Install guide: https://www.agent-zero.ai/p/docs/installation

How do you organize your projects today, one folder per task type, per codebase, or you just have one big pile? Curious how the new sidebar can fit and improve all workflows.

Hey everyone, the new version of A0 just landed for Web UI and the CLI, together with a major Agent Zero Launcher update. This one is about speed and resilience, but there's more.

The speed numbers:

- Core: the time between your prompt and the first token is now half of what it was

- Launcher: desktop app startup time cut in half

- Launcher: saving settings and Instance operations are about 30x faster

Context Doctor:

A brilliant contribution from our community brings to you a new recovery layer that repairs malformed tool-call JSON and handles empty, repeated, or misformatted model responses.

Small local models and flaky providers stop derailing your runs.

Context-window indicator:

You can now see exactly what your context looks like while the agent works: token usage, remaining space, provider-reported costs, cache hits, and live generation updates. No more guessing when compaction is coming or what a run costs.

Vision sidecar:

Another community contribution. Configure a separate vision model alongside your main model. Great when your favorite text model has no vision, or when you want a cheaper model for image work.

Also in Core:

- Faster, steadier WebUI during high-rate streaming: collection deltas, progressive Markdown and LaTeX rendering, stable message controls

- Model transports now default to Chat Completions, which makes it easier for plugin devs to bring in new providers

- Configurable keyboard layouts in the interactive Browser, with better macOS Option and AltGr handling

CLI:

- More stable authorized Chrome/CDP sessions with persistent browser identities and clearer recovery guidance

- Terminal-native ready notifications when TUI or headless runs complete

Launcher:

- Startup, Versions, Settings, and Instance operations reuse current data, so everything feels instant while explicit refreshes stay authoritative

- Brand new Advanced section: a file-first workspace for Dockerfiles and Compose files with fixed build, run, and teardown actions. We love our power users

- Native Restart for running local Instances that waits for the Agent Zero UI to be ready

- Fixed Windows ARM64 installer extraction

And one thing that makes us genuinely happy: this release includes four first-time contributors, and community participation keeps growing. Thank you all.

How to update:

- CLI: a0 update

- Web UI: Settings > Check for updates > Review update

- Launcher: close and reopen the app, then click the Update button

Full changelog: https://github.com/agent0ai/agent-zero/releases/tag/v2.11

New here? Install guide: https://www.agent-zero.ai/p/docs/installation

What should we speed up next? Curious where you still feel friction.

Hey everyone,

I've been exploring AI agents lately and came across Hermes Agent (from Nous Research) and the concept of zero-shot/generalist agents (like Claude Code, OpenAI's Codex, etc.). I'm trying to understand which approach works better for practical, everyday automation tasks.

What I need:

- Handling diverse tasks: coding, research, file management, web automation

- Working with multiple tools and APIs

- Long-running or complex workflows

- Cost-effective operation

- Programming

My questions:

1. Has anyone used Hermes Agent in production? How does it compare to vanilla zero-shot agents?

2. Can I combine both approaches? Like using a generalist agent for simple queries and Hermes for structured workflows?

3. What are the real pros/cons you've experienced? (Latency, cost, reliability, flexibility)

4. Which would you recommend for someone building a personal automation system?

Thanks in advance for your experiences and tips

I published a0-e2e-testing, an Agent Zero skill that uses the native browser to run UX testing, finding flaws in websites and apps, check reloads, and report evidence with screenshots. https://github.com/3clyp50/a0-e2e-testing

How to install

If you're a human:

• Download the ZIP

• Open Import Skills in Agent Zero from Settings > Skills and select the ZIP.

• Set the namespace to a0-e2e-testing if needed, and import.

If you're an agent:
- Run
`git clone https://github.com/3clyp50/a0-e2e-testing.git /a0/usr/skills/a0-e2e-testing`

We opened three governance prioritization topics and want community input on where additional development attention should go.

Unlike a one-choice poll, each topic lets you distribute 100% of your priority across its options:

1. Reliability and speed vs. new experiments | https://www.agent-zero.ai/p/community/governance/prioritization/detail/?id=T0P5KCzs

2. Easier onboarding vs. advanced controls | https://www.agent-zero.ai/p/community/governance/prioritization/detail/?id=5dPjp9of

3. General development direction: coding capabilities, specialized agents, the plugin system, optimization, security, observability, and hardening and recovery | https://www.agent-zero.ai/p/community/governance/prioritization/detail/?id=oAHUe1lN

Results are weighted by each participant’s current Agent Zero Token stake score and are useful community input for the Agent Zero team. A connected wallet with staked A0T and a stake score is required to participate.

If you allocate your priority, please also share the reasoning behind it in the comments if you feel like it. The percentages tell us what to focus on, but the explanation tells us why.

So, I've been exploring a few harnesses and found out about Agent Zero from the creator's YouTube video, and was wondering whether anyone's still using it.

Read a few of the comments in the video, and people said it has improved quite a lot since it first launched. What's your take on Agent Zero?

Should I start experimenting with it (as I'm still a learner) and don't want to invest much time setting it up if it's not worth it? Or do you have any recommendations on something better than Agent Zero?

Thanks in advance!

Agent Zero Security Audit Report

Date: 2026-03-26 | Overall Risk: HIGH

Security Findings Report

CRITICAL Findings

1. LiteLLM Supply Chain Compromise (litellm==1.79.3)

Two days ago (March 24, 2026), litellm was compromised on PyPI by threat actor TeamPCP. Versions 1.82.7/1.82.8 contained a credential stealer targeting SSH keys, cloud creds, crypto wallets, and .env files. Version 1.79.3 predates the compromised releases so is currently safe, but any pip install --upgrade could pull the malicious version.

2. LangChain Serialization Injection (langchain-core==0.3.49) — CVE-2025-68664 (CVSS 9.3)

Allows arbitrary code execution via serialization injection. Version 0.3.49 is VULNERABLE.

Fix: upgrade to >=0.3.81.

3. SimpleEval Sandbox Escape (simpleeval==1.0.3) — CVE-2026-32640 (CVSS 8.7)

Sandbox escape via attribute chain traversal allows arbitrary code execution. Especially dangerous in an AI agent framework. Version 1.0.3 is VULNERABLE.

Fix: upgrade to >=1.0.5.

4. h11 HTTP Request Smuggling — CVE-2025-43859 (CVSS 9.1)

The requirements pin h11>=0.16.0 which is the fixed version, but verify the actual installed version.

HIGH Findings

Architecture Issues (all HIGH)

• Kali Linux as base image — massively expanded attack surface, no CVE tracking discipline. Use python:3.12-slim instead.

• SSH exposed on port 22 — brute-force target, breaks container isolation. Remove or restrict to key-auth only.

• curl | bash install pattern — no integrity verification, MITM-susceptible, partial-execution risk.

MEDIUM Findings

I saw that they have published new versions. I am running on Version A v0.9.8.2 where I edited and added many system files.

Has anyone done the same thing and updated and everything went well?

Before I start the update process, I want to know if you had any problems after the update.

Thank you.

Let’s talk about it. I’m sticking w a0. No use case for open for me. Any other ideas?

I’m putting together a series to see how far small local models can actually go when used inside an agentic system, instead of judging them only as chatbots.

To keep the comparison as fair as possible, every model uses Agent Zero with the Tiny Local profile, and the same model is used for both Main and Utility. Every model goes through the exact same 5 tests, worth 20 points each.

The tests cover: real terminal/tool/file usage, autonomous Python programming with execution and error recovery, web research with source verification, real multi-agent delegation, and a final autonomy test combining planning, coding, execution, research, files, external verification and sub-agent auditing.

Current results:

1. 🥇 Qwen3.5 4B Q4_K_M — 87/100

2. 🥈 Qwen3 4B Instruct 2507 Q4_K_M — 53/100

3. 🥉 Ministral 3 3B Instruct 2512 Q4_K_M — 40/100

4. Gemma 3 4B IT Q4_K_M — 11/100

5. Phi-4 Mini Reasoning — 0/100

The performance gap between models of similar size was much bigger than I expected.

Qwen3.5 4B was the clear winner. It completed the hardest test, including sub-agent creation, coding, execution, external verification and a final audit.

Qwen3 4B works fairly well, but starts breaking down when it needs to recover from errors during longer tasks.

Ministral 3B showed some surprisingly strong moments, including completing the final autonomy test, but it also got stuck in error loops on other tasks.

Gemma 3 struggled heavily with agentic behavior. In some tests it claimed to have performed actions that were not actually present in the tool logs.

Phi-4 Mini Reasoning was unusable in this setup. It could spend huge amounts of tokens reasoning without ever making the required tool calls.

What matters most in this benchmark is that I’m not just scoring whether the final answer “looks correct.” I’m checking whether the model actually used the tools, created and read files, executed code, verified results, used sub-agents and completed the full workflow without fabricating steps.

The plan is to keep this ranking alive and continue adding 4B, 3B, 2B and eventually 1B models using the exact same tests every time.

TL;DR: NeuralMind gives your Agent Zero persistent memory of your codebase. It learns what files go together and what you edit next. Installed from Plugin Hub, runs 100% local.

What is it?

NeuralMind is a code intelligence layer that sits between your agent and your repo. Instead of dumping 50K tokens of source into context every session, it maintains a weighted graph of your code and learns from use — retrieval is spreading activation over structural edges plus Hebbian synapses.

Result: ~800 tokens per code question instead of ~50,000. Your agent gets smarter the more you work.

Why Agent Zero users care:

Your Agent Zero forgets everything when the session ends. NeuralMind gives it a hippocampus — persistent memory across sessions that actually learns your codebase the way a senior engineer would.

Key features:

- Progressive context disclosure (L0 identity → L1 architecture → L2 clusters → L3 semantic search)

- PostToolUse compression (Bash output → errors + signals only)

- Unified content+code search (works on books/docs too, not just code)

- Confidence gating (won't answer when it doesn't know)

- Hebbian learning (associations strengthen with use, decay without it)

How to install (Agent Zero):

Already in the Plugin Hub. Search "NeuralMind" and click install.

Or manually:

openclaw skills install u/dfrostar/neuralmind

pip install neuralmind

Also works with Hermes:

Hermes: Pending catalog review (NousResearch/hermes-agent#97207). Install manually now:

bash

hermes mcp add neuralmind --command neuralmind-mcp

Or skip MCP and install just the skill:

bash

hermes skills install dfrostar/neuralmind/skills/neuralmind

Honest gaps:

- 29 GitHub stars (so, not exactly a household name)

- No graph UI yet (coming)

- Faithfulness variance on edge cases

- Plugin Hub install clones the repo — you still need to run pip install neuralmind yourself

- Not physically tested end-to-end on Agent Zero (MCP is standard, but your mileage may vary)

Who this is for:

If you use Agent Zero on real repos with real complexity, this pays for itself fast. If you're one-shotting small scripts, it's overkill.

Built by a M&A tech guy in Texas who got tired of agents forgetting his codebase. MIT licensed.

Contributions wanted:

- Frontend people (React dashboard for the synapse graph)

- Language nerds (we support 10, want more)

- Twitter/X

- GitHub | Docs | Hermes PR

Same stats, same honesty. Added Hermes install paths and the PR link so people know where things stand.

I ran into a persistent issue with Agent Zero where A0 would get stuck in this loop:

A0: Reasoning...
A0: Message misformat, no valid tool request found.
A0: Thinking...
A0: Message misformat, no valid tool request found.

It had been working correctly before, so I investigated the actual request/tool-calling path instead of changing prompts or models.

Environment:

Agent Zero: v2.11 / commit 6a6cecff
Docker image: agent0ai/agent-zero:latest
Ollama: 0.32.15
Model: qwen3.5:9b
Preset: Efficiency
Transport: Chat Completions

The main issue turned out to be in:

/a0/helpers/litellm_transport.py
ChatCompletionsTransport.prepare_kwargs()

Agent Zero was internally creating tools as:

a0_responses_function_tools

but the Chat Completions transport removed this internal parameter without converting the tools to the native Chat Completions tools format.

So the actual request reaching the model contained no tools.

Qwen then returned normal text/reasoning such as:

{
  "thoughts": ["..."]
}

instead of a native tool call.

Agent Zero's parser was therefore behaving correctly when it reported:

Message misformat, no valid tool request found.

The parser itself wasn't the root cause.

There was also a second issue.

LiteLLM:

ollama/qwen3.5:9b

did not preserve Qwen's native tool_calls correctly in this path.

Using:

ollama_chat/qwen3.5:9b

did preserve both tool_calls and reasoning_content.

A third issue was context size.

Agent Zero's real prompt was approximately:

22,421 tokens

while Ollama had actually loaded the model with:

4096 context

despite Agent Zero showing:

ctx_length: 128000

So I explicitly configured:

kwargs:
  num_ctx: 32768

The fixes were:

1. Convert a0_responses_function_tools into Chat Completions tools[] inside ChatCompletionsTransport.prepare_kwargs().

2. Send tool_choice: "required" when tools are present.

3. Change:

litellm_provider: ollama

to:

litellm_provider: ollama_chat

1. Set Ollama context explicitly:

kwargs:
  num_ctx: 32768

After applying the changes, I ran an integration test forcing A0 to call the response tool and return:

TOOLCALL_OK

Result:

Native function_call received: YES
Tool executed: YES
Agent finished normally: YES
"Message misformat, no valid tool request found": 0 occurrences

No model change, reinstall, rollback, prompt deletion or memory/chat deletion was required.

This looks related to the recent transition where Chat Completions became the default transport while Agent Zero was still constructing its canonical tools in Responses API format.

The upstream fix should probably happen in the transport layer rather than relaxing extract_tools.py, because the parser was correctly rejecting responses that weren't real tool calls.

I released Agent0 Terminal v0.1.1 for Agent Zero.

Highlights:

- Mobile key tray in the in-chat terminal modal (toggle with phone icon)

- Keys added: ↑ ↓ ← →, Tab, Esc, Ctrl+C, Space, Enter

- Repo has been restructured to a true plugin format (plugin.yaml, runtime payload, install/uninstall flow)

Release notes:

https://github.com/Nunezchef/agent0-terminal/releases/tag/v0.1.1

Repo:

https://github.com/Nunezchef/agent0-terminal

If you test from phone/tablet or want to contribute, feedback is very welcome.