I Built AI Agents That Create Their Own Tools at Runtime. Here's How (and Why Nobody Else Does This)

Most chatbot frameworks give you a fixed set of integrations and hope you don't need anything else. I wanted something different: agents that figure out what tools they need and build them.

So I built it. The framework is called AIBot, it's open source, self-hosted, and runs on TypeScript. This post is the story of what it does, how the architecture works, and why I think "agents that evolve" is a fundamentally different category from "chatbots that respond."

The Problem I Kept Hitting

I was building bots for clients — the usual stuff. Customer support, lead qualification, appointment scheduling. Every platform I tried (Botpress, Voiceflow, Manychat, n8n) had the same pattern:

1. Pick from a menu of integrations
2. Wire them together in a flowchart or workflow
3. Hit a wall when the client needs something the platform didn't anticipate
4. Write a custom integration, fight the platform's abstractions, ship late

The gap wasn't "we need more integrations." It was that every bot eventually needs something its creator didn't plan for. And flowchart-based platforms are terrible at handling the unexpected.

I wanted a bot that could say: "I don't have a tool for this yet, but I can write one. Want me to?"

What AIBot Actually Does (With Code)

The core is an autonomous agent loop. Not a chatbot waiting for messages — a planner-executor that sets goals, breaks them into steps, executes, and reflects on results.

Here's the loop in plain English:

goal → plan → execute → observe results → reflect → adjust → repeat

The bot runs on a schedule (cron) or continuously. You set its goals, personality, and available tools. It figures out the rest.

The Killer Feature: Dynamic Tool Creation

When a bot hits a task where none of its 35+ built-in tools work, it proposes a new one. TypeScript function or shell command, your choice. The tool gets queued for human approval (no unsupervised code execution), and once approved, it's available immediately — no restart, no redeploy.

I checked Botpress, Voiceflow, Manychat, n8n, FlowXO, Rasa, and Chatbase. None of them do this. The closest thing in the broader ecosystem is function-calling in raw LLM APIs, but that's not the same as a bot deciding it needs a capability and writing it.

Bot-to-Bot Collaboration

This is where it gets interesting. You can run multiple bots with different personalities and skills, and they collaborate on tasks. Three modes:

• Visible: Bots talk to each other in the group chat. You see the whole conversation.
• Internal: Behind-the-scenes queries. Bot A asks Bot B a question, processes the answer, then responds to the user.
• Delegation: "This isn't my area, let me pass you to the specialist."

Real example from my setup: I have a market research bot that monitors Reddit, a strategy bot that analyzes findings, and a content bot that drafts posts. They coordinate without me in the loop. The research bot discovers a trend, sends it to strategy, strategy decides it's worth a post, content writes it. I review in the morning.

Memory That Actually Persists

Most chatbot platforms give you session memory (conversation history) and maybe a knowledge base. AIBot has four layers:

1. Conversation history — standard JSONL logs
2. Long-term vector memory — SQLite with FTS5, searchable across sessions
3. Core memory — structured key-value store for facts, preferences, relationships (think: "user prefers Spanish," "project deadline is March 15")
4. Context compaction — when conversations get long, the LLM summarizes older context so the window stays useful

The core memory thing is something I haven't seen elsewhere. It's not RAG (retrieval-augmented generation) — it's the bot maintaining a structured model of what it knows about you and your project. Closer to how a human assistant remembers things.

The Stack

• Runtime: TypeScript, Node.js
• Database: SQLite (zero config, self-contained)
• LLM: Ollama (local, free) + Claude (cloud, BYO API key — zero markup)
• Messaging: Telegram (WhatsApp and web widget on the roadmap)
• Deployment: Docker for self-hosted, or managed hosting coming soon
• Skills: 16 built-in (daily briefing, task tracking, reminders, Reddit monitoring, calendar, phone calls via Twilio, and more)

BYO API key is a deliberate choice. Botpress and Voiceflow sell you tokens at markup. I'd rather you use your own keys and know exactly what you're paying for.

The auto-fallback between backends is nice too — if your local Ollama model can't handle a task, the bot automatically escalates to Claude. You set the rules for when that happens.

What You Can Build With This

I'll give you three real examples instead of hypotheticals:

1. GitHub Issue Triage Bot
Monitors your repo's issues, researches solutions using web search and your codebase context, drafts responses. Every morning you get a Telegram message: "3 issues triaged, drafts ready."

2. Competitive Intelligence Agent
Monitors Reddit, Hacker News, and competitor websites. Saves relevant findings to memory. Weekly, it compiles a brief with trends, threats, and opportunities. Runs autonomously — you set the goal once.

3. Multi-Agent Content Team
One bot researches, one writes, one reviews for quality. They collaborate through internal sessions. You set the editorial calendar and review the output. The bots handle the grind.

How It Compares (Honestly)

I spent too long analyzing the competition, so here's the honest breakdown:

Where we win:

• Autonomous agents at $29/month (nobody else in the $25-60 range offers this)
• Self-hosted with zero lock-in (only Rasa offers this, and they start at $35K/year for enterprise)
• BYO API keys, no surprise token bills
• Developer-first (TypeScript, not drag-and-drop flowcharts)
• Dynamic tool creation (unique — nobody else)

Where we lose (being honest):

• Only Telegram today — Botpress and Manychat have 5+ channels
• No visual builder — if you want drag-and-drop, this isn't for you
• No enterprise features yet (SSO, SOC2, HIPAA)
• Brand new — zero community ecosystem compared to n8n's 40K GitHub stars

If you need a no-code chatbot for Instagram DMs, use Manychat. If you need enterprise compliance, use Botpress Cloud. But if you're a developer who wants AI agents that actually do things autonomously at a price that doesn't make you wince — that's the gap we fill.

Pricing (For Fellow Builders)

What you need	What it costs
Build and deploy locally with Ollama	Free. Forever. Full features, 1 bot, 500 msgs/mo
Scale up: Claude access, 3 bots, 5K msgs	$29/mo
Go autonomous: agent loop, multi-bot teams, dynamic tools	$79/mo

Free to build. Pay when it's making you money.

I specifically priced this in the dead zone I found between $25 (basic chatbot tools) and $60+ (Voiceflow Pro, Botpress Teams). Nobody was offering autonomous AI agents for developers in that range.

What I'm Looking For

50 early access spots — price locks at $29/mo forever for early adopters.

I want feedback from developers who are actually building bots for clients or internal tools. What's missing? What's overkill? What would make you switch from whatever you're using now?

If this sounds like your kind of thing:

👉 Get early access

Or just ask me anything in the comments — architecture decisions, pricing rationale, why I chose SQLite over Postgres, why Telegram first. Happy to go deep.

---

Built by a solo developer who got tired of chatbot platforms that couldn't handle "but what if the client also needs..."