We’ve all been there. You watch a slick demo of an AI agent framework. “Look,” the presenter says, “in just five lines of code, you can build an AI assistant!” Your excitement builds. This is it—the tool that will finally let you build that intelligent system you’ve been dreaming about.

Then reality hits like a brick wall.

Need multi-user capabilities? That “simple” framework suddenly requires you to reverse-engineer undocumented internals. Want to see what your agent is actually doing? Good luck navigating through layers of abstraction and hidden prompts. Need to swap out the LLM provider? Hope you enjoy rewriting half your codebase.

One developer we spoke with lost months just trying to understand how their chosen framework actually worked. Another had to assign an entire team just to keep up with framework updates. For one agency, the “simple” solution became anything but.

After building AI assistants for close to a decade and going through four iterations of our own framework, we decided enough was enough. It was time to build something different.

The Journey of Five Frameworks

Xaibo isn’t our first rodeo. It’s actually our fifth attempt at building an AI agent framework, and each iteration taught us something crucial about what developers actually need.

Iteration 1: The Visual Experiment
We started with an implementation of “baby AGI” using Xircuits, our visual programming environment. The idea was simple: instead of drawing diagrams and then implementing them separately, why not draw the implementation itself? It worked, but the complexity quickly became unwieldy.

Iteration 2: The Abstraction Layer
Our Agent GPT toolkit abstracted the larger components to simplify development. But we discovered a truth that would haunt us through multiple iterations: simplification often meant hiding complexity, not eliminating it. Users still needed deep domain knowledge to do anything meaningful.

Iteration 3: The Simplification Push
The XAI agents component library pushed simplification even further. This version powered the AI capabilities on the Xpress AI platform and worked well for basic use cases. But as soon as requirements grew complex, the cracks showed.

Iteration 4: The Async Revolution
Real-world integrations with Discord, Slack, and Microsoft Teams demanded asynchronous operations. We rebuilt everything on quart and async components. Remarkably, we maintained the same interface—no breaking changes for existing users. But a fundamental problem remained.

The Tutorial Cliff

Here’s the pattern we kept seeing across the entire AI framework landscape:

1. The Hook: “Build an AI agent in 5 lines of code!”
2. The Demo: A slick presentation showing a basic query-response system
3. The Reality: Your actual requirements don’t fit the narrow use case
4. The Cliff: You either accept the limitations or dive into undocumented internals
5. The Rebuild: Many teams end up rebuilding from scratch

We call this the “tutorial cliff”—that moment when the simple becomes impossible. Need to restrict knowledge access based on user permissions? Want to customize how certain queries are processed? Suddenly, those beautiful abstractions become prison walls.

Three Principles That Changed Everything

After four iterations and countless conversations with frustrated developers, we crystallized three core principles for Xaibo:

1. Dependency Injection: Stop the Hidden Dependencies

Most frameworks create a web of hidden dependencies. An orchestrator module creates its own llm client, a memory module hardcodes its storage, a tool provider assumes specific implementations. This makes testing a nightmare and swapping components nearly impossible.

With Xaibo, modules explicitly declare what they need:

class MyOrchestrator:
    def __init__(self, llm: LLMProtocol, tools: ToolProviderProtocol, memory: MemoryProtocol):
        self.llm = llm
        self.tools = tools
        self.memory = memory

Want to test with a mock LLM that returns predictable responses? Just inject it. Need to switch from SQLite to a cloud database? Change the configuration, not the code.

2. Radical Transparency: See Everything

We wrap every component in a transparent proxy—think of it as a two-way mirror that lets you see every interaction:

No more scattered print statements. No more guessing what happened. Every call, every parameter, every response—completely visible.

3. Lego-Like Modularity: Build, Don’t Wrestle

Every component implements a clear protocol. Don’t like our LLM implementation? Copy it, modify it, use it:

