# Don't be the meat proxy > When you copy the output of one system and paste it into another, you are operating as a network link made of meat: slow, lossy, unlogged, and off-shift sixteen hours a day. Human judgment belongs in the loop. Human transport never does. Build the channel once, and keep your attention for the decisions. - Canonical: https://jedarden.com/notes/dont-be-the-meat-proxy/ - Published: 2026-08-17 - Tags: agents, collaboration, friction --- The agent needed to know how a page rendered on my phone. So I picked up the phone, looked at it, and typed a description into the chat. The agent asked a follow-up — was the banner above the fold or below it? I picked the phone back up. Somewhere around the third round trip I understood what my role in this system actually was: two computers were having a conversation about a rendering bug, and I was the cable. I've started calling this being the **meat proxy**: a human operating as the transport layer between two systems that have no direct channel to each other. You copy the stack trace out of one window and paste it into another. You read a dashboard aloud into a chat box. You run the command the agent gave you and relay what it printed. Nothing about the information changes on its way through you — no judgment applied, no decision made, no bit flipped. You are moving bytes by hand between two machines that are, in most cases, already on the same network. Stated plainly, this is beyond stupid. It is also the default posture of nearly every agent workflow I see. ## The worst network link you will ever operate Evaluate a human as transport equipment and the spec sheet is grim: **Latency.** Seconds when you're at the keyboard, hours when you're not. You are the slowest hop in any pipeline you join, by three to six orders of magnitude. **Lossy by design.** You don't relay; you summarize. You paste the part of the error that *looked* relevant and drop the frame that mattered. A description of a screenshot is not a screenshot. Every transfer through a human is a transfer through a compressor with opinions. **Error-prone.** Stale clipboard. Wrong window. The hand-redaction that removed one character too many. None of these failure modes announces itself — the corrupted payload arrives looking exactly like a good one. **Availability.** You sleep eight hours. You have a job. Every transfer is synchronous with your attention, which means every transfer queues behind your entire life. **Unlogged.** Neither system records that the transfer happened. It cannot be retried, audited, or replayed. The most important hop in the pipeline is the only one with no observability at all. If a vendor tried to sell you this link, you would laugh them out of the room. Then you'd alt-tab and paste something. ## Transport is not judgment The steelman for humans-in-the-loop is real, and I want to be precise about what this note is *not* arguing against. A human as a **decision point** is often exactly right: approving the irreversible action, reviewing the diff before merge, [catching the number that can't possibly be true](/notes/anchor-on-a-fact-the-model-cant-see/). In those loops, something passes through your judgment and comes out *different* — approved, rejected, corrected. That is the job. That is the part worth being slow for. The meat proxy is the degenerate case: information passes through your hands and comes out identical. The test is one question — **could this transfer have been a pipe?** If replacing you with `cat` would lose nothing, you weren't a decision point. You were plumbing. Friction in a system should be a decision, not an accident. Deliberate friction — the approval gate, the review step — is a control surface you designed. The meat proxy is accidental friction: a tax you pay on every single transfer, forever, because nobody spent one afternoon building the channel. ## Build the channel once Every direct channel in my setup exists because I got sick of one specific copy-paste loop: **The phone.** The rendering question that opened this note doesn't reach me anymore. The phone is on the tailnet with ADB exposed; the agent takes a screencap, reads the image itself, and taps the screen if it needs to navigate. The phone went from "thing I describe" to "peripheral the agent operates." As a bonus it became the failover web connection — when a request fails from the server, the agent checks the URL through the phone's own network before concluding anything is down. **The clusters.** I used to be the person pasting `kubectl get pods` output into a chat window. Now every cluster runs a read-only proxy the agent can query directly. When it wants pod status, it asks the cluster — the actual authority on the matter — instead of asking me to ask the cluster. **Command output.** Commands the agent needs run now run where both of us can read the result, instead of me ferrying stdout across a window boundary one selection at a time. **A real browser.** An old laptop on the bench keeps a live display session up; the agent screenshots it and drives a real browser when "does this actually render" is the question. Each of these took an afternoon or less. Each one deleted a category of copy-paste permanently. That's the whole economic argument: the meat proxy charges per transfer, forever; the channel charges once. And for the transfers where a human genuinely must carry the message — UI feedback is the classic — you can at least stop being lossy. [Agentation](https://github.com/benjitaylor/agentation) exists for exactly this: click the element and the agent gets a CSS selector and DOM context, not "the card in the top right." If you must be the proxy, don't also be the compressor. There is a scale version of this, too. Interactively, the meat proxy wastes minutes. At fleet scale it is disqualifying: [twenty headless workers](/notes/agents-pets-cattle/) cannot route their I/O through my hands, so the only transfers that happen at all are the ones with a real channel. Building the channel isn't an optimization on the loop — it's the precondition for taking yourself out of it. ## What it costs **Channels carry authority.** A direct channel means the agent can do the thing without you, and that should make you think before it makes you comfortable. The answer is scoping, not abstinence: nearly every meat-proxy loop I've replaced was read-only, so the channels are read-only — my cluster proxies mechanically *cannot* write. Where a channel would carry write authority, that's a decision point wearing a transport costume, and the human stays. [Trust is a property of the system](/notes/trust-is-a-property-of-the-system/): the fix for a scary channel is scope and reversibility, not vigilance. **The setup cost is lumpy and the paste is not.** Eight seconds of copy-paste never feels worth an afternoon of plumbing, which is exactly why the friction survives. But you don't actually pay eight seconds — you pay a context switch, and worse, you pay in the transfers that *never happen*. When asking you is expensive, the agent stops asking. It works blind, guesses instead of checking, and hands you output shaped by every question it didn't ask. The deepest cost of being the meat proxy isn't the pastes you perform; it's the checks that silently don't occur because you priced them out. **Sometimes the copy-paste was doing double duty.** Eyes on the data as it moved through you — an accidental review step. Remove the transport and you remove that too, so [put the review back deliberately](/notes/dont-let-the-agent-grade-its-own-homework/), as a gate you designed, instead of a side effect of your own slowness. ## The question I now ask When I catch myself copying from one window and pasting into another: > Did anything here pass through my judgment, or only through my clipboard? If it passed through judgment — a call was made, a number was checked, an action was approved — then that's the job, and it should stay mine. If it only passed through the clipboard, I just found a missing channel, and every repetition of that paste is another vote for spending the afternoon. The systems can talk to each other. They are usually on the same network. The only reason you're carrying the message is that nobody built the wire — and you're the only component in the whole pipeline that can fix that. — Jed --- *Related: [Trust is a property of the system, not the agent](/notes/trust-is-a-property-of-the-system/) — why the fix for a scary channel is scoping and reversibility, not vigilance. And [Don't let the agent grade its own homework](/notes/dont-let-the-agent-grade-its-own-homework/) — the review step you must re-add on purpose once you stop being the wire.*