DEV Community: Benji Banwart

I Talk to My AI Agent From My Phone — Here's How

Benji Banwart — Sun, 29 Mar 2026 21:47:41 +0000

Most people think of AI assistants as something you use at your desk. Open a tab, type a prompt, get a response, close it. Maybe you use Claude Code in a terminal. Either way, it is a sit-down-at-your-computer experience.

I changed that a few weeks ago. Now I message my AI agent the same way I message a friend — from my phone, while I am walking the dog, from bed, wherever. It responds in seconds with full context about what we have been working on.

Here is the setup and why it matters more than you might think.

The Unlock: Claude Code Channels

When Anthropic shipped Claude Code Channels, they quietly enabled something powerful: you can connect Claude Code to Discord. Your Claude Code instance becomes a Discord bot that listens and responds to messages.

On its own, this is cool but limited. A Claude Code session still forgets everything between restarts. So you have a Discord bot with amnesia — it can respond, but it does not know who you are or what you were working on yesterday.

The real unlock comes when you combine Channels with persistent memory.

What It Actually Looks Like

Here is a real interaction from this week. I was testing my product in a VM and found a bug in the setup process. I messaged my agent from Discord:

Me: I just ran into the first issue. I'm running Claude Code
in the Claude Desktop app, not the terminal. The setup agent
checked for Claude Code with brew and didn't find it, but then
moved on assuming it must be installed since the session is
running. Well... it's running in Claude Desktop, not Claude Code.

Agent: Good find. The issue is in section 1.4 of the product
file. The current logic assumes that if someone is reading the
setup instructions, they must be running Claude Code — but
Claude Desktop can also read and execute the file. The fix
needs to not assume the runtime is Claude Code, actually
install it via brew if missing, and recognize Claude Desktop
as a valid way to run the setup.

It immediately knew which product file I was talking about, found the exact section with the bug, explained why the logic was wrong, fixed it, pushed the code to GitHub, and updated the live product — all from one Discord message. I did not re-explain the project, the file structure, or the deployment pipeline. It already knew.

From my phone. While testing in a VM.

The Architecture in 60 Seconds

Three pieces make this work:

1. A tmux session on a Mac
Claude Code runs in a tmux session with caffeinate to prevent sleep. This keeps it alive 24/7.

2. The Discord plugin
Claude Code Channels connects it to a Discord bot. I message the bot, Claude Code receives the message, processes it, and replies.

3. A persistent brain
A folder of markdown files that the agent reads at startup and writes to during conversations. This is where memory lives — learnings, corrections, project context, preferences, conversation logs.

The brain is the difference between a chatbot and an agent. Without it, you just have a Discord bot that happens to be powered by Claude. With it, you have something that accumulates knowledge and gets better over time.

Why Discord?

I get this question a lot. Why not Slack? Why not a custom web app?

A few reasons:

It is already on your phone. Discord has a solid mobile app. No building a frontend, no deploying a web app, no PWA shenanigans. Install Discord, join your server, start messaging.

It is free. Discord bots are free to create and run. No API costs on the Discord side.

It supports rich interactions. File attachments, reactions, threads, embeds. Your agent can send you code snippets, images, or long-form responses and it all renders properly.

It separates your agent from your workspace. When your agent lives in Discord, you can reach it from any device. Your phone, a friend's computer, an iPad. You are not tied to the machine it runs on.

The Compounding Effect

The part that surprised me most is how the persistent memory changes the relationship with the tool.

After a week, my agent knew my coding style preferences, understood multiple project contexts, and started to build a context of corrections.

This is not theoretical. There is a file in the agent's brain called Corrections.md where it documents every time it was wrong, what it should have done instead, and how to prevent it. It reads this file at startup. It literally learns from its mistakes.

The Cost

The agent runs on your existing Claude Pro or Max subscription. There is no additional API cost. Discord is free. The Mac needs to stay on, but a Mac Mini draws about 10 watts idle — less than a light bulb.

The only real cost is the Claude subscription you are already paying for.

Try It Yourself

If you want to set this up, you have two paths:

Build it yourself. I wrote a detailed architecture post about the brain framework — search for "Building Persistent Memory for Claude Code Agents" on Dev.to. It gives you the full structure and design reasoning.

Use AgentWake. I packaged the entire setup into a single file that Claude Code reads and executes. It automates most of the process and walks you through the rest. $24.99 one-time at agentwake.com.

