Let a Local Clock Gate the Free Server

A free server should stay idle while the desk still hits budget. Local latency, secret residue, and an offline drill pick the winner. The remote box is a spare lane, not the home road.

Teams often rent a distant model because the sticker price is zero. That choice still spends time, trust, and a working network. A cheap lane can be the slow lane when the loop is tight.

Treat the laptop as a nearby kitchen clock. Treat the free server as a street courier. The courier wins only after the clock misses the meal.

This draft proposes a gate, not a product score. Figures below are planning targets, not measured vendor claims. Run them on your host before you trust a line.

Budget the desk first

Set two budgets before you send any prompt. An assist hop should return in under 400 milliseconds. A batch review may spend up to eight seconds.

Those ceilings are proposals for a solo repo workflow. Change them when your editor or hardware differs. Do not paste them into a contract or status page.

Assist work sits near the hands, so delay feels like friction. Batch work sits near the calendar, so delay feels like a queue. The same remote hop can pass one budget and fail the other.

Measure the desk with a short sample, not a single lucky call. Seven local runs can sketch a median and a rough tail. With seven runs, that tail is simply the slowest sample.

Four facts, one choice

The gate reads four facts and prints one choice. It samples a local stand-in and scans secret shapes. It also checks a drill marker and a network flag.

Stay local when the local p95 fits the budget. Stay local when the offline drill was never recorded. Block the send when a key-like pattern remains.

Open the spare lane only when the miss is real. Local p95 must sit past budget, and the drill file must exist. The wire must be up, and the secret scan must be clean.

The local stand-in sleeps briefly, then copies the string. It stands in for an on-disk model, linter, or cache. Replace that function before you trust the printed choice.

A fifty millisecond sleep is a fixture, not a hardware result. Your real model may take longer on a cold start. Warm the process once, then time the calls you would ship.

The secret scan is a rough net, not a proof. It flags common key labels and a private-key banner. It misses novel formats, split tokens, and image text.

Treat a clean scan as a permit to continue the clock check. Treat a hit as a stop, even if the clock is slow. Edit the payload, write a new file, and sample again.

The offline marker is a file you write after a real unplug. Cut the route, run the local path, and confirm a result. Only then create the marker file on disk.

A missing marker means the courier is not yet earned. The script will not guess that the laptop works alone. That refusal is the point of the drill.

Airplane mode is a fair cut for a cafe laptop. A lab bench may need a disabled route instead. Record which cut you used beside the marker file.

Save the following harness as gate.py in an empty directory. It was not run against a live remote host for this article. Treat every printed number as a sketch until you execute it.

#!/usr/bin/env python3
"""Proposed local-clock gate. Unexecuted example, not a benchmark."""
import argparse
import json
import re
import statistics
import time
from pathlib import Path

SECRET = re.compile(
    r"(?i)(api[_-]?key|token|password|BEGIN PRIVATE KEY)"
)
BUDGET_MS = {"assist": 400, "batch": 8000}


def local_stub(payload: str) -> str:
    time.sleep(0.05)
    return payload.upper()


def sample_local(payload: str, runs: int = 7) -> dict:
    samples = []
    for _ in range(runs):
        start = time.perf_counter()
        local_stub(payload)
        samples.append((time.perf_counter() - start) * 1000)
    samples.sort()
    index = max(0, int(round(0.95 * len(samples))) - 1)
    return {
        "p50_ms": round(statistics.median(samples), 1),
        "p95_ms": round(samples[index], 1),
        "n": runs,
    }


def decide(kind: str, payload: str, marker: Path, net_up: bool) -> dict:
    clock = sample_local(payload)
    hits = len(SECRET.findall(payload))
    meets = clock["p95_ms"] <= BUDGET_MS[kind]
    drilled = marker.is_file()
    if hits:
        choice, why = "blocked", "secret pattern remains"
    elif not drilled:
        choice, why = "stay_local", "offline drill missing"
    elif meets:
        choice, why = "stay_local", "local p95 inside budget"
    elif net_up:
        choice, why = "free_server", "budget missed and wire up"
    else:
        choice, why = "stay_local", "budget missed but wire down"
    return {"choice": choice, "why": why, "hits": hits, **clock}


def test_block_and_local() -> None:
    blocked = decide("batch", "api_key=example", Path("missing"), True)
    assert blocked["choice"] == "blocked"
    local = decide("batch", "lint the queue", Path("missing"), True)
    assert local["choice"] == "stay_local"


def main() -> None:
    parser = argparse.ArgumentParser(description="Proposed local-clock gate")
    parser.add_argument("--kind", choices=sorted(BUDGET_MS), required=True)
    parser.add_argument("--payload-file", type=Path, required=True)
    parser.add_argument("--marker", type=Path, default=Path(".offline_drill_passed"))
    parser.add_argument("--net-up", type=int, choices=(0, 1), required=True)
    args = parser.parse_args()
    payload = args.payload_file.read_text(encoding="utf-8")
    report = decide(args.kind, payload, args.marker, bool(args.net_up))
    print(json.dumps(report, sort_keys=True))


if __name__ == "__main__":
    main()

Run the sketch from a clean directory you can delete. Pass a payload file that you are willing to inspect. Keep customer text and live environment files out of the trial.

