I Gave My AI Agents Their Own Phone Numbers. Here's What I Learned.

Three things I learned this week that changed how I work with AI:

Your AI assistant is failing you because it's trying to do everything in one conversation.
Prompt engineering is becoming irrelevant — and most people haven't noticed.
The real power of coding agents isn't the coding. It's the orchestration.

Here's what happened.

The setup

I've been running OpenClaw — an open-source AI agent framework — for about a month. It lives on a Mac Mini in my apartment. It runs my calendar, my email, my research, my code deployments. It's become the operating layer for most of my work.

Last week I did something that sounds trivial but turned out to be transformative: I gave each of my AI agents their own WhatsApp number.

Three agents. Three phone numbers. Three completely separate conversations in my WhatsApp, sitting right alongside my human contacts.

And it changed everything.

The context problem nobody talks about

If you're using AI seriously — not just asking ChatGPT the occasional question, but actually building with it, running projects through it, delegating real work — you've hit this wall. You just might not have named it yet.

When you're running 3+ projects simultaneously — which, let's be honest, most founders are — two things break down fast with a single AI assistant:

First, the context window fills up. You're discussing a video pipeline, then switching to investor outreach, then debugging a web dashboard, and suddenly your AI is drowning in 50 different threads. It starts forgetting things you told it an hour ago. It starts confusing Project A's database schema with Project B's API endpoints. The quality drops off a cliff — not because the model got dumber, but because you're asking it to hold too many things in its head at once.

This is the dirty secret of "long context windows." Yes, models can technically handle 200K tokens now. But cramming 200K tokens of mixed-project context into one conversation doesn't make the AI smarter. It makes it confused. Context length is not the same as context quality.

Second, even when context isn't full, you have to be incredibly precise about which project you're talking about. "Update the homepage" — which homepage? "Fix the export bug" — which export, which project? "Push the latest changes" — to which repo?

You end up spending half your time prompt-engineering just to keep the AI oriented, instead of actually getting work done. Every message needs a preamble. Every instruction needs disambiguation. You're managing the AI's attention instead of it managing yours.

Sound familiar?

The fix was embarrassingly simple

Give each project its own agent. Its own phone number. Its own context.

That's it.

When I text the agent on one number, it knows I'm talking about the video project — because that's the only thing it's ever discussed. When I text another number, it knows I'm talking about investor research. There's no confusion. No "which project do you mean?" No context pollution.

Each agent has its own memory. Its own workspace on disk. Its own conversation history. They're genuinely separate entities, not tabs in the same interface.

Why WhatsApp?

This is the part that surprised me most. The choice of WhatsApp wasn't a technical decision — it was a workflow revelation.

Because you carry it everywhere.

It's already open on your phone. There's no "let me open my laptop and find the right chat window" or "let me switch to the right tab." You're in the car, you think of something, you text the right agent. You're walking between meetings, you fire off a quick message. You're lying on the couch at 11pm and remember something — you just text it, the same way you'd text a colleague.

The AI is just another contact in your phone. And that changes the relationship completely.

I set up three agents through the WhatsApp Business API — each with their own number, their own identity, their own workspace. Text one about the video project, text another about investor research, text the third about infrastructure. They never cross-contaminate. Each one knows exactly what you're talking about because that's ALL it's been talking about.

The interaction becomes so natural that you forget you're talking to an AI. You're just... texting your team.

The thing people are missing about coding agents

There's a second insight from this week that I think is even bigger.

Tools like OpenClaw, Claude Code, and Codex have this incredible capability that almost everyone is undervaluing: orchestration.

Yes, these tools can write code. Everyone knows that. That's the demo. That's the headline. "AI writes code!" Cool.

But that's not where the real power is.

The real power is when an agent runs these tools for you. When it knows how to communicate with Claude Code — how to break down a complex task into smaller pieces, how to provide the right context, how to review the output, how to catch when something's gone wrong and course-correct.

Think about it like this: the difference between a junior developer and a senior engineering manager isn't that the manager writes better code. It's that the manager knows how to break down problems, delegate effectively, review work, and coordinate multiple workstreams. The code itself is almost beside the point.

That's what OpenClaw does with coding agents. It's the senior engineer managing a team of specialist coders. You describe what you want at a high level — "build me a dashboard that shows all my podcast episodes with cost tracking" — and it handles the delegation, the back-and-forth, the quality control, the integration.

