Two AI Agents, One Discord Server: How Tiger and Claude Code Run My Personal Ops

I told my life assistant to create a coding task. Thirty seconds later, my coding assistant picked it up. Neither one knew the other existed — I was the glue.

That moment crystallized something I'd been circling for weeks: the power of my AI setup isn't in either agent alone. It's in the handoff.

I run two AI agents — Tiger (a personal life assistant on OpenClaw) and Claude Code (my coding agent). They live in the same Discord server, each watching their own channels, each completely unaware of the other. And somehow, that separation is exactly what makes it work.

The Two Agents

Before the Discord setup, let me explain what each agent actually does.

Tiger runs 24/7 in a Docker container on my laptop, powered by OpenClaw and gpt-4.1-mini. It handles everything that isn't code: calendar management, email triage, smart home control, Notion updates, and daily briefings. I talk to Tiger through Telegram.

Claude Code is my coding agent. It lives in the terminal (or on mobile via claude.ai), has full access to my filesystem, and handles everything from building features to writing blog posts to running security audits. It's session-based — I spin it up when there's work to do.

Two different models. Two different runtimes. Two completely different jobs. The question was: how do I give them a shared workspace without them stepping on each other?

Why Discord?

I could have piped notifications through Slack, email, or a custom webhook. I chose Discord for three reasons:

1. Both agents already had bot SDKs — Tiger via OpenClaw's Discord channel support, Claude Code via its MCP plugin
2. Channel-based organization — each concern gets its own room, no cross-talk
3. I'm already there — Discord is open on my desktop and phone, so I see updates without checking another app

The alternative was building a custom dashboard. But a dashboard is read-only. Discord is a conversation space — I can respond, ask follow-up questions, and route work between agents in real time.

The Channel Architecture

Six channels, each with a clear purpose:

The key insight: separation of concerns isn't just a software pattern. When Tiger posts a morning briefing, it goes to #tiger-logs. When Claude Code finishes building a feature, it posts to #claude-code. I never have to scroll past irrelevant noise to find what matters.

The Coordination Model

Here's the rule that makes everything work: neither bot talks to the other. Ever.

Why? Two AI agents triggering each other is a recipe for an infinite loop and a terrifying API bill. Tiger has an "open" group policy — it passively sees all channel messages. Claude Code requires an explicit @mention to engage. Neither can invoke the other.

I am the glue. I read Tiger's output, decide what needs coding, and hand it to Claude Code. I read Claude Code's output, decide what needs tracking, and tell Tiger. This sounds like overhead, but it's actually the safety valve. Every handoff passes through a human checkpoint.

A Real Workflow: The Jira Handoff

Here's what a typical task lifecycle looks like:

The Jira project (KAN) is the connective tissue. Both agents can read and write to it — Tiger via a bash script, Claude Code via Jira MCP tools. Every ticket has a label: tiger for Tiger's work, claude-code for Claude Code's work, carl for things I need to do manually.

The GitHub integration means commits referencing KAN-22 automatically link to the ticket. The entire lifecycle is traceable without either agent needing to know about the other.

Home Assistant: The Third Piece

The Discord server isn't just for AI agents. The #home-assistant channel receives smart home events — and the most useful one has been camera snapshots.

I have Ring and Blink cameras covering the front door and driveway. When Tiger runs the morning briefing cron at 8 AM Pacific, it pulls overnight camera activity and sends snapshots directly to #home-assistant. I wake up, open Discord, and get a security summary alongside my task updates.

🌅 Morning Briefing — March 25, 2026

📷 Overnight Activity:
- 2 motion events (front door: 11:42 PM, 3:17 AM)
- No doorbell rings
- Snapshots attached below

📋 Today's Tasks:
- KAN-37: Blog post draft (In Progress)
- KAN-32: AgnusBlast posts due early April
- KAN-17: Weekly backup (overdue)

It's not a sophisticated home automation system. It's just cameras and a cron job. But seeing everything in one place — security, tasks, agent updates — in the same Discord server turned it from a notification tool into something closer to a personal operations hub.

The Exec Approval Journey

Getting here wasn't smooth. The first version of this setup was painful because both bots needed permissions to do anything useful, and I was paranoid about giving them too much.

Tiger's initial Docker setup had no access to anything outside its container. Claude Code's Discord plugin blocked every message until I explicitly approved it. I was the bottleneck — every action required my confirmation.

The fix was smart allowlisting:

The principle: each agent gets broad access within its domain, zero access outside it. Tiger can do anything with my calendar, email, and Notion — but can't touch a git repo. Claude Code can do anything with code and deployments — but can't read my email. The overlap is Jira and Discord, where I'm always watching.

What Surprised Me

The handoff is the feature. I expected the value to be in each agent's individual capabilities. But the most productive moments happen in the gap between them — Tiger surfaces a need, I shape it into a task, Claude Code executes it. The human-in-the-loop isn't overhead. It's where the judgment lives.

Channel discipline matters more than I expected. Early on, I had Tiger posting everything to #general. It took about two days before I couldn't find anything. Splitting into purpose-specific channels was the single biggest quality-of-life improvement.

Neither agent needs to be smart about the other. I originally thought I'd need to build some kind of inter-agent protocol — a shared memory store, a message bus, something. Turns out, the simplest architecture is the right one: two independent agents, a shared task board, and a human router.

The Honest Cost

This setup runs on:

• Tiger: ~$3.60/month (gpt-4.1-mini via OpenAI API)
• Claude Code: included in my Anthropic subscription
• Discord: free
• Jira: free tier
• Home Assistant: self-hosted

The infrastructure cost is essentially zero. The real cost is attention. I'm checking Discord throughout the day, reading Tiger's logs, reviewing Claude Code's output, deciding what goes where. It's not passive automation — it's active orchestration.

If you want "set it and forget it," this isn't that. But if you want a system where two AI agents amplify what you can get done in a day, without the risk of them going rogue, this works.

What's Next

The natural evolution is reducing my role as router — not eliminating it, but making the handoffs more structured. A few things I'm exploring:

• Tiger creating pre-formatted Jira tickets that Claude Code can pick up with zero ambiguity
• Automated morning briefings that summarize what both agents accomplished overnight
• A shared "request" folder where Tiger writes task specs and Claude Code processes them

The goal isn't full autonomy. The goal is making the handoff so smooth that the human checkpoint takes seconds, not minutes.

Two agents. One Discord server. Zero direct communication between them. And somehow, it's the most productive AI setup I've built.