Claude Code Remote-Control vs Tailscale vs Telegram Bots: Which Is Best for Remote Access?

Mar 17, 2026

The Problem

I wanted to continue my Claude Code sessions when away from my computer. Maybe check on a long-running task from my phone, or clear a stuck session remotely.

I tried three approaches:

Claude Code’s built-in remote-control
Tailscale + tmux for persistent sessions
A custom Telegram bot bridge

After testing all three, I found that each has a place—but the built-in option works for most people, and Tailscale is the upgrade path when you need more. Telegram bots are generally overkill.

Option 1: Built-in Remote-Control (Simplest)

Claude Code has a native remote-control feature that’s included free. You enable it once, and then you can access your session from any browser.

claude remote-control

Output:

✓ Remote control enabled
✓ Session ID: abc123xyz
✓ Access URL: https://claude.ai/remote/abc123xyz

From your phone or another computer, open that URL. You’re connected to your Claude Code session.

What works well:

Zero setup beyond one command
Works over HTTPS through Anthropic’s servers
No port forwarding required
Free (included with Claude Code)
No network configuration

What doesn’t work well (from Reddit user FromAtoZen, 55 upvotes):

“It disconnects frequently, you can’t clear sessions remotely, and there are no slash commands yet. The feature feels half-baked compared to Tailscale + tmux.”

I experienced the same issues. The connection drops every 15-20 minutes of inactivity. When it drops, you lose context. And if your local session hangs, you can’t reset it from the remote interface.

When to use built-in remote-control:

Quick check-ins from your phone
Short remote sessions (under 30 minutes)
You don’t need persistent sessions
You want zero setup time

Option 2: Tailscale + tmux (Most Features)

When the built-in option frustrated me, I tried Tailscale with tmux. This approach keeps your session running persistently and gives you full terminal control.

# Install Tailscale
brew install tailscale

# Authenticate
sudo tailscale up

Your machine gets a permanent address:

✓ Assigned IP: 100.x.y.z

Then I start Claude Code inside tmux:

# Start tmux session
tmux new -s claude

# Inside tmux, start Claude Code
claude

# Detach with Ctrl+B, then D
# Session keeps running in background

From my phone or another computer:

# Install Tailscale on remote device
# Connect to same tailnet

# SSH to my machine
ssh [email protected]

# Attach to tmux session
tmux attach -t claude

Claude Code session is exactly where I left it.

What works well:

Session persists forever (until you close it)
Full terminal access, not limited to Claude Code features
Can clear sessions, kill processes, restart services
Works with any terminal-based tool
More stable connection

What doesn’t work well:

Requires initial setup (Tailscale account, SSH config)
Need tmux knowledge
Network dependency (both devices need internet)
Mobile terminal experience is cramped

When to use Tailscale + tmux:

Long-running tasks you need to monitor
Remote debugging sessions
Multiple terminal tools, not just Claude Code
You need full control from remote

Option 3: Telegram Bot (Generally Unnecessary)

I also explored building a Telegram bot that would relay messages to my Claude Code instance. The idea: send a Telegram message, get a response from Claude.

After building it, I realized this was over-engineered.

What you need for a Telegram bot:

1. Telegram bot token (BotFather)
2. Webhook server (or long polling)
3. Message queue for async responses
4. Session management
5. Authentication layer
6. Rate limiting
7. Error handling
8. Security considerations

The Reddit community echoed this. One comment:

“Why add another layer when built-in remote-control exists? Telegram makes sense for notifications, not interactive sessions.”

The only use case where Telegram helps: you want notifications when long tasks complete, without keeping a session open. But even then, you could use Tailscale + a notification script instead.

When Telegram might make sense:

Push notifications for task completion
You’re already heavy on Telegram for other automation
Async queries (send question, get answer later)

When Telegram is overkill:

Interactive sessions
Real-time responses
Simple remote access needs

Comparison Table

Feature	Built-in Remote-Control	Tailscale + tmux	Telegram Bot
Setup time	1 command	30 minutes	Hours
Cost	Free	Free (personal)	Server costs
Session persistence	No	Yes	Varies
Remote session clearing	No	Yes	No
Mobile experience	Good (browser)	Okay (terminal)	Good (app)
Full terminal access	No	Yes	No
Network dependency	Anthropic servers	Internet required	Internet required
Connection stability	Drops frequently	Stable	Depends on server
Best for	Quick check-ins	Power users	Notifications only

Option 4: Termux on Android (Bypass Remote Access Entirely)

Reddit user Historical-Lie9697 pointed out another option:

“Just install Termux from F-Droid and run Claude Code directly on Android. No remote access needed.”

This works if you have an Android device and want native mobile access:

# Install Termux from F-Droid (not Play Store)
# Open Termux, run:

pkg install nodejs
npm install -g @anthropic-ai/claude-code
export ANTHROPIC_API_KEY="your-key"
claude

Advantages:

Native experience on Android
No network dependency for remote access
Full Claude Code features on mobile

Disadvantages:

Android only (no iOS option)
Typing on phone is limited
Smaller screen makes code review hard
Not truly “remote” access—your phone runs it

My Recommendation Path

After testing all options, here’s my decision tree:

Do you need remote access?
│
├── Yes, quick check-ins only
│   └── Use built-in remote-control (free, zero setup)
│
├── Yes, need persistent sessions
│   └── Use Tailscale + tmux (30 min setup, full control)
│
├── Just want notifications
│   └── Telegram bot (but consider simpler alternatives)
│
└── Have Android and want native mobile
    └── Termux + Claude Code directly on device

Common Mistakes

From my trial-and-error and the Reddit discussion:

Mistake 1: Over-engineering with Telegram

Problem: Building a bot bridge when built-in options exist
Fix: Start with built-in remote-control, upgrade to Tailscale if needed

Mistake 2: Ignoring session management

Problem: Built-in remote-control disconnects, you lose context
Fix: For long tasks, use Tailscale + tmux for persistence

Mistake 3: Not considering Termux on Android

Problem: Setting up complex remote access when you could run natively
Fix: If you have Android, try Termux first

Mistake 4: Assuming all features work remotely

Problem: Remote-control doesn’t have slash commands yet
Fix: Check the docs for feature parity before committing

Mistake 5: Forgetting network dependency

Problem: Remote access needs internet on both ends
Fix: Plan for offline scenarios, or consider native mobile with Termux

The Setup I Use Now

I settled on a hybrid approach:

For short sessions: Built-in remote-control

Quick question from phone during commute
Check on a task status
Review a completed change

For long-running work: Tailscale + tmux

Multi-hour refactoring tasks
Remote debugging sessions
Running tests that take time

I removed my Telegram bot experiment. It added complexity without solving a real problem.

Summary

In this post, I compared three approaches to remote access for Claude Code. The built-in remote-control is the simplest option—it’s free, requires one command to enable, and works over HTTPS. Tailscale + tmux offers more features like session persistence and full terminal control. Telegram bots are generally unnecessary for this use case.

The key insight: start with built-in remote-control. If you hit its limitations (disconnections, no remote clearing, missing features), upgrade to Tailscale. Don’t build a custom bot bridge unless you specifically need async notifications.

For Android users, running Claude Code directly in Termux bypasses the remote access question entirely—but it’s not an option for iOS.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

👨‍💻 Reddit: Claude Code Remote-Control Discussion
👨‍💻 Claude Code Documentation
👨‍💻 Tailscale

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!