DEV Community: Emul Ahamed Sazib

I Built an IDE Where Multiple AIs Code Together as a Team 🚀

Emul Ahamed Sazib — Wed, 29 Jul 2026 19:34:36 +0000

I’ve been building a project lately that feels like something straight out of a sci-fi movie—an IDE where multiple AI models collaborate and write code together as a unified team in real-time.

Normally, if you’re using AI to write code, it’s a strict 1-on-1 chat. You prompt, the AI generates, you paste it in. But I wanted to see what would happen if we treated AI models like a real engineering squad.

What if you assigned Claude to handle the backend architecture, Gemini to build out the frontend, and a local Open-Source model to strictly act as QA and fix bugs—all working on the exact same project at the exact same time?

Here is a breakdown of how I made it happen, the roadblocks I hit, and how I solved them.

The Biggest Challenges: Chaos and Costs

When you have three LLMs firing off code simultaneously, two things happen very quickly:

Code Collisions: They try to overwrite each other's work.
Massive API Bills: Passing the entire codebase context back and forth to multiple commercial APIs is a great way to drain your wallet.

To solve this, I couldn't just wire them up to a text editor. I needed an orchestrator.

Building the "Traffic Cop" Manager

I built a custom desktop application using Python and PyQt6 that acts as the engineering manager for the AI team. Instead of letting the models run wild, this app orchestrates their workflow.

Here is how the architecture handles the chaos:

The "Traffic Cop" System: The manager only wakes up specific AI agents when they are strictly needed. If it's a UI task, only Gemini gets the ping.
AST Skeletons over Full Context: To save on token costs and prevent confusion, the models don't read the whole project. Instead, the manager parses the codebase and provides them with an Abstract Syntax Tree (AST) skeleton. They get the outline of the project so they know where things are, without the token-heavy payload of reading every single line of code.
Inter-Agent Signaling: This is my favorite part. If the frontend AI (Gemini) realizes it needs a new database endpoint to render a component, it doesn't just fail or hallucinate. It sends a digital "signal" to the backend AI (Claude) to request the database change.
Central Memory Base: All agents share a centralized memory store to keep track of state, tasks, and project context without getting confused or duplicating effort.

What's Next?

Building this has been an intense, coffee-fueled deep-dive into multi-threading, UI design, and AI orchestration. But seeing the agents actually pass tasks back and forth on a local dashboard and build features collaboratively is incredibly rewarding.

Right now, I am just polishing up the settings page to allow users to dynamically plug in their own commercial API keys or hook up their local models.

Stay tuned—I'll be sharing a video demo of the team in action very soon!

Stop Leaking Tokens: How I Finally Mastered AI Memory Management

Emul Ahamed Sazib — Wed, 29 Jul 2026 19:25:38 +0000

If you are building AI-driven applications, you already know the drill. You start with a simple agent, everything runs smoothly, and then you try to scale. Suddenly, you are hitting context window limits, your token usage is through the roof, and passing context between multiple agents feels like untangling a bowl of spaghetti.

I’ve been battling these exact issues while managing repo memory and agent footprints. Recently, I integrated a package called @vonneollc/knbase, and it fundamentally changed how I handle AI memory governance. Here is a breakdown of why this tool has become a permanent part of my stack.

The Problem: Token Bloat and Context Chaos

When you have multiple AI agents working on a single repository, they need to share information. Traditionally, this means passing massive chunks of context back and forth.
This approach creates two major headaches:

Cost and Latency: Passing redundant context eats up tokens quickly and slows down response times.
Hallucinations and Lost Details: As context windows fill up, the AI tends to lose track of fine details, leading to incomplete tasks or incorrect code generation.

The Fix: `@vonneollc/knbase`

knbase tackles memory governance by shifting how agents interact with stored knowledge. Instead of brute-forcing context into every prompt, it manages memory in granular detail.

Here are the standout features that caught my attention:

1. Massive Token Reduction with Complete Execution

By managing memory at a detailed level, knbase feeds the AI exactly what it needs — nothing more, nothing less. I noticed that the AI was still able to complete complex tasks flawlessly, but with a drastically reduced token count. You get the complete version of the output without the bloated input costs.

2. True Multi-Agent Harmony

This is arguably the best feature. The package includes "multi-agent readability" features that allow all your AI agents to work on the same memory base without explicit context sharing. You no longer have to manually pipe the output of Agent A into the prompt of Agent B. They can read and act on the shared repository memory organically.

3. Seamless MCP Integration

If you are experimenting with the Model Context Protocol (MCP), the MCP version of knbase handles the memory process in a really interesting and streamlined way, standardizing how your models access local or remote context.

Wrapping Up

If you are tired of wrestling with context sharing and want to shrink your agent footprints, I highly recommend checking out @vonneollc/knbase on npm. It takes the heavy lifting out of memory governance so you can focus on building smarter, more efficient AI workflows.

Let’s discuss: How are you currently managing context sharing between multiple AI agents? Have you tried knbase or similar memory governance tools? Drop your thoughts in the comments!