Build in Public · ~5 min · AI Agents

My AI agent was waiting for input.
I was at the grocery store.

You start Claude Code on a task, leave the room, come back twenty minutes later — and it's sitting there: "Do you want me to proceed? (y/n)". Twenty minutes. Gone.

The problem

AI agents need a babysitter

Here's something nobody warns you about when you start using AI coding agents: they're not autonomous. Not really. They hit a permission prompt, an ambiguous decision, a file they want to create, a test that failed — and they stop. They wait. Patiently. Indefinitely.

If you're sitting at your desk staring at the terminal, that's fine. You approve, it keeps going. But if you stepped away — to make coffee, to take a call, to go pick up groceries — you come back to find your agent has been frozen for an hour, waiting for a single keystroke.

I've lost entire afternoons to this. Not because the agent was slow, but because I wasn't there to unblock it. The bottleneck in AI-assisted development isn't the AI. It's the human's proximity to the terminal.

I run multiple Claude Code sessions in tmux. Different tasks, different repos, sometimes different branches. On a good day, I context-switch between panes, approve prompts as they come up, and everything flows. On a bad day, three sessions are waiting for input and I didn't notice because I was looking at the fourth one. Or I wasn't looking at any of them because I left the house.

The solution

Put your terminal in a browser

The fix turned out to be three tools I already had, wired together in about ten minutes.

Your laptop
tmux + Claude Code
→
Web terminal
Wetty
→
Secure tunnel
HLE + SSO
→
Anywhere
Phone / Browser

tmux keeps your sessions alive. Multiple panes, each running a Claude Code instance on a different task. Close your laptop lid, sessions keep running. This part most of us already have.

Wetty is a web-based terminal emulator. It runs a small HTTP server and gives you a fully interactive terminal in any browser. Point it at your tmux session, and you've got your entire workspace in a browser tab.

HLE exposes Wetty to the internet with a secure URL and SSO authentication. No port forwarding on your router, no VPN your phone needs to connect to first. Just a URL that works, protected by Google or GitHub login so nobody else can access your terminal.

The result: you open a browser tab on your phone, authenticate once, and you're looking at your tmux session. All your Claude Code instances, right there. Scroll up to see what happened. Switch panes to check on the other tasks. Type y to unblock the agent that's been waiting. All from the checkout line at the supermarket.

How to

Setting it up

Start your Claude Code sessions in tmux as you normally would:

# Create a named tmux session with multiple windows
tmux new-session -d -s work
tmux send-keys -t work "claude" Enter

# Add more windows for parallel tasks
tmux new-window -t work
tmux send-keys -t work "claude" Enter

Run Wetty and point it at your tmux:

# Install Wetty
npm install -g wetty

# Start Wetty, attaching to your tmux session
wetty --port 3000 --command "tmux attach -t work"

Expose it with HLE:

# Expose Wetty with SSO protection
hle expose --service http://localhost:3000 --label terminal

That's it. Your terminal is now at something like https://terminal-x7k.hle.world, behind SSO. Open it on any device, authenticate with your Google or GitHub account, and you're in your tmux session.

SSO is on by default. Only you can access this terminal. Nobody without your authenticated session can even see the login page of Wetty — HLE's SSO gate sits in front of everything. If you want extra protection, you can add a PIN or restrict access to specific email addresses.
In practice

What this looks like day-to-day

The workflow shift is subtle but significant.

You kick off three Claude Code tasks before lunch. One is refactoring a module, one is writing tests, one is fixing a CI pipeline. You leave your desk. An hour later, you pull up the URL on your phone while waiting for coffee.

Pane one: refactoring is done, Claude is asking if you want it to run the test suite. You type y. Pane two: tests are still running, no input needed. Pane three: Claude wants to know if it should modify a workflow file. You glance at the diff, type y.

Thirty seconds of phone time. Two agents unblocked. By the time you're back at your desk, one task is finished and the other two are nearly there.

Compare that to the old way: you come back from lunch, discover all three agents have been idle for 45 minutes, and you spend the first ten minutes just figuring out where each one left off.

The bigger point

The supervision bottleneck

AI coding agents are genuinely powerful. I run multiple Claude Code sessions daily and they do real work — writing code, debugging issues, managing PRs across repositories. But they operate in a loop that requires a human in it. They propose, you approve. They hit a wall, you redirect.

The speed of that loop determines how much you actually get out of them. If you can only check in when you're physically at your desk, you're leaving capacity on the table. A three-hour task doesn't take three hours because the agent is slow. It takes three hours because two of those hours were the agent waiting and you not knowing about it.

Making your terminal accessible from anywhere compresses that idle time. The agent is still the one doing the work. You're just removing the gap between "I need input" and "here's your input."

The takeaway

Everything is where you left it

tmux keeps your sessions alive. Wetty gives you a window into them from any browser. HLE makes it securely reachable from anywhere. Your whole dev environment — every running agent, every open pane, every line of scrollback — accessible from a URL, behind SSO, on any device.

No setup on the client side. No VPN to connect. No app to install. Just a browser and a URL.

My agents still wait for input sometimes. The difference is now I notice within minutes, not hours.