Prox
The local process manager I wanted for agent-assisted development.
Start your project's processes with one command, then let you and your coding agent both watch and control them over an API: tail logs, inspect HTTP requests, restart one service. A TUI gives humans real-time logs with search; an optional mkcert-backed proxy puts services on friendly local HTTPS domains, even sharing one port across several projects, so you can stop memorizing ports.
# bring the whole stack up with one command
api:
port: 5555
env_file: .env
processes:
web: cd frontend && bun run dev --port 3000
api: cd backend && uv run uvicorn main:app --reload
worker: uv run python -m app.worker
proxy:
enabled: true
https_port: 443
domain: local.stridelabs.ai
services:
app: 3000
api: 8000
Overview
Prox is a process manager for local development with an agent-forward design. It brings up your project’s processes with one command (a Procfile-style prox.yaml) and then lets both you and your coding agent watch and control them together. The thing it is built to avoid is copying an error out of a server log and pasting it into an agent. With prox, the agent reads the same logs you do.
Everything a running process exposes (its logs, its status, start, stop, restart) is reachable over an HTTP API, which is what makes that sharing work. You drive it from an interactive TUI with real-time log filtering and search; an agent drives the same actions over the API, with an installable skill to teach it how. It can run in the foreground or as a daemon the agent starts and you attach the TUI to later, and you can restart a single process instead of the whole stack.
An optional reverse proxy is the other half. Give it a base domain and prox routes subdomains to your services (app.local.myapp.dev, api.local.myapp.dev) over locally-trusted HTTPS, with the certificates generated for you through mkcert. Run more than one project at once and a shared per-machine daemon lets them all answer on the same port (say 443) routing by hostname, each project coming up and shutting down on its own; the daemon starts on first use and stops when the last project does, with nothing extra to manage. That means HTTPS locally without the usual hassle, no remembering which service is on which port, and a record of the HTTP requests flowing through that you (or the agent) can filter down to the ones that failed.
Why API-first
Every action prox exposes in its TUI (start, stop, restart, stream logs, inspect requests, check health) is just an HTTP call. That’s the seam that lets a human and a coding agent operate the same dev environment at once: the agent brings services up, watches a log, notices a 500 and reads the request that caused it, all without a person copy-pasting between a terminal and a chat box. It’s the StrideLabs bias in miniature, a tool whose whole surface an agent can drive, that’s just as pleasant to run yourself.
Where it stands
Prox mostly does what I need now. I expect it to keep improving around the edges, but the shape is settled: a small process manager that is useful to run by hand and useful to hand to an agent.
Stop pasting errors into your agent
You and your coding agent read the same running processes over an API. Instead of copying a stack trace into chat, the agent tails the failing log or pulls the bad HTTP request itself.
Local HTTPS, shared across projects
An optional reverse proxy puts your services on subdomains like app.local.myapp.dev over mkcert-trusted HTTPS. A shared per-machine daemon lets several projects answer on one port (say 443), routed by hostname and each started and stopped on its own, so you stop remembering which service is on which port.
Request introspection
The proxy records the HTTP requests flowing through it; filter by service or status code (say, everything that 500'd) from the API or TUI to see what actually failed during a test run.
A TUI built for humans
Real-time logs with filtering and search (follow one noisy service or grep across all of them while they run) with start, stop, and restart from the same view.
Daemon mode, attach any time
An agent can bring the stack up in the background with prox up -d; attach the TUI later with prox attach, detach, and it keeps running. Restart a single process instead of the whole stack.
Simple by default, installs anywhere
A Procfile-style config and prox up for the common case, with optional per-process health checks. Homebrew, a signed apt repo, .deb downloads, or go install (amd64 and arm64).