Guessing local versus remote wastes both battery and tokens. Measure three gates before any prompt leaves disk. Connectivity, secret residue, and wall-clock cost decide the hop.
A laptop is a workshop on your desk. A remote model is a mill across town. You do not crate the shop for one cut.
House keys do not travel with the lumber. Secrets inside a prompt are those house keys. A free mill still sits far across town.
This article is a measurement workflow, not a bake-off. The script below is a labeled example only. Run it locally and trust only its clocks.
Coding agents now plan, search, and generate together. Local context is cheap to read from disk. Completion on a cold CPU can stall hard.
Remote completion can still win on that stall. It can also leak residue or hang offline. Extra latency can erase the time it saves.
Weekly agent glossaries rename the same moving parts. The useful question stays narrower than weekly branding. When does a remote hop beat a local stall?
Three gates answer that without slogans or dashboards. Gate one is reachability on the open wire. Gate two is leftover secret material in text.
Gate three is a stopwatch on both sides. Skip any gate and the decision is folklore. Folklore is how keys leave working laptops daily.
The wire is a hard constraint, not a preference. If the socket fails, stay on local disk. Offline work does not negotiate with a mill.
Secret residue is the second hard stop today. Clean the text or refuse the send. A price of zero does not change that physics.
Only then time the work with a cheap stub. Walk the tokens on CPU and probe RTT. Remote wins when CPU dominates a thin payload.
Arithmetic beats instinct on that last gate check. A long round trip cannot beat a short stub. A throttled laptop can still lose on decode.
Do not assume which machine is slower today. Thermal state and queue time both move around. Measure the hop on the machine you have.
Disclosure: This article was prepared as part of MonkeyCode's product outreach. MonkeyCode offers free model access and a free server option. Those two availability facts are the only product claims used here.
No model names, quotas, or hardware figures appear above. The workflow holds if you never rent that mill. Use remote capacity only after the three gates pass.
Treat the product as optional rented mill time. The workshop remains on local disk until then. Thin, clean, slow-at-the-bench work may leave later.
Save this example artifact as local_remote_gate.py on disk. It prints a verdict and the supporting clocks. It does not call any vendor network API.
#!/usr/bin/env python3
"""Proposal: local-first gate for LLM payloads.
Example only. Not a DLP product. Not a latency SLA.
Run: python3 local_remote_gate.py path/to/prompt.txt
"""
from __future__ import annotations
import argparse
import re
import socket
import time
from pathlib import Path
SECRET_HINTS = (
re.compile(r"AKIA[0-9A-Z]{16}"),
re.compile(r"-----BEGIN (?:RSA |OPENSSH |EC )?PRIVATE KEY-----"),
re.compile(r"(?i)api[_-]?key\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{20,}"),
re.compile(r"(?i)secret\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{16,}"),
re.compile(r"ghp_[A-Za-z0-9]{20,}"),
re.compile(r"xox[baprs]-[A-Za-z0-9-]{10,}"),
)
def read_payload(path: Path) -> str:
return path.read_text(encoding="utf-8", errors="replace")
def gate_wire(host: str, port: int, timeout: float) -> tuple[bool, float]:
started = time.perf_counter()
try:
with socket.create_connection((host, port), timeout=timeout):
rtt_ms = (time.perf_counter() - started) * 1000.0
return True, rtt_ms
except OSError:
rtt_ms = (time.perf_counter() - started) * 1000.0
return False, rtt_ms
def gate_secrets(text: str) -> list[str]:
hits = []
for rx in SECRET_HINTS:
if rx.search(text):
hits.append(rx.pattern)
return hits
def gate_clock(text: str) -> dict[str, float]:
started = time.perf_counter()
tokens = text.split()
acc = 0
for tok in tokens:
acc ^= hash(tok.lower())
acc &= 0xFFFFFFFF
local_ms = (time.perf_counter() - started) * 1000.0
bytes_len = len(text.encode("utf-8"))
return {
"local_ms": local_ms,
"approx_tokens": float(len(tokens)),
"bytes": float(bytes_len),
"checksum": float(acc),
}
def decide(
wire_ok: bool,
rtt_ms: float,
hits: list[str],
local_ms: float,
bytes_len: float,
) -> str:
if not wire_ok:
return "LOCAL_OFFLINE"
if hits:
return "LOCAL_SECRETS"
remote_floor_ms = rtt_ms + max(40.0, bytes_len / 4000.0)
if local_ms < remote_floor_ms:
return "LOCAL_FASTER"
if bytes_len > 120_000:
return "LOCAL_PAYLOAD_FAT"
return "REMOTE_OK"
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("payload")
parser.add_argument("--host", default="1.1.1.1")
parser.add_argument("--port", type=int, default=443)
parser.add_argument("--timeout", type=float, default=1.5)
args = parser.parse_args()
text = read_payload(Path(args.payload))
wire_ok, rtt_ms = gate_wire(args.host, args.port, args.timeout)
hits = gate_secrets(text)
clock = gate_clock(text)
verdict = decide(wire_ok, rtt_ms, hits, clock["local_ms"], clock["bytes"])
print(f"verdict={verdict}")
print(f"wire_ok={wire_ok} rtt_ms={rtt_ms:.1f}")
print(f"secret_hits={len(hits)}")
print(f"local_ms={clock['local_ms']:.2f}")
print(
f"approx_tokens={int(clock['approx_tokens'])} "
f"bytes={int(clock['bytes'])}"
)
if verdict != "REMOTE_OK":
print("action=keep_payload_on_disk")
else:
print("action=remote_hop_allowed_after_human_review")
if __name__ == "__main__":
main()
Run it against a prompt file you already own. Keep real secrets out of the sample file. The command below uses a boring refactor note.
printf 'refactor the parser in src/parse.ts\n' > /tmp/prompt.txt
python3 local_remote_gate.py /tmp/prompt.txt
Now prove the secret gate with a fake string. Confirm the verdict becomes LOCAL_SECRETS on that file. Never paste a live credential into the scratch path.
printf 'api_key=not-a-real-key-0123456789abcdef\n' > /tmp/dirty.txt
python3 local_remote_gate.py /tmp/dirty.txt
Point the host flag at an unreachable address next. Confirm the verdict becomes LOCAL_OFFLINE without further debate. A mill you cannot reach is not faster.
python3 local_remote_gate.py /tmp/prompt.txt --host 192.0.2.1 --timeout 0.4
Read local_ms as a stub, not full inference. Full local generation needs your own runtime stack. This script asks eligibility before any heavy decode.
Replace gate_clock with a real tokenizer later on. Keep the same decide function and printed fields. Stable gates matter more than a fancy clock source.
Fat repo dumps should fail LOCAL_PAYLOAD_FAT on purpose. Remote hops like thin diffs, not whole monorepos. Mail a cut list, never the whole lumberyard.
Whitespace token counts are not model tokenizer output. They still catch oversized context before the wire. That cheap signal is the entire point here.
The 40ms floor is a labeled heuristic constant. The 4000 bytes per millisecond factor is also heuristic. Replace both after you sample your own path.
Secret residue remains the quiet production failure mode. Latency-only routing is how keys leave buildings. Free remote capacity is still fully remote capacity.
Free does not mean unlogged or magically local. Free does not mean a promise of zero retention. If cleanliness is unproven, ignore the stopwatch completely.
The remote floor inside decide() stays conservative on purpose. It adds RTT plus a bytes-derived floor value. It assumes no queue and no TLS handshake tax.
Queue time can erase an apparent remote win fast. DNS, TLS, and auth add still more delay. Swap --host to the real endpoint before trusting RTT.
Here is who should run this gate first. Solo developers on mixed-offline laptops benefit first here. Small teams that already redact git secrets also fit.
Here is who should skip this entire approach. Residency rules can forbid the hop even now. Certified DLP suites sit outside this example's class.
Air-gapped work must never open the probe socket. Novel secret formats will slip past these regexes. Docs that quote fake keys will false-positive often.
REMOTE_OK is permission to consider a remote hop. It is not an order to send any bytes. Keep a human on the first weeks of verdicts.
Log decisions locally and omit the payload bodies. Do not wrap the gate as a silent sidecar. Silent retries around LOCAL_SECRETS create messy incident reports.
Attach a remote client only to files that passed. Send a diff, not the tree that produced it. Retry after cleaning source, never after ignoring hits.
A default probe to 1.1.1.1 only tests public reachability. That address is not your model host. Wrong RTT data will invert the last gate.
Local hash-walking is not thermal telemetry either. A fan-loud laptop can still print a tiny local_ms. Plug a real generate() clock in before you claim a remote win.
Agent vocabulary will keep shifting through this quarter. Planner, tool, memory, and hop are fresh labels. Disk proximity and wire delay are not labels.
Keep the workshop local until clocks and scans agree. Rent a mill for the clean, thin, slow cut. That is the whole local-first trade in practice.
Need rented mill time after a REMOTE_OK verdict. MonkeyCode is one option to try then. The three gates remain yours either way here.