10 Open Agents That Improve Themselves

However, this doesn’t mean they recursively rewrite themselves into something like AGI. In most open-source systems today, “self-improvement” is practical: better memory, better prompts, better skills, better tool use, task decomposition, and recovery from mistakes.

The rising popularity of Hermes Agent have demonstrated an important thing – people are seeking and are increasingly interested in agents that can self-improve.

Hermes Agent positions itself as “the agent that grows with you”, emphasizing persistent memory across sessions and automatic skill creation alongside a gateway for multi-platform messaging and sandboxed tool use. This is the first agent at this scale, but similar ideas and mechanisms appear in other agents as well.

The most important categories to watch are memory-first agents, reflection agents, skill-evolving agents, and self-referential architectures. Memory-first agents, like Hermes Agent and Letta, focus on persistent memory. Reflection agents’ idea is obviously reflection and self-critique, such as LangGraph reflection patterns. Some agents – Agent0, AutoSkill, MemSkill, and EvoAgentX – focus on skill creation and self-evolving workflows. And others go further into self-referential architectures, where the agent can modify not only its output but parts of its own improvement process, as in HyperAgents.

Here are several interesting lightweight open-source agents and frameworks that support self-improvement concept:

Meta’s research system for self-referential AI, combining a task agent with a meta agent in a single editable program that can modify both itself and its improvement process, making it one of the clearest examples of explicit self-improvement architectures. → Explore more

Agent0 is a research-oriented autonomous framework built around zero-data self-evolution. Its description states that agents can improve and evolve without human-curated datasets and self-generate training data through intelligent exploration, using tool-integrated reasoning to drive continuous capability growth. → Explore more

A framework for building LLM agents that generate workflows, evaluate their own performance, and iteratively rewrite prompts and structures using built-in evolution algorithms. Over time, this creates agents that continuously refine how they work (not just what they output) through feedback-driven self-optimization. → Explore more

Trains agents that don’t rely on static data: they generate their own tasks, explore environments, and learn from past trajectories. By assigning credit across steps and refining policies, the system forms a closed feedback loop where agents continuously evolve. → Explore more

An autonomous agent framework that runs in an execution environment, where agents use and create tools while refining workflows over time. With persistent memory, plugin-based skills, and iterative loops, it can self-correct and expand its capabilities, gradually evolving its behavior through continuous interaction and tool use. → Explore more

A memory-first coding harness built on the Letta API, where a persistent agent keeps state across sessions and updates its memory over time. It can learn reusable skills and adapt from past interactions, improving continuously instead of resetting each session, while remaining portable across different LLM backends. → Explore more

A multi-channel AI assistant built on the Letta Code SDK, using a single persistent agent with shared memory across apps like Telegram, Slack, Discord, WhatsApp and Signal. It stores conversations over time, executes local tools, and schedules tasks. The agent continuously updates its memory and skills, allowing it to improve behavior and responses from ongoing interactions. → Explore more

A reflection-style agent pattern that implements iterative self-critique: a critique agent evaluates the main agent’s output and, if issues are found, sends feedback for revision. This loop repeats until no further critiques remain, enabling step-by-step refinement within a single execution. → Explore more

Autonomous agent framework that allows agents to continually improve performance across runs. It provides memory storage to retain information and adapt behavior over time, enabling incremental improvement through repeated execution and accumulated context. → Explore more

AutoSkill is a framework for agents that learn reusable skills from past interactions and apply them in future tasks. It turns repeated user preferences, workflows, and corrections into explicit skills that can be maintained, reused, and shared. It is especially relevant for personal agents, workplace assistants, and long-running systems that need to improve without retraining the base model. → Explore more

Self-improving AI agents are systems that can get better over time through memory, feedback, reflection, reusable skills, and iterative workflow updates. They do not necessarily retrain the base model. Most improve by remembering past interactions, refining prompts, creating tools, or correcting their own behavior across tasks.

AI agents can improve themselves through several mechanisms: persistent memory, self-reflection, critique-and-revision loops, tool creation, skill libraries, task history, and feedback from users or environments. Some systems improve within a single task, while others accumulate knowledge across sessions.

Some are open source, but not all. Frameworks like LangGraph, Letta-based projects, Agent Zero, SuperAGI, EvoAgentX, and related research agents provide open ways to experiment with memory, reflection, and self-improving workflows. However, the most advanced production agents may still be closed or only partially open.

Memory lets an agent remember information across sessions. Self-improvement goes further: the agent uses that memory or feedback to change how it works. For example, it may refine a workflow, reuse a skill, avoid a repeated mistake, or choose better tools based on past outcomes.

Yes, but in a practical and limited sense. Today’s self-improving agents can improve prompts, workflows, memory, tool use, and task strategies. They are not fully autonomous systems that recursively upgrade themselves into AGI. The real progress is happening in persistent memory, skill evolution, reflection loops, and better feedback mechanisms.