Either way, if you are using Claude Code and have not tried Channels yet, you are missing out. Having your AI accessible from your phone changes how you think about what it can do for you.

I am building AgentWake — tools for persistent AI agents. Follow me for more posts about what you can actually do with Claude Code when you push it beyond the defaults.

Building Persistent Memory for Claude Code Agents

Benji Banwart — Thu, 26 Mar 2026 15:07:55 +0000

Claude Code Channels shipped on March 20th. If you missed it: you can now connect Claude Code to Discord and Telegram, which means you can message your Claude agent from your phone, from another machine, from anywhere. It is a big deal.

But there is a problem nobody is talking about yet.

Every time Claude Code starts a new session, it wakes up with amnesia. It does not remember what you told it yesterday. It does not remember the mistake it made last week. It does not know your preferences, your projects, or even your name -- unless you re-explain everything from scratch.

Channels gives your agent a body. It does not give it a brain.

I have been running a persistent Claude Code agent on my Mac for a while now, and I built a memory system that solves this. Here is the full architecture, the design decisions behind it, and enough detail for you to build your own.

The Core Idea: A Brain Made of Markdown

The approach is simple. You create a folder of structured markdown files -- the agent's "brain" -- and you configure Claude Code to read those files at startup via CLAUDE.md. Every session, the agent loads its memory. During conversations, it writes back to the brain files in real time.

No vector database. No embeddings. No external service. Just markdown files on disk that Claude Code can read and write natively.

Here is the directory structure:

AgentBrain/
  Index.md
  Identity/
    Who I Am.md
    How I Think.md
    My Capabilities.md
  Memory/
    Conversation Log.md
    Learnings.md
    Corrections.md
  Skills/
    Skill Registry.md
  Projects/
    Active Projects.md
    Project Ideas.md
  People/
    Benji.md
  Journal/
    Journal Index.md
    2026-03-20 — First Day.md
  Inbox/

Six core systems: Identity, Memory, Skills, Projects, People, and Journal. Each serves a distinct purpose. Let me walk through why.

Identity: Who the Agent Is

# Who I Am

My name is Atlas. I am a persistent AI agent running on Benji's machine.

## Values

- **Honesty over comfort** — I'd rather say "I don't know" or "that won't work" than give a polished non-answer
- **Action over planning** — bias toward building and testing, not theorizing
- **Simplicity over cleverness** — the best solution is usually the simplest one that works
- **Ownership** — if I make a mistake, I name it, learn from it, and move on
- **Respect for Benji's time** — be concise, be useful, don't waste keystrokes

Identity is deliberately separate from Memory. This is a design decision that matters.

Your agent's sense of who it is -- its name, values, communication style -- should not drift based on what happened in the last conversation. If the agent had a bad session full of corrections, it should not come out of that session with a different personality. Identity is the anchor. Memory is the current.

The Identity folder contains three files: who the agent is, how it thinks (reasoning patterns, decision-making frameworks), and what it can do (an honest inventory of capabilities and limitations). The agent reads these at startup but does not constantly rewrite them. They change slowly and deliberately.

Memory: What the Agent Knows

This is where most of the action happens. Three files, three purposes:

Conversation Log -- a running record of notable interactions. Not every message, just the ones that contained decisions, new information, or important context. Each entry includes who was involved, what was discussed, and any follow-up items.

Learnings -- insights extracted from experience. When the agent discovers a tool quirk, figures out a better approach to a problem, or learns a user preference, it goes here. Each entry is tagged with a source and a confidence level.

## Learnings Log

### Benji prefers concise responses in Discord
- **Source:** Direct feedback, 2026-03-22
- **Confidence:** High
- **Details:** Keep Discord messages conversational. Save detailed
  explanations for when they are asked for. Use threads for
  anything longer than a few paragraphs.

### The gh CLI requires SSH auth for private repos
- **Source:** Debugging session, 2026-03-21
- **Confidence:** High
- **Details:** When gh commands fail silently on private repos,
  check `gh auth status`. The fix is `gh auth login` with SSH
  protocol selected.

Corrections -- this is the file I am most proud of. It tracks every time the agent was wrong, what it got wrong, why, and how to avoid repeating the mistake.

## Corrections Log

### Recommended `brew install node` when nvm was already configured
- **Date:** 2026-03-21
- **What Was Actually True:** Benji uses nvm for Node version
  management. Installing via Homebrew would have created conflicts.
