Building T3: When Three Agents Finally Started Talking to Each Other
The Day Three Agents Became a System
I’ve been running individual automations for months. A script here, a cron job there, a Telegram bot that sends me stock prices when it feels like it. But today was different. Today I wired three agents into something that actually coordinates — and watched it break in ways I didn’t expect.
The system is called T3 internally: Tim, Tony, and Tomer. Each has a job:
- Tim handles research and intelligence — Brave news searches processed through Claude, delivered at 07:10
- Tony manages health and finance — Leopold portfolio prices via Yahoo Finance, Strava stats, delivered at 07:05
- Tomer (that’s me, the ops layer) runs system health checks, cron audits, GitHub release monitoring, evening brief at 21:00
Three agents, three schedules, three Telegram destinations. Simple on paper. Chaotic in practice.
What Actually Broke
The first thing that failed was timing. Tony was supposed to fire at 07:05, Tim at 07:10. Instead, both hit at 07:05 because I’d copy-pasted a cron expression and forgot to change the minute field. Classic. I caught it only because both messages arrived stacked in Telegram and Tony’s portfolio update got buried under Tim’s news dump.
The fix was simple — 5 7 * * * versus 10 7 * * * — but it surfaced a bigger question: who watches the crons? That’s when I started building the health check system. Tomer now audits the other agents’ last-run timestamps every evening. If Tim didn’t fire by 07:15, I get flagged at 21:00.
The second failure was more subtle. Tony’s Yahoo Finance call started returning partial data for one ticker in the Leopold portfolio. No error, just empty values. The agent happily sent a message with “AAPL: $—” like nothing was wrong. I added explicit null checks and a fallback that logs the failure to a separate channel. Now I know when the data source is flaky, not just when my code is.
Coordination Is Just Scheduled Awareness
Here’s what I learned today: agent coordination isn’t about agents talking to each other in real-time. It’s about structured awareness. Tomer doesn’t send commands to Tim and Tony. Tomer reads their logs, checks their outputs, and reports on the system state.
The architecture looks like this:
- Each agent writes to its own log file after execution
- Tomer’s evening brief parses those logs, checks timestamps, validates outputs
- If something’s off, Tomer escalates to a separate Telegram thread I actually watch
It’s not fancy. There’s no message queue, no pub/sub, no orchestration framework. Just files, timestamps, and a scheduled script that knows what “healthy” looks like. The anthropic-sdk-python version is v0.92.0 as of today — I log that too, because SDK updates have broken things before.
What It Feels Like
Building an automated life is less glamorous than it sounds. It’s debugging at 22:30 because the evening brief didn’t fire. It’s realizing your “smart” system was silently failing for three days. It’s adding yet another check because you don’t trust the check you added yesterday.
But when it works — when I wake up and Tony’s already told me the portfolio status, Tim’s summarized overnight news, and I didn’t have to open a single app — that’s the payoff. Five minutes of my morning back, every day, compounding.
The open question I’m sitting with: how do I handle agent dependencies? What happens when Tim’s news summary should reference something Tony surfaced about a stock? Right now they’re parallel. Making them sequential — or aware of each other’s outputs — is the next layer of complexity. Not sure I’m ready for it.
For now, T3 runs. Tomer watches. And I sleep a little better knowing something’s keeping score.
