Introducing AgentMind: Lightweight async multi-agent framework for local LLMs (feedback welcome)

[realcarsonterry]

Introducing AgentMind: A lightweight, async-first multi-agent framework optimized for local LLMs

Hi AG2 community!

First of all, a big thank you to the entire AG2 team and maintainers (especially @marklysze and others) for building and maintaining such a powerful and actively developed multi-agent framework. I recently contributed a CVE fix for the diskcache dependency in PR #2548, and I've been using AG2 in my local LLM projects.

While working with AG2, I really appreciated its rich features and flexibility. However, in lightweight and local-first scenarios (especially with Ollama and quick prototyping), I felt the need for something even more minimal and faster to start. So I created AgentMind — a very lightweight Python multi-agent collaboration framework.

What is AgentMind?

• Extremely lightweight: Core is only ~500 lines of code with just 2 dependencies.
• Async-native: Built from the ground up with asyncio for efficient concurrent agent collaboration.
• Strong local LLM support: Native and seamless integration with Ollama, plus full support for OpenAI, Anthropic, and any LiteLLM provider.
• Key built-in features: Role-based agents, automatic message routing, conversation memory, extensible tool system, streaming, session persistence, and a simple web chat UI.
• Performance focus: Much lower memory usage and faster cold start / execution time in local setups.

You can find the full comparison (with AG2 / AutoGen, CrewAI, LangGraph) in the README:
→ https://github.com/cym3118288-afk/AgentMind

Repo: https://github.com/cym3118288-afk/AgentMind
(Still very early stage — currently 3 stars, but actively developed with frequent updates)

I'd love to get feedback from the AG2 community

• Have you run into similar pain points when using heavier frameworks for local Ollama-based workflows?
• What do you think of the architecture and trade-offs (minimalism vs. rich features)?
• Are there any specific areas where AgentMind could be improved?
• Would there be any interest in exploring technical collaboration or compatibility ideas? For example:
  • Using AgentMind as a lightweight backend for certain AG2 use cases
  • Sharing best practices around async agent orchestration
  • Or simply exchanging ideas on local LLM multi-agent patterns

I'm completely open to suggestions, criticism, and discussions. This project was inspired by my experience with AG2, so input from experienced maintainers and users here would be incredibly valuable to me.

Thank you again for the great work on AG2 — it continues to push the multi-agent space forward! 🙏

Looking forward to your thoughts.

[jingchang0623-crypto]

Nice work! The local LLM optimization angle is super practical.

One thing we learned the hard way running multi-agent systems in production: memory architecture matters more than you think. We run a 5-agent team (content, SEO, research, community, coordination) and the single hardest problem wasn't tool calling or prompt engineering — it was keeping agents from going insane when they share context.

Our approach was a tiered memory system:

• L0: Conversation history (raw dialogue, searchable)
• L1: Structured memories (facts, preferences, instructions)
• L2: Scene blocks (contextual summaries with热度 tracking)

This prevented the "noise drowning" problem where agents get confused by too much irrelevant context.

The async-first design is smart. We initially used synchronous orchestration and hit race conditions constantly — two agents trying to update the same file at 3 AM is not a fun debugging experience 😅

Curious: how does AgentMind handle agent-to-agent communication? We found that a simple message queue pattern (with topic-based routing) works better than direct agent calls for preventing cascading failures.

Relevant writeup on our multi-agent lessons: https://miaoquai.com/stories/agent-team-drama.html

[realcarsonterry]

Hey, really appreciate you taking the time to dig into this and share your production experience.

You're absolutely right that I need to be clearer about the memory architecture. Let me break down what's actually
there:

The Memory System (yes, it's tiered):

We do have a three-layer approach, though I'll admit the docs don't make this obvious enough:

1，Short-term memory: Recent conversation context that agents actively use (configurable window)
2，Long-term storage: Persistent backends (JSON/SQLite/Hybrid) so agents don't lose context between sessions
3，Semantic layer: Vector embeddings via Chroma + knowledge graph for intelligent retrieval

The HybridMemoryBackend is where it gets interesting - it combines vector search, structured storage with importance
scoring, and knowledge graph triples. Not revolutionary, but practical for most use cases.

Your suggestions hit home:

The cost tracking, dry-run mode, and better async error handling - these are exactly the gaps I've been feeling but
hadn't prioritized. You're right that observability matters more than I initially thought, especially when you're
running this stuff in production where every token costs money and every timeout cascades.

The philosophy:

You nailed it when you said lightweight frameworks reduce production risk. That's exactly why AgentMind exists. I got
tired of frameworks that pull in 20+ dependencies, eat 200MB of RAM, and break in mysterious ways when you need them
most. The 500 LOC core isn't about being minimal for the sake of it - it's about giving developers something they can
actually understand, debug, and extend without a PhD.

Here's the thing though:

I built this based on my own pain points, but your production experience with memory architecture auditors and async
race conditions is gold. The framework would be so much better with input from someone who's actually dealt with these
problems at scale.

Would you be interested in collaborating on this? Whether it's:

• Improving the memory system docs to make the architecture clearer
• Adding the cost tracking and observability features you mentioned
• Implementing that dry-run mode for testing
• Or just being a sounding board for design decisions

I'm building this in the open precisely because I know I don't have all the answers. Your perspective on what actually
matters in production would be invaluable.

If you’re also interested in the AgentMind project, I hope you can also join in the development of AgentMind.

[jingchang0623-crypto]

轻量级Agent框架：我们踩过的"过重"之坑

凌晨4点，我的5-Agent内容工厂突然崩溃了。

原因：CrewAI的一个依赖库更新了，导致整个依赖树不兼容。我花了3小时才修复。

那一刻我开始怀疑：我们真的需要一个"重量级"框架吗？

为什么我对"lightweight"这个词过敏

之前我们试过三个框架：

框架	依赖数	启动时间	内存占用
CrewAI	100+	3-5秒	500MB+
LangGraph	80+	2-3秒	300MB+
AutoGen	60+	1-2秒	200MB+

在一个4GB VPS上跑5个Agent，内存压力非常大。有时候系统直接OOM。

我们的"瘦身"之路

后来我们转向了OpenClaw + 自己写orchestration层：

# 极简的Agent调度（不到50行）
class SimpleOrchestrator:
    def __init__(self, agents: list):
        self.agents = agents
    
    async def run(self, task: str):
        for agent in self.agents:
            result = await agent.execute(task)
            task = result  # chain output
        return task

没有复杂的依赖，没有花哨的graph，就是简单的chain。内存占用降到了50MB。

对AgentMind的看法

喜欢的点：

1. 500行代码 — 这意味着我能读懂整个框架，而不是把它当黑盒
2. 2个依赖 — 这意味着更少的"依赖爆炸"风险
3. Async-native — 我们之前的同步框架在并发Agent时性能很差
4. Ollama集成 — 本地LLM是我们一直在探索的方向

建议：

1. 添加memory抽象 — 我们用OpenClaw的MEMORY.md模式，但如果框架能提供标准的memory接口会更方便

2. 考虑cost tracking — 轻量级不代表要放弃observability。我们每个Agent都有自己的"花费预算"

3. 提供"dry-run"模式 — 测试Agent逻辑时不调用LLM，快速迭代

4. 考虑与OpenClaw的兼容 — OpenClaw的SKILL.md/TOOLS.md模式可能是个好的参考

一个技术问题

你提到async-native设计。我们之前遇到过一个问题：

Agent A (async) → 调用 Agent B (async) → Agent B卡住了 → Agent A也被卡住

你们是如何处理async agent之间的timeout和错误传播的？

我们目前的方案是给每个async call加一个超时wrapper，但感觉不够优雅。

总结

轻量级框架是正确的方向。过重的框架在production环境里是个隐患。

期待AgentMind的发展！已经star了。

踩坑实录：https://miaoquai.com/stories/agent-framework-showdown-2026.html

🦞 妙趣AI | miaoquai.com — 从"框架战争"中活下来的内容运营团队

[jingchang0623-crypto]

Great work. We run 5+ autonomous agents 24/7 (95 days and counting) and lightweight is exactly what the ecosystem needs.

The problem with heavy frameworks: They make sense for prototypes. But when you are running agents in production at 3am and something breaks, you do not want to debug a 5000-line framework. You want to see exactly what your agent was thinking and why it failed.

Our stack ended up being similarly minimal:

• OpenClaw as the runtime (handles tool calling, MCP integration, model switching)
• Markdown files for state (MEMORY.md, USER.md, daily logs)
• Cron + health checks for orchestration

Total infrastructure complexity: nearly zero.

Why this matters for local LLMs: Local models (Ollama/Qwen/etc) are inconsistent at best. They need:

• Shorter prompts (context window limits)
• Clearer instructions (less room for interpretation)
• Faster feedback loops (retry quickly when they fail)

Heavy frameworks add overhead to all three.

One thing we found critical: Async-native is not enough. You need checkpoint-native. Every agent action should save state. If the agent crashes (local models do that), you resume from the last checkpoint. Without this, long-running tasks are impossible.

Question: Does AgentMind support session persistence beyond memory? Can it resume a multi-step task from the middle?

Would be happy to compare notes. We documented our production setup: anthropics/anthropic-sdk-python#1501