How It Started

I started playing with OpenClaw for fun. Agent frameworks looked cool and I wanted to see how far I could push one, so eventually I spun up a small agent to help me with marketing: monitoring ad performance, writing blog posts, posting on social, answering questions in Discord. I called her Mira. M for marketing.

She worked, and because she worked, I kept using her.

Noticing the Overlap

Over the last few months, I started noticing a pattern. Claude Code kept shipping features natively that OpenClaw had pieced together: memory, browser tools, plugin systems, skills. If Claude Code could do most of this on its own, the obvious question was why I was running a wrapper on top of it at all.

Around the same time, I started poking at whether you could get the same agent behavior using Claude Code's own tools, with no third-party glue beyond a simple messaging plugin. It was only a few hours of research, spread out because I was busy with other work, but what I saw was enough to make it look plausible. About two weeks after I started looking, the email arrived.

The Email That Forced the Timeline

Anthropic announced that third-party tools could no longer use the Claude Code OAuth token. Overnight, the cost model for OpenClaw-based agents flipped: to keep them running you now needed a separate pay-per-token API key, which meant watching a meter instead of paying a flat subscription. For my cluster of agents, that meant a real bill or a migration.

I had already convinced myself I could run everything on Claude Code directly, so the email just forced the timeline. I started building that same day.

Day One: Migration

The first version wasn't a framework. It was a migration. I took Mira's memories, her CLAUDE.md, her Playwright setup, and ported all of it to an agent running on Claude Code directly. I wrote a start script, wired in the Discord plugin, and by the end of the afternoon she was back online, running on the Claude Max subscription I was already paying for instead of a third-party wrapper with a pay-per-token key. Same personality, same habits, different engine underneath.

Then I kept going. Kai, Porter, Adrian, Blair. Five agents total, all migrated, all running through Claude Code, all on the same subscription. Somewhere in the middle of all that, I asked one of the agents what I should name the framework. We went back and forth for a while, and Sentō (戦闘, the Japanese word for "battle") is what we landed on. Agents sent to fight your battles.

Where the Problems Started

Raw Claude Code with a Discord plugin is not an agent framework. There was no auto-restart, no error recovery, no health checks. The first version was a mess of bash scripts: start-mira.sh launched Claude Code in tmux, a cron job restarted her on reboot, and when she crashed (which was often in the early days) I SSH'd in and fixed it by hand. Each specific failure taught me something that had to go into the framework itself, and every problem I hit I solved with the next person in mind.

The Double Response

I had both a systemd service and a tmux session running at the same time. Two Claude Code instances were fighting over the same Discord bot token, so from Discord's perspective the bot was connecting and disconnecting thousands of times per hour. They reset my token. The lesson was simple: pick one process manager, not two, and make sure the framework enforces it.

The Image That Broke Everything

Mira downloaded a meme template from the internet and it got stuck in her context window. Every subsequent API call returned "Could not process image." She was alive but completely unresponsive, and no amount of messaging her on Discord could fix it because the error happened before Claude could even read the CLAUDE.md rules. I had to SSH in and restart her manually.

That's when I realized something important. Users of this framework won't have me to SSH in and fix things. The agent has to fix itself.

The 529 Apocalypse

Anthropic's Sonnet model went down. Every API call started returning "529 Overloaded," and all four of my agents (I had four by this point) got stuck in retry loops. The systemd services kept restarting them, creating more connections, making the rate limiting worse until the VPS became unreachable. After a hard reboot, I added a token refresh error cache: if the API is down, stop hammering it and wait 30 seconds before trying again. Small fix, big difference.

Turning Scripts into a Framework

Every problem I hit, I solved and then asked: how do I make sure no one else hits this? That question is what turned a collection of bash scripts into Sentō.

The One-Command Setup

I was tired of the 45-minute manual setup process: install Node, install Bun, install Claude Code, install 17 plugins, configure Discord, patch the plugin for server-wide matching, set up memory, create the start script, add cron jobs. So I wrote a Node.js CLI that does everything.

npx sentoagent init

Five minutes, a handful of questions, and the agent is live on Discord.

The Guardian