Last week we had 15 sub-agents running in parallel. Some were researching VC firms. Some were enriching email databases. Some were building new features in a web app. All coordinated by the main agent, all running simultaneously, all reporting back when done.

That's not prompt engineering. That's management.

And it works because the orchestrating agent understands something that a raw coding tool doesn't: context. It knows about the project. It knows about previous decisions. It knows what was tried before and didn't work. It passes all of that to the coding agents so they don't start from zero every time.

The death of prompt engineering (mostly)

This is the third insight, and it's the one I keep coming back to.

We've all become obsessed with prompt engineering. There are courses, certifications, entire job titles built around it. And yes, in some contexts it still absolutely matters — when you're building production systems, when you're crafting reusable templates, when milliseconds and token costs matter.

But here's what I noticed this week: when you put an agent in front of that complexity — one that interacts with you more like a person than a text box — the need for prompt engineering drops dramatically.

The conversation becomes more like talking to another engineer. You say "this feels slow, can we optimise it?" instead of carefully constructing a multi-paragraph prompt with examples, constraints, output format specifications, and chain-of-thought instructions. You say "that's not quite right, make it more casual" instead of rewriting your system prompt for the fourth time.

The agent asks clarifying questions. It pushes back when something doesn't make sense. It remembers what you decided last Tuesday. It says "we tried that approach on the video project and it didn't work — want me to try the alternative?"

You talk like a human. The agent translates that into precise instructions for the tools underneath.

This is a huge shift. For the last two years, the implicit message from the AI industry has been: "These tools are incredibly powerful, but you need to learn how to talk to them properly." Prompt engineering became a skill. A craft. A gatekeeping mechanism.

What I'm seeing now is the opposite direction. The tools are learning how to talk to us. The agent layer absorbs the complexity of communicating with models, APIs, coding tools, and search engines. You just... talk. Like you would to a smart colleague.

That doesn't mean prompt engineering dies entirely. Someone still needs to design the agent's system prompts. Someone still needs to tune the orchestration layer. But the end user — the founder, the product manager, the operator — they shouldn't need to think about it. And increasingly, they don't.

What this looks like in practice

A typical day now looks something like this:

I wake up, check my WhatsApp. Three AI contacts, just like three team members. I scan what they've been up to overnight — one ran a research task I'd kicked off before bed, another has a summary of what changed in a codebase.

On the way to a meeting, I voice-note one agent: "The investor portal needs a countdown timer on the allocation page. Can you spec that out?" By the time the meeting's over, it's done — not just specced, but built by a sub-agent it delegated to, reviewed, and ready for me to look at.

During the meeting, I text another agent: "What's the latest on the podcast pipeline? Anything broken?" Quick status update. No laptop needed.

In the evening, I'm on the couch and think of a feature idea. I text it to the right agent. "Add this to the backlog and rough out an approach." Done. It'll be waiting for me tomorrow.

The AI isn't a tool I sit down to use. It's a team I communicate with throughout the day, through the same app I use to talk to everyone else.

The bigger picture

I think we're at an inflection point that most people haven't recognised yet.

The conversation around AI assistants is still stuck on "which model is best" and "how do I write better prompts." Those are last year's questions.

The questions that matter now are:

How do you structure an AI team? Which agents handle which domains? How do they share (or not share) context?
How do you communicate with AI naturally? Not through carefully engineered prompts, but through the same channels and patterns you use with human colleagues?
How do you orchestrate, not just execute? How do you get AI to manage other AI, so you can operate at a higher level of abstraction?

Giving my agents their own phone numbers isn't really about phone numbers. It's about treating AI as team members instead of tools. It's about context separation as an architectural principle. It's about meeting AI where you already are — in your pocket, on WhatsApp, in the flow of your actual life — instead of going somewhere special to "do AI stuff."

Where this goes next

Right now, this setup requires some infrastructure work. WhatsApp Business API, phone number provisioning, webhook routing, agent configuration. It's not a 5-minute setup.

But the model is clear. And the delta in productivity and quality between "one AI assistant for everything" and "a team of focused agents, each a message away" is enormous.

Not because the underlying models got better. But because each agent finally has the breathing room to actually think.

That's the real unlock. Not smarter models. Better architecture.

Nick Halstead is a serial entrepreneur (TweetMeme → Twitter, DataSift, InfoSum) and founder of GVT Labs. He's currently building AskGVT — AI that learns from video.

Follow the journey: softwareasarequest.substack.com