# Vision: AI as Colleague, Not Tool

## The Problem With How We Talk to AI

Every AI tool today works the same way: you type a command, it executes, it returns a result, it stops. You are the driver. It is the engine. The interaction model is a terminal from 1975 — just with better autocomplete.

This is wrong.

Not because the AI isn't capable enough. Because the interface doesn't match how humans actually work together.

## What Millions of Years Taught Us

Humans have spent millions of years evolving the most effective collaboration patterns. We don't collaborate by issuing commands and waiting for results. We talk. We interrupt. We notice things. We bring up problems nobody asked about. We tap each other on the shoulder and say "hey, I saw something weird."

The best collaboration happens in the channels we already live in — the group chat, the DM, the thread. Not because these tools are technically optimal, but because **human communication patterns are the optimal interface**, and messaging is where those patterns live digitally.

When you put AI in a terminal, you force humans to adapt to a machine's interaction model. When you put AI in your team chat, you force the machine to adapt to yours.

We choose the latter.

## The Colleague Test

Ask yourself: does your AI pass the colleague test?

A **tool** waits for instructions, executes them, and stops.

A **colleague** does what you asked — then keeps thinking. They notice the module next door has the same bug. They feel uneasy about the test coverage. They come back and say "hey, while I was in there, I found three other things we should look at." They get better at their job over time. They care about the product, not just the task.

The gap between tool and colleague isn't capability. Today's AI agents are extraordinarily capable. The gap is **initiative** — the ability to sense that something isn't right and act on it without being told.

## Tension-Driven Agency

We call this driving force **tension**: the gap between how things are and how they should be.

A human colleague feels tension when test coverage drops, when error messages confuse users, when a deployment goes out without review. They don't need a ticket for these things. They notice. They act.

An AI colleague should work the same way. Not running tasks from a queue, but continuously sensing tensions in the codebase, the product, the workflow — and resolving them. User messages aren't commands that start the engine. They're one signal among many in a stream of events the AI is always processing.

This is the architecture:

- **Inbox**: everything the AI perceives — user messages, code changes, CI results, system events — enters as events. No single source is privileged.
- **Processing**: the AI's continuous inner life — sensing tensions, reasoning about causes, prioritizing what matters, planning actions.
- **Outbox**: the only way the AI affects the world — explicit, auditable tool calls. Send a message. Modify a file. Notify a human. Every action is traceable.

The AI doesn't start when you talk to it and stop when it's done. It has its own timeline. It's always there, always thinking, always sensing. Like a colleague sitting across the room.

## Why IM, Not a New Interface

The instinct is to build a dedicated AI collaboration UI — a purpose-built dashboard with panels and widgets and real-time visualizations.

We reject this.

Not because we can't build it. Because it would be building another tool, and the world has enough tools. The entire point is that AI should show up where humans already are — not ask humans to go somewhere new.

IM platforms are imperfect. Message length limits, linear threads, limited rich media. But these constraints are features, not bugs. They force the AI to communicate like a human — concise, contextual, conversational. An AI that can only send you a Slack message will learn to make that message count. An AI with an unlimited dashboard will dump everything it knows and call it transparency.

Constraints breed clarity.

## Where We Are

Today, avibe connects AI coding agents to Slack, Discord, and Lark. You can write code from your phone, review PRs from the beach, debug production from a taxi. The plumbing works.

But the experience is still a remote control. You press buttons. The AI executes. It's useful, but it's not what we're building toward.

## Where We're Going

We're building AI that passes the colleague test.

An AI that finishes your refactoring task and then says: "I noticed the session module has the same structural issue. And the error messages in the auth flow are confusing — want me to clean those up too?"

An AI that messages you on Monday morning: "Over the weekend, I noticed test coverage dropped in the payments module. I traced it to the last three PRs. Here's what I'd do about it."

An AI that improves its own tools: "I keep running into the same friction with the test runner. I updated the config to handle edge cases better."

An AI that has goals, not just tasks. That feels tension, not just receives instructions. That exists on its own timeline, not just yours.

## The Golden Age

A year ago, building this would have required a team of twenty and a year of work. Today, a single person with AI can build what used to take an army. The engineering barrier is gone. What remains is taste — knowing what to build and why it matters.

We believe the next great interface between humans and AI isn't a new app. It's the apps humans already use, with AI that behaves like the best colleague you've ever had.

**This is what avibe is becoming.**

---

*avibe is open source. If this vision resonates with you, we'd love your help building it.*

*[github.com/avibe-bot/avibe](https://github.com/avibe-bot/avibe)*