python3 -c "import gate; gate.test_block_and_local()"
printf 'lint the queue module\n' > ./sample.txt
python3 gate.py --kind assist --payload-file ./sample.txt --net-up 1
python3 gate.py --kind batch --payload-file ./sample.txt --net-up 0
printf 'review this api_key=example\n' > ./sample.txt
python3 gate.py --kind batch --payload-file ./sample.txt --net-up 1

The first live command should stay local, because the marker is absent. The key-label file should print blocked, even when the wire flag is up. A fast stub will not open the lane, and that is intended.

The default stub sleeps for about fifty milliseconds, so it beats both budgets. To inspect the free_server branch, set the assist budget to ten. Restore the real budget before you judge a live payload.

Create the marker only after that cut succeeds. Do not copy a touch command in place of the drill. The filename is .offline_drill_passed, and it is only a note.

Read the JSON choice before you change any client setting. A stay_local line means the desk still earns the loop. A blocked line means you edit the payload and sample again.

A free_server line means the spare lane is eligible, not mandatory. You may still keep the work on disk if quality is unsure. Eligibility is a clock result, not an order to migrate.

Read the matrix, then the wire

The same rule fits in a small review table. Use the row that matches your sample, not the row you prefer. A printed choice should agree with that row before you continue.

Local p95	Drill file	Secret hits	Network	Choice
Inside budget	Present	0	Either	stay_local
Outside budget	Missing	0	Up	stay_local
Outside budget	Present	Greater than 0	Up	blocked
Outside budget	Present	0	Down	stay_local
Outside budget	Present	0	Up	free_server

Latency is only one axis on that table. A fast local hop can still be unsafe if a token remains. A slow remote hop can still fit a nightly batch.

Offline work changes the math without a code change. Trains, flights, and lab benches drop the courier without warning. If the drill never passed, you do not know the clock works.

Secrets change the math faster than latency does. A zero invoice does not make a distant hop safe. Redact first, then ask whether the clock missed budget.

Disclosure: This article was prepared as part of MonkeyCode's product outreach. The operator reports free model access and a free server option. Quota size, model names, hardware, and duration were not verified here.

Use that reported lane only when the gate prints free_server. Point a batch client there after redaction, not before the scan. Keep the assist hop on the desk unless its own budget fails.

Do not read a free option as a latency promise. A shared queue can wait behind jobs you cannot see. Sample the remote round trip, then compare it with the local tail.

A fair remote sample uses the payload the gate already cleared. Send one warm call, then five timed calls, and keep the median. Drop the run if any call returns an auth error.

The next loop is a shape, not a private client. Set the URL yourself, and do not place secrets in the file. Replace headers if your existing client already requires them.

# Proposed timing shape. Set FREE_SERVER_URL yourself.
: > /tmp/gate_times.txt
for i in 1 2 3 4 5; do
  curl -sS -o /tmp/gate_body.txt -w "%{time_total}\n" \
    -H "Content-Type: application/json" \
    --data-binary @cleared_payload.json \
    "$FREE_SERVER_URL" >> /tmp/gate_times.txt
done
python3 - <<'PY'
import statistics
from pathlib import Path
vals = [float(x) * 1000 for x in Path("/tmp/gate_times.txt").read_text().split()]
print({"n": len(vals), "median_ms": round(statistics.median(vals), 1)})
PY

Compare that remote median with the local p95, not a slide. If the remote tail is slower than the batch ceiling, stay local. A free box that misses budget is still a miss.

Record both clocks in one line so the comparison stays honest. Include the job kind, the choice, and whether the wire was up. A later reader should not reconstruct the afternoon from memory.

printf '%s %s %s\n' "$(date -u +%FT%TZ)" "$CHOICE" "$P95" >> .gate_log

After a week of samples

Review that log after a week of real edits. If free_server never appears, you do not need the spare lane yet. If it appears on assist hops, the budget or the desk is tight.

Raise the assist budget before near-hand help leaves the machine. Lower the batch budget if the courier often returns late. Edit the script table, then rerun the same payload file.

This method will not rank which model writes a better patch. It will not score prose, taste, or review comments. It only tells you when a free server earned a timed turn.

A small on-disk model can meet the clock and still miss. Pair the gate with a diff check or a unit run you trust. A fast stub is not evidence that the patch is right.

Free capacity can also vanish without a local code change. A refused remote call should fall back to the local stub. Log the fallback reason next to the same clock sample.

def fallback(choice: str, remote_ok: bool) -> str:
    if choice != "free_server" or not remote_ok:
        return "local_stub"
    return "free_server"

Air-gapped repos should never open the spare lane. Regulated text that cannot cross a boundary should stay on disk. A slow local clock is not a permit to break that rule.

Skip the lane when you need a paid support contract. Skip it when prompts still contain raw environment dumps. Skip it when the unplug drill cannot run on the real laptop.

The gate fails in a dull way if you fake the marker. Creating the file without cutting the route is theater, not evidence. The drill is the proof, and the file is only a note.

Cold starts also fool a short sample on a local model. The first call may load weights while later calls look fast. Drop the first sample, or report it apart from the timed set.

Set the network flag from a check you already trust. A failed name lookup is enough to force a local choice. Do not hard-code a vendor address into the first version.

Start with the local clock on a payload you can publish. Record the offline drill before you celebrate a zero price. Open the spare lane only when the printed choice allows it.

When a cleared batch prints that choice, sample the reported lane once. Keep the path that meets budget on the next five calls. The kitchen clock still owns the meal when the street is optional.