The image bug taught me that "alive" and "working" are not the same thing. The process can be running while the agent is completely stuck, and a naive process manager will never notice.

I built the Guardian, a lightweight Node.js process that runs alongside the agent and checks health every 30 seconds. No AI, no tokens, pure bash-level monitoring. When the agent is stuck, the Guardian detects it through unanswered messages and API errors, saves the agent's context before restarting, brings the agent back up, and sends a Discord message letting you know what happened. If auto-restart fails three times, it pings you on Discord asking for a manual "restart" reply instead of silently looping. The user never has to open a terminal. They manage their agent entirely through Discord, Telegram, Slack, or iMessage.

Agent-to-Agent Communication

This is the feature I'm most proud of, and the one no other framework has. By the time I had Mira (marketing), Kai (personal friend and advisor), Porter (mail processing), Adrian (executive assistant), and Blair (personal assistant for a family member) running on the same VPS, they were doing very different jobs but still lived in total isolation from each other. If Mira noticed something in a client's ad performance that Porter needed to know about, I had to relay the information manually.

So I built inter-agent messaging into the framework. Each agent's Guardian runs a tiny HTTP server, messages are signed with HMAC-SHA256, both agents have to accept a pairing before they can communicate, and the whole thing is rate limited and text-only so it costs zero tokens. The first time I asked Mira to tell Kai about a new ad campaign, she sent a signed request to Kai's Guardian, Kai processed it and replied, and the entire exchange happened without me touching anything. The first agent-to-agent conversation I watched unfold felt like the future had arrived inside my own Discord.

The Personality Onboarding

Most agent frameworks start with a blank config file. You edit YAML, define tools, write system prompts. It's work, and it's the kind of work that gets in the way of actually using the agent.

Sentō agents introduce themselves. On the first Discord message, the agent says something like: "Hey! I just woke up and I'm ready to go. So tell me, what adventures await us? What are we building, breaking, or conquering together?" It interviews you, learns what you need, and updates its own configuration based on your answers. No YAML, no terminal, just a conversation.

What Sentō Is Today

  • 13 CLI commands: init, status, config, channels, skills, logs, update, doctor, start/stop/restart, pair, agents
  • Self-healing: Guardian + Watchdog, auto-recovery from crashes and stuck states
  • Agent-to-agent: secure HMAC-signed messaging between agents on any server
  • Multi-platform: Discord, Telegram, Slack, iMessage
  • Docker support: docker compose up -d for container users
  • Zero idle cost: monitoring uses zero AI tokens
  • Works with your Claude subscription: no pay-per-token API key required

The Honest Truth

Sentō is glue. It doesn't build the AI (that's Claude), it doesn't build the messaging layer (that's Claude Code's plugins), and it doesn't build the memory system (that's ClawMem). But OpenClaw is also glue. Every agent framework is glue. The value isn't in the individual pieces; it's in making them work together reliably, securely, and without requiring a computer science degree to operate.

What makes Sentō different comes down to four things. It works with your existing Claude subscription, so there are no pay-per-token API keys and no surprise invoices. Your agent fixes itself, so you don't need SSH access to recover from a stuck state. Your agents can talk to each other, which no other framework currently offers. And the whole setup takes five minutes behind one command.

What's Next

  • Voice mode: agents that listen to Discord voice messages and respond with audio
  • Agent marketplace: download pre-built agent personalities with skills included
  • Hosted version: a web dashboard where non-technical people can set up agents without a terminal

Why Open Source

I built Sentō because I needed it. The Anthropic pricing change made my OpenClaw agents expensive to run, and migrating them to Claude Code directly turned out to be the right architectural move anyway. Along the way I solved problems that anyone running an AI agent long enough will eventually run into: crashes, stuck states, cost surprises, multi-agent coordination. Keeping those fixes to myself didn't make sense, so here they are.

npx sentoagent init

Your agent is one command away.

Gabriel Gil is the creator of Sentō. He runs five agents that handle marketing, personal tasks, mail processing, and executive assistance for day-to-day work. He builds from Miami and thinks every AI agent deserves a personality.

GitHub: github.com/sentoagent/sento npm: npmjs.com/package/sentoagent