How I Expose Agent-Built Localhost Apps With a Short-Lived Public URL
TL;DR: Quackshell gives agent-built localhost apps a short-lived public URL.
A lot of my AI-assisted development work now starts the same way: I ask an agent to build or modify a small local web app, it starts a dev server on localhost, and then I need to actually see it, test it, share it, or connect it to something outside my machine.
That last step is where things usually get annoying.
Localhost is great for building, but it is terrible for collaboration, mobile testing, webhook testing, and agentic workflows where another tool needs to reach the thing your agent just created. Deploying every experiment is too slow. Setting up infrastructure is too heavy. Leaving long-lived tunnels open is more exposure than I usually want.
So I built Quackshell: a small CLI that gives a local web app a temporary public URL.
The Problem
Agent-built apps are often disposable, experimental, and fast-moving. An agent might spin up a React app, a Python server, a dashboard, a prototype, or a one-off tool. The useful moment is immediate: “show me what you built.”
But if the app only exists at:
http://localhost:3000then it is trapped on your machine.
That makes simple things harder than they should be:
- Opening the app from your phone
- Sharing a preview with another person
- Letting another agent or automation inspect it
- Testing callbacks or webhooks
- Running a demo without deploying
The old answer was usually “deploy it” or “set up a tunnel.” Both work, but they do not always fit the pace of agentic development.
The Workflow I Wanted
I wanted something closer to this:
# Start any local app
python -m http.server 8000
# Expose it temporarily
quackshell-cli --port 8000 --api-token <token>The CLI prints a public URL. Anyone with that URL can reach the local app while the session is running.
When I stop the CLI, the public session stops working.
That is the whole idea.
Why Short-Lived URLs Matter
The short-lived part is important. Most agent-built apps are not production systems. They are previews, experiments, throwaway dashboards, mini tools, and demos.
For that kind of work, I do not want a permanent deployment every time. I want a temporary viewing window.
A short-lived public URL fits the shape of the work:
- The app starts locally.
- The URL exists while I am actively working.
- The URL dies when the session ends.
That makes it useful for rapid iteration without turning every experiment into infrastructure.
Where This Gets Useful
The obvious use case is sharing a local app with another human. But the more interesting use case is agentic workflows.
If an agent builds a local UI, another tool can open the public URL and inspect it. If a prototype needs a webhook callback, the callback can hit the temporary URL. If I want to test the mobile version, I can open the URL on my phone without changing my network setup.
It turns local development into something that can briefly participate in the wider web.
A Simple Mental Model
Quackshell is not trying to replace deployment.
It is for the step before deployment:
- “Can I see it?”
- “Can I share it?”
- “Can this external service reach it?”
- “Can my agent show me what it made?”
If the answer needs to be yes for the next ten minutes, a short-lived public URL is often enough.
Example
Imagine an agent creates a small dashboard and starts it on port 5173:
npm run devInstead of deploying the dashboard, I can expose it:
quackshell-cli --port 5173 --api-token <token>Now I have a public URL I can open, send, test, or hand to another workflow.
When I am done, I stop the CLI. The session ends.
Why This Feels Different With Agents
Before AI coding agents, localhost was mostly a developer-only space. You built something, checked it yourself, and eventually deployed it.
With agents, localhost is becoming a workspace that other systems need to interact with. Agents can build apps, modify them, run them, inspect them, and use them as part of a larger loop.
That makes local apps more valuable when they can be temporarily reached from outside the machine.
The public URL becomes a bridge between an agent-built local artifact and the rest of the workflow.
Closing Thought
Agentic development is making software creation faster and more local. But the web is still built around reachable URLs.
Quackshell is my attempt to make those two worlds meet: keep the speed of localhost, but give it a short-lived public address when the workflow needs one.
For builders working with local agents, prototypes, demos, and automation loops, that small bridge can remove a surprising amount of friction.
