From Static to Evolutionary Agents: A First Experiment

By Matías Molinas and Ismael Faro | Week 1 (Extended)

In our initial article, we highlighted how static AI agents—locked into one domain or skill—fall short of the broader vision for self-evolving AI systems. This follow-up piece demonstrates a practical example of an “evolutionary” agent in action, using the Bee Agent Framework to build and invoke custom tools on the fly. This quick experiment lays the groundwork for the more complex multi-agent and governance concepts we’ll introduce in subsequent articles.

Background Recap

• Static Agents: Good for fixed scenarios; unresponsive if user requests deviate from what the agent was trained to do.
• Evolutionary Agents: Generate new code or “tools” when faced with tasks they haven’t seen. Over time, they can learn, refine, and adapt automatically.

Previous article

In our series’ Step 1 plan, we want to prove that an agent can:

1. Identify when it lacks a tool for a new request.
2. Write the Python code to implement that tool.
3. Register the tool into its environment.
4. Execute the newly created tool, returning a result to the user.

Experiment: Dynamic Tool Creation for Riddles

We built a Bee Agent with minimal initial tools—just a Python execution environment and a special create_custom_tool function. When the user asks for something the agent can’t handle yet, it calls create_custom_tool to generate a new Python function. Below, we’ll see two requests and how the agent adapts.

1. Generating a Local Riddle

User Prompt: “Generate a random riddle.”

• The agent sees it has no built-in “riddle” function.

It creates a Python function called generate_riddle() on the fly:

import random

def generate_riddle():

"""Generates a random riddle."""

riddles = [

"What is always coming but never arrives? Tomorrow.",

...

]

return random.choice(riddles)

• After some minor validation errors (like docstring or schema issues), it succeeds.
• The agent calls this new tool, returning a random riddle to the user.

Console Excerpt:

Agent ?? (tool_name) : create_custom_tool

Agent ?? (tool_input) : { "name": "RiddleGenerator", "description": "Generates a random riddle", "sourceCode": "import random\ndef generate_riddle(): ...", "inputSchema": {} }

Agent ?? (tool_output) : {"tool_name":"RiddleGenerator","message":"A new tool named 'RiddleGenerator' has been created."}

Agent ?? (tool_name) : RiddleGenerator

Agent ?? (tool_output) : "What is always coming but never arrives? Tomorrow."

Final Answer: Here is a random riddle: “What is always coming but never arrives? Tomorrow.”

2. Fetching a Riddle from an External API

User Prompt: “Fetch a random riddle from the ‘https://riddles-api.vercel.app/random’ endpoint.”

The agent repeats the same approach, but this time with a code snippet that uses requests.get(...) against the external service:

import requests

def fetch_random_riddle():

????"""Fetch a random riddle from an external API."""

????response = requests.get('https://riddles-api.vercel.app/random')

????return response.json()

• Once the code is validated, the agent registers the new RiddleFetcher tool.
• A quick function call returns a JSON object with a riddle and answer.

Console Excerpt:

Agent ?? (tool_name) : create_custom_tool

Agent ?? (tool_input) : { "name": "RiddleFetcher", "description": "Fetches a random riddle from API", "sourceCode": "import requests\ndef fetch_random_riddle(): ..." }

Agent ?? (tool_name) : RiddleFetcher

Agent ?? (tool_output) : {"riddle": "People walk on me day and night. I never sleep...", "answer": "A sidewalk"}

Final Answer: The random riddle is: “People walk on me day and night. I never sleep... Who am I? A sidewalk.”

Why This Matters

We’ve just demonstrated the first principle of an evolutionary AI: the ability to create new capabilities in response to novel requests. This example is intentionally simple—fetching or generating riddles is not a complex enterprise operation—but it proves the agent can expand beyond initial constraints without a developer rewriting code by hand each time.

1. Dynamic Code Generation Instead of failing when asked for a random riddle, the agent crafts a Python snippet at runtime.
2. Self-Healing on Errors We see small missteps in docstring or schema validation. The agent recognizes and retries with corrected code until success.
3. Scalability As we proceed, the agent can store an expanding library of custom tools—beyond just riddles—so it’s not locked into a single domain.

A Foundation for Future Steps

This mini-demo represents our “Step 1” from the previous article:

• Basic Agent + Tool Generation: The agent writes, registers, and calls new code on the fly.
• Logging & Minimal Validation: The code interpreter can reject malformed Python or incomplete docstrings, prompting a retry.
• Human Oversight: A developer (or an automated test) could easily inspect or block certain code suggestions.

Roadmap Highlights

• Next Articles: We’ll add more robust governance (sandboxing, policy checks, and version control), leading to multi-agent collaboration.
• Smoother Error Handling: Future improvements will manage instrumentation warnings (circular references), ensuring logs remain clean and stable for large-scale use.
• Lifelong Learning: In later articles, we’ll see how the agent updates its own knowledge base or tunes an LLM to avoid repeating mistakes.

By incrementally scaling this approach—from single-agent experiments to multi-agent ecosystems—we aim to transform the typical single-purpose AI script into resilient, ever-evolving AI solutions.

Conclusion

This experiment shows how an evolutionary agent can adapt to new tasks—like generating or fetching riddles—through on-demand tool creation. This is precisely the foundational step that future articles in this series will build upon, adding deeper governance, memory, and multi-agent coordination. If you’ve followed along, you now have a glimpse of why static automata can’t keep up in dynamic, real-world environments, and how an AI can evolve itself in real time.

Stay tuned for Article 2, where we dive deeper into the fundamentals of building a single-agent system that can generate tools on demand—and see how these “baby steps” lead to advanced multi-agent architectures with governance and lifelong learning. We'll explore governance as the agent's “firmware,” ensuring its behavior remains mutable yet safely controlled, along with versioned tool libraries and human oversight guiding the creation of new tools.

About the Authors

• Matías Molinas : A CTO passionate about adaptive, real-world AI solutions.
• Ismael Faro : VP and Distinguished Engineer at IBM, working in Quantum + AI.

They will continue documenting each stage of this evolutionary AI journey, offering insight into successes, challenges, and why self-evolving agents matter for the future of AI.

Code:

https://github.com/matiasmolinas/bee-experiments

Generated using AI, validated by a human.