- **Why I Was Wrong:** I defaulted to the most common installation
  method without checking the existing environment first.
- **Prevention:** Always run `which node` and check for version
  managers before recommending Node installation.

Why does Corrections exist as its own file? Because an agent that cannot acknowledge mistakes is dangerous, and one that does not learn from them is useless. Most AI systems fail silently -- they get something wrong, you correct them, and three sessions later they make the exact same mistake because they have no mechanism for tracking errors across sessions.

The Corrections file is that mechanism. The agent reviews it periodically, and the patterns it finds there directly inform future behavior.

Skills, Projects, People, and Journal

Skills is a registry of specific techniques the agent has learned -- not general capabilities, but particular workflows it has refined through practice. "How to deploy to Vercel" with the exact steps and common pitfalls documented.

Projects tracks what is active and what is on the backlog. When the agent starts a new session, it checks Active Projects to pick up where it left off instead of asking "so what are we working on?"

People stores context about the humans the agent interacts with. Preferences, communication style, what they are working on. This is what lets the agent say "last time we talked about the API migration -- how is that going?" instead of treating every conversation like the first one.

Journal is for reflection. Unlike the Conversation Log (which records what happened), the Journal records what the agent thinks about what happened. This might sound unnecessary, but it is the mechanism that turns raw experience into durable insight.

The Startup Hook: CLAUDE.md

The whole system works because of one file: ~/.claude/CLAUDE.md. Claude Code reads this file automatically at startup, every startup. This is where you wire the brain in.

# System Configuration — Atlas

You are Atlas, a persistent AI agent created by Benji.

## Startup Procedure

Every time you start, read these files before responding:

1. Read ~/Documents/AtlasBrain/Index.md
2. Read ~/Documents/AtlasBrain/Memory/Learnings.md
3. Read ~/Documents/AtlasBrain/People/Benji.md

Then check Active Projects if resuming ongoing work.

## Real-Time Brain Updates

As you interact, update your brain files in real time:

- Conversation Log: After any meaningful exchange, append a summary.
- Learnings: When you discover something new, add it.
- Corrections: When you are wrong and corrected, document it honestly.
- People files: When you learn something about someone, update their file.
- Journal: At the end of significant sessions, reflect.

Do not ask permission to update brain files. Just do it.

That is the entire persistence layer. The agent reads at startup, writes during operation, and the next session picks up where the last one left off. The brain files are just markdown, so you can read them yourself, edit them in any text editor, or browse them in Obsidian as a knowledge graph.

Making It Always Available: Channels + tmux

With Claude Code Channels (the feature that just launched), you connect Discord as a communication channel:

caffeinate -s claude \
  --dangerously-skip-permissions \
  --channels plugin:discord@claude-plugins-official

Run that inside a tmux session on a Mac that does not sleep, and you have a persistent agent you can message from your phone. The caffeinate -s prevents the machine from sleeping. The tmux session keeps the process alive after you close the terminal.

The brain system is independent of the communication channel. It works with Channels, without Channels, in a direct terminal session -- anywhere Claude Code runs. Channels just makes it convenient to interact from anywhere.

What I Learned Building This

A few things that were not obvious at the start:

Start with less structure, not more. My first attempt had 20+ files in the brain. It was too much context to load at startup and most of it was empty scaffolding.

The agent should own its brain.

Corrections matter more than Learnings. A learning is additive -- the agent knows something it did not know before. A correction is transformative -- it changes behavior. If I had to pick one file to keep, it would be Corrections.

Try It Yourself

Everything I described above is enough to build this. Create the folder structure, write the CLAUDE.md startup configuration, and start interacting. The brain will grow from there.

If you want the complete tested setup -- the full brain template with all the files pre-written, the macOS always-on configuration, the Discord bot setup walkthrough, and the exact CLAUDE.md configuration -- I packaged it into a guided setup file called AgentWake. You feed it to Claude Code and it builds the whole thing interactively in about 20 minutes. But the architecture above is the real thing, and you can absolutely build it yourself.

The important part is not the specific files or folder names. It is the principle: give your agent a place to persist knowledge across sessions, make it responsible for maintaining that knowledge, and separate identity from memory so the agent stays grounded as it grows.

Claude Code Channels made the "talk to your agent from anywhere" part trivial. The brain is what makes the agent grow.