Hey HN,
I've been working on an open-source framework for creating AI agents that evolve, communicate, and collaborate to solve complex tasks. The Evolving Agents Framework allows agents to:
Reuse, evolve, or create new agents dynamically based on semantic similarity
Communicate and delegate tasks to other specialized agents
Continuously improve by learning from past executions
Define workflows in YAML, making it easy to orchestrate agent interactions
Search for relevant tools and agents using OpenAI embeddings
Support multiple AI frameworks (BeeAI, etc.)
Current Status & Roadmap
This is still a draft and a proof of concept (POC). Right now, I’m focused on validating it in real-world scenarios to refine and improve it.
Next week, I'm adding a new feature to make it useful for distributed multi-agent systems. This will allow agents to work across different environments, improving scalability and coordination.
Why?
Most agent-based AI frameworks today require manual orchestration. This project takes a different approach by allowing agents to decide and adapt based on the task at hand. Instead of always creating new agents, it determines if existing ones can be reused or evolved.
Example Use Case:
Let’s say you need an invoice analysis agent. Instead of manually configuring one, our framework:
Checks if a similar agent exists (e.g., a document analyzer)
Decides whether to reuse, evolve, or create a new agent
Runs the best agent and returns the extracted information
Here's a simple example in Python:
import asyncio
from evolving_agents.smart_library.smart_library import SmartLibrary
from evolving_agents.core.llm_service import LLMService
from evolving_agents.core.system_agent import SystemAgent
async def main():
library = SmartLibrary("agent_library.json")
llm = LLMService(provider="openai", model="gpt-4o")
system = SystemAgent(library, llm)
result = await system.decide_and_act(
request="I need an agent that can analyze invoices and extract the total amount",
domain="document_processing",
record_type="AGENT"
)
print(f"Decision: {result['action']}") # 'reuse', 'evolve', or 'create'
print(f"Agent: {result['record']['name']}")
if __name__ == "__main__":
asyncio.run(main())
Next Steps
Validating in real-world use cases and improving agent evolution strategies
Adding distributed multi-agent support for better scalability
Full integration with BeeAI Agent Communication Protocol (ACP)
Better visualization tools for debugging
Would love feedback from the HN community! What features would you like to see?
Repo: https://github.com/matiasmolinas/evolving-agents
Hi everyone,
Thanks for all your feedback on the Evolving Agents Toolkit! Here's a quick update on an exciting new addition: Architect-Zero, a meta-agent built to autonomously create multi-agent solutions.
Architect-Zero includes several significant improvements:
Embedded Evolution Strategies: Replacing basic self-improvement prompts with advanced, targeted evolution methods built directly into the tools.
Pure ReAct SystemAgent: Now fully capable of reasoning and adapting its strategies autonomously without relying on fixed logic.
Agent Bus: A new system for agents to discover and communicate efficiently, allowing seamless coordination across distributed setups.
Currently, Architect-Zero is showing promise in practical scenarios, such as financial invoice analysis and healthcare assessment systems, autonomously designing teams of agents capable of managing complex tasks.
Please note that the toolkit is actively under development. The ultimate aim is to achieve robust production capabilities, but more improvements—especially to the Agent Bus—are needed before reaching that stage.
Explore the latest updates and examples:
GitHub Repository: https://github.com/matiasmolinas/evolving-agents
Run new examples: python evolving_agents/financial_example.py python evolving_agents/medical_example.py
Your ongoing feedback is very important. Feel free to share your thoughts on Architect-Zero and these recent updates!