I Killed My Telegram Bots. Here’s What Replaced Them.

ByDevin

Last week I killed Tomer, Tony, Theo, and Tim — four Telegram bots I’d spent months building. Not because they stopped working. Because I realized the architecture was fighting me instead of helping me.

What the Old System Looked Like

The T-Team was four specialized Telegram bots with distinct roles. Tim handled research and morning intelligence. Tony tracked health and portfolio prices. Tomer ran system ops and cron audits. Theo coordinated. They had LaunchAgent processes, RAG memory, Telegram listeners, and a handoff protocol between them.

On paper, impressive. In practice: four things that could break, four logs to check, four restart procedures to remember, and an invisible coordination tax that accumulated daily. I was spending more energy managing the agents than using their output.

The Moment I Decided to Pull the Plug

It wasn’t one incident. It was noticing the same pattern on repeat: I’d ask Tomer something, it would work, then it wouldn’t, then I’d spend 20 minutes debugging whether it was the LaunchAgent, the listener, the env vars, or Telegram’s rate limits.

The agents were adding complexity faster than they were removing it. That’s the signal. When your automation system needs its own ops team, you’ve gone too far.

What Replaced Them: Four Claude Code Routines

The replacement is embarrassingly simple. Four Python scripts, four cron jobs, one Telegram token used only for one-way sends.

tony_morning_brief.py — Health and Leopold portfolio prices at 07:05. tim_morning_brief.py — Brave news search and Claude summaries at 07:10. tomer_evening_brief.py — System ops audit, cron health, GitHub releases at 21:00. tomer_health_check.py — Silent 30-minute monitor, alerts only on failures.

No listeners. No session state. No LaunchAgents managing other LaunchAgents. Scripts run, generate output, send to Telegram, exit. That’s it.

What I Actually Lost (Almost Nothing)

The capability loss was minimal. I gave up two-way Telegram conversations with the agents. In exchange I got: reliable execution, zero listener failures, no session management, and the ability to read any script’s full logic in under three minutes.

The briefs are the same quality. The system health monitoring is actually better because the logic is simpler and easier to audit. The only thing missing is the ability to ask the agent a follow-up question via Telegram — which in practice I rarely did anyway.

The Broader Lesson About Agent Complexity

There’s a version of this where you keep adding agents until you’ve built something that requires a dedicated person to run. I was trending that direction.

The right question isn’t ‘what can I add?’ It’s ‘what’s the simplest version of this that reliably delivers the output I care about?’ Four cron scripts and one-way Telegram pushes turned out to be that answer.

Clarity of execution beats sophistication of architecture. Every time.

Lessons Learned

  • Bidirectional agents are a maintenance liability — Listening for commands means managing state, handling timeouts, and debugging silent failures. One-way push systems are dramatically simpler and more reliable.
  • Fewer moving parts wins on a long enough timeline — The T-Team was impressive for three weeks. By week eight, the maintenance overhead was the dominant time cost. Simplicity compounds.
  • Your agent architecture should get simpler over time, not more complex — If you keep adding agents to fix problems caused by other agents, the architecture is wrong. Start with outputs you need, work backwards to the simplest system that produces them.

What I’d Do Differently

Start with cron scripts. Seriously. Run simple scheduled Python scripts for 60 days before building anything that listens for commands. You’ll learn what you actually need versus what sounds useful. Most of what sounds useful turns out to be noise.

TL;DR: Ripped out four Telegram bots and replaced them with four cron scripts. Lost bidirectional agent conversations, gained reliable execution and zero maintenance overhead. The simpler system is better in every measurable way.

Similar Posts