# Your agent configuration
modules:
  - module: my_company.llm.CustomLLM  # Your implementation
    id: llm
    config:
      special_feature: enabled
  - module: xaibo.primitives.modules.orchestrator.StressingToolUser
    id: orchestrator

The framework should enable, not constrain. Mix and match components. Use our batteries-included modules or build your own. The choice is yours.

What Makes Xaibo Different

Let’s get practical. Here’s what building with Xaibo actually looks like:

Getting Started in 30 Seconds

# Install and create a project
pip install uv
uvx xaibo init my_project
cd my_project
uv run xaibo dev

That’s it. You now have a running agent with a web UI and an OpenAI-compatible API.

Building a Real Agent

Here’s a complete agent configuration that actually does something useful:

id: support-agent
description: Customer support agent with knowledge base access
modules:
  # The LLM brain
  - module: xaibo.primitives.modules.llm.OpenAILLM
    id: llm
    config:
      model: gpt-4
      temperature: 0.7

  # Python tools for actions
  - module: xaibo.primitives.modules.tools.PythonToolProvider
    id: tools
    config:
      tool_packages: [ tools.support ]

  # Vector memory for knowledge base
  - module: xaibo.primitives.modules.memory.VectorMemory
    id: memory
    config:
      memory_file_path: ./knowledge_base.pkl

  # The orchestrator that brings it all together
  - module: xaibo.primitives.modules.orchestrator.StressingToolUser
    id: orchestrator
    config:
      max_thoughts: 10
      system_prompt: |
        You are a helpful customer support agent.
        Always check the knowledge base before answering.
        Be friendly but professional.

Adding a Custom Tool

# tools/support.py
from xaibo.primitives.modules.tools.python_tool_provider import tool

@tool
def check_order_status(order_id: str) -> str:
    """Check the status of a customer order."""
    # Your actual implementation here
    return f"Order {order_id} is being processed"

@tool
def escalate_to_human(reason: str) -> str:
    """Escalate the conversation to a human agent."""
    # Your actual implementation here
    return "Escalating to human support..."

Debugging in Real Time

Start the dev server and open the web UI. You’ll see every interaction visualized:

Click on any interaction to see the full details—parameters, responses, timing, everything. Found a bug? Copy the exact parameters from the debug log into a test case. Reproducibility becomes trivial.

Beyond the Tutorial

Here’s where Xaibo shines. Those “advanced” features that other frameworks hand-wave away? They’re first-class citizens:

Multi-User Support: Not an afterthought. Configure authentication, session management, and user-specific contexts through clear interfaces.

Custom Memory Systems: Don’t want vector search? Implement the MemoryProtocol with your preferred approach—graph databases, traditional SQL, whatever fits your needs.

Complex Tool Orchestration: Need tools that call other tools? Agents that spawn sub-agents? The modular architecture makes it possible without framework surgery.

Production Monitoring: The same transparency that helps during development becomes invaluable in production. Every interaction is traceable, debuggable, and analyzable.

The Road Ahead

We pushed Xaibo public just hours ago. This is the beginning, not the end. Here’s what’s coming:

• Visual Configuration UI: Drag-and-drop agent building (without hiding the underlying configuration)
• Xircuits Integration: Visual tool definition for complex logic flows
• More Protocol Implementations: Additional LLMs, memory systems, and tool providers
• Multi-Agent Orchestration: First-class support for agent teams and hierarchies

But here’s the key: the core is stable. The principles are solid. You can build on Xaibo today with confidence that we won’t pull the rug out from under you.

Join Us in Building Better AI Agents

We built Xaibo because we needed it. After years of fighting with frameworks that promised simplicity but delivered complexity, we decided to build something different. Something that respects developers. Something that makes easy things easy and hard things possible.

Xaibo is 100% open source. Every line of code, every design decision, every feature—it’s all there for you to use, modify, and improve.

Get Started Today:

• GitHub: github.com/xpressai/xaibo
• Documentation: xaibo.ai
• Discord: Join our community

The age of AI agents is here. Let’s build them right.