Budget the Tool Loop Before a Hot Laptop Exports the Job

A night build on a developer laptop stalled after the third tool retry, and the chassis grew hot enough to throttle the editor. The agent held a clean task and a local repository, yet every model call waited behind a CPU that had already saturated. A teammate suggested moving the whole loop onto a free remote worker before the morning stand-up began. That shortcut can rescue a batch job, but only after the team measures the loop and keeps secrets on the laptop.

The scene above is a composite framing device, not a measured incident from this account or from any named customer. Local-first agent work fails in a familiar way when placement is treated as a hunch instead of a written budget. Interactive edits want short round trips and a machine that can sleep without abandoning files the user has not committed. Batch refactors, long logs, and repeated test runs want sustained throughput that a warm laptop may refuse to hold.

A free remote server can win the batch class of work, while interactive edits should remain beside the keyboard. The practical failure starts when fan noise convinces someone to upload a loop they have not measured on either seat. A hot laptop adds queue delay to every tool call, and that delay feels like a reason to leave the machine entirely. The upload can copy prompts, tool arguments, and uncommitted diffs into a place the local editor no longer watches.

Latency may improve while confidentiality and offline recovery get worse, which is a poor trade if nobody recorded the numbers. A placement budget forces that trade into a written record before any remote worker is allowed to see the fixture. The record stores local loop time, remote loop time, secret exposure, and how long the job can wait offline. It then selects a seat for one fixture, rather than declaring a permanent home for every repository on the team.

Disclosure: This article was prepared as part of MonkeyCode's product outreach. Free model access and a free server option are treated here as operator-supplied availability claims, not as measured product facts. This draft does not name a model, state a token quota, describe hardware, or promise that either offer will remain available. Anyone adopting the remote seat should re-read the project terms on the day of the run, because unpublished limits go stale quickly.

What to record on the fixture

A useful record uses the team clock on a disposable fixture, not a number copied from a launch announcement or a chat thread. Local loop time covers one tool call plus one model turn on the laptop, including any stall caused by thermal throttling. Remote loop time covers that same fixture, and queue delay stays in its own field so a slow link is not misread. Two further fields mark secret exposure and whether the developer can finish the task with the network cable pulled.

Those fields are enough to reject a fashionable default that sends every slow loop to whatever worker happens to be free. The local seat remains mandatory when a secret marker appears, when the work tree is dirty, or when the link is gone. A free server becomes reasonable only when the fixture is redacted, the job is batch-shaped, and the remote sample wins a prewritten margin. Neither seat expresses a preference about vendors, because both seats are answers to one measured fixture and nothing broader.

Decision table for a single job

The table below is a gate for a single job, and it should be read before any sample is uploaded or discarded. A zero price does not repair a secret leak, and a fast laptop does not finish a batch that has already stalled. The remote column is allowed only when every local blocker is absent and the timing margin was measured on this fixture. Teams that want a published score should measure their own run, because this article does not supply one.

Signal	Stay local	Consider a free remote worker
Secret or credential in the prompt or tool args	Required	Do not send the fixture
Uncommitted diff required for a correct answer	Keep that tree local	Send a redacted patch only
Network during the run	Optional	Required for the remote seat
Laptop throttling on a repeated clean fixture	Fine for short edits	Reasonable if the sample wins
Travel or a dead link	Local queue only	Defer until the path returns
Desire for a published score	Do not invent one	Measure the fixture yourself

Numbered workflow

The commands and the Python helper that follow are a proposal for a disposable fixture, and they were not executed for this draft. Thresholds inside the helper are placeholders that a team should replace after it sees its own editor latency. The samples should be collected on redacted inputs, then discarded if a later review finds a marker the script missed. Treat every printed seat as a suggestion until a human compares it with the dirty tree still sitting on the laptop.

1. Freeze a redacted fixture

Copy one failing tool loop into a fixture file that contains no tokens, no customer rows, and no proprietary uncommitted diff. Leave the original work tree on the laptop so a remote experiment cannot become the only copy of the change. The fixture should still be heavy enough to warm the CPU, or the later comparison will flatter whichever side stayed idle. A public unit-test failure is a reasonable stand-in when the real repository cannot leave the machine even in redacted form.

mkdir -p fixtures samples queue/offline
python3 - <<'PY'
import json
from pathlib import Path
fixture = {
    'task': 'retry a redacted unit test and summarize the failure',
    'repo': 'public-fixture',
    'secrets': [],
    'dirty_tree': False,
}
Path('fixtures/redacted_retry.json').write_text(json.dumps(fixture, indent=2))
PY

2. Time the local seat, then let the machine idle

Write a local skeleton while the editor and the agent share the CPU, then fill loop_ms from the operator clock. Record a second local sample after the machine has been idle long enough for the chassis to cool down. The hot sample explains why a teammate wants to leave the laptop, and it should not be hidden from the record. The idle sample stops that hot reading from becoming a permanent policy for every future edit in the repository.

python3 loop_budget.py sample --seat local --phase hot \
  --fixture fixtures/redacted_retry.json --out samples/local-hot.json
python3 loop_budget.py sample --seat local --phase idle \
  --fixture fixtures/redacted_retry.json --out samples/local-idle.json

3. Time the remote seat only after the redaction check

Send the same fixture to the free server option only after the marker check is clean and the offer is confirmed that day. The helper writes a skeleton and does not open a socket, so measured milliseconds must be pasted in by hand. Keep queue milliseconds in their own field so a congested path is not later described as a weak model. If the free server cannot be confirmed that day, skip the remote file and leave the job on the laptop.

python3 loop_budget.py sample --seat remote \
  --fixture fixtures/redacted_retry.json --out samples/remote.json

4. Score with an explicit refusal path

The helper refuses a remote seat when a secret marker is present, when the tree is dirty, or when the laptop is offline. It also refuses a remote seat when either file lacks loop_ms, because a null timestamp is not a successful sample. A gain below the team margin keeps the work local even if the remote call returned a plausible answer. Interactive edits stay local regardless of speed, since the user is still typing in a tree the server should not own.

#!/usr/bin/env python3
"""Proposal only: record and score one redacted tool loop. Not a live benchmark."""

import json
import sys
from pathlib import Path

MARKERS = ('api_key', 'BEGIN PRIVATE', 'password', 'token')

def blob_has_secret(text):
    return any(item in text for item in MARKERS)

def cmd_sample(seat, phase, fixture, out):
    raw = Path(fixture).read_text()
    if blob_has_secret(raw):
        raise SystemExit('refusing sample: secret marker in fixture')
    payload = json.loads(raw)
    record = {
        'seat': seat,
        'phase': phase,
        'offline': False,
        'dirty_tree': bool(payload.get('dirty_tree')),
        'interactive': False,
        'loop_ms': None,
        'queue_ms': None,
        'note': 'fill loop_ms after timing; null is not a win',
    }
    Path(out).write_text(json.dumps(record, indent=2) + '\n')
    print(out)

def cmd_decide(local_path, remote_path, max_remote_ms=4000, min_gain_ms=800):
    local = json.loads(Path(local_path).read_text())
    remote = json.loads(Path(remote_path).read_text())
    local_raw = Path(local_path).read_text()
    remote_raw = Path(remote_path).read_text()
    if blob_has_secret(local_raw) or blob_has_secret(remote_raw):
        seat, reason = 'local', 'secret marker present; do not upload'
    elif local.get('offline') or local.get('dirty_tree'):
        seat, reason = 'local', 'offline or uncommitted work stays local'
    elif local.get('loop_ms') is None or remote.get('loop_ms') is None:
        seat, reason = 'local', 'missing loop_ms is not a win'
    else:
        gain = local['loop_ms'] - remote['loop_ms']
        remote_ok = remote['loop_ms'] <= max_remote_ms and gain >= min_gain_ms
        if remote_ok and not local.get('interactive'):
            seat, reason = 'remote', 'clean batch fixture; remote loop wins the margin'
        else:
            seat, reason = 'local', 'gain too small, link too slow, or edit is interactive'
    print(json.dumps({'seat': seat, 'reason': reason}, indent=2))

def flag(args, name, default=None):
    if name not in args:
        if default is None:
            raise SystemExit('missing ' + name)
        return default
    return args[args.index(name) + 1]

def main():
    if len(sys.argv) < 2:
        raise SystemExit('usage: loop_budget.py sample|decide ...')
    cmd, args = sys.argv[1], sys.argv[2:]
    if cmd == 'sample':
        cmd_sample(flag(args, '--seat'), flag(args, '--phase', 'unspecified'),
                   flag(args, '--fixture'), flag(args, '--out'))
        return
    if cmd == 'decide':
        cmd_decide(args[0], args[1])
        return
    raise SystemExit('unknown command')

if __name__ == '__main__':
    main()

Sample files should follow one flat object so the scorer can fail closed when a required timing field is missing. Values shown beside this helper are placeholders, and copying them into a report would invent a benchmark this method forbids. A real sample replaces loop_ms only after the operator times that seat on the team machine. Queue time stays beside loop time so a later reader can see whether the link, not the model, dominated the wait.

{
  "loop_ms": null,
  "queue_ms": null,
  "offline": false,
  "dirty_tree": false,
  "interactive": false,
  "phase": "hot"
}

python3 loop_budget.py decide samples/local-hot.json samples/remote.json
python3 loop_budget.py decide samples/local-idle.json samples/remote.json

5. Park offline jobs instead of retrying a dead link

If the path drops, copy the redacted fixture into a local queue and leave the remote seat unused until the path returns. Resume only after a fresh remote sample succeeds on that same fixture, rather than replaying a stale timing file. This queue rule is a workflow suggestion for the operator, not a claim that any particular client already implements it. Offline time is a reason to wait, not a reason to weaken the secret check when the link finally recovers.

cp fixtures/redacted_retry.json "queue/offline/$(date -u +%Y%m%dT%H%M%SZ).json"

Reading the two scores without folklore

A hot local sample that loses by a wide margin supports a remote seat for that batch and for no other job. An idle local sample that already fits the editor budget cancels that support and saves the free server for a heavier fixture. When the two decisions disagree, the idle sample should govern interactive work and the hot sample should govern only the stalled batch. Writing both outcomes next to the fixture prevents a single fan spike from rewriting the placement policy for the week.

Teams should also name the failure they are willing to accept before they compare the two millisecond fields. A remote timeout on a clean fixture can be retried, while a secret upload cannot be retried back into safety. That asymmetry is why the helper checks markers before it subtracts timestamps, and why a faster number never outranks a dirty payload. If the team cannot explain that order to a new teammate, the remote seat is not ready for the queue.

Where a free server earns the seat

A free remote worker earns the seat on repeated redacted fixtures that make a laptop thermally noisy for minutes at a time. Long log summaries, broad reruns of a public test suite, and scaffold drafts from an already public repository fit that shape. Free model access helps in a narrower way, because a team can rehearse the remote sample without purchasing a seat first. That rehearsal is a method check, and it says nothing about output quality, context length, or how long the offer will last.

The same worker loses the seat when the prompt still holds a credential or when the answer depends on an uncommitted diff. It also loses the seat when the developer is offline and cannot accept a result that arrives after the link returns. An idle laptop that already meets the latency budget should keep the job, even if a remote call would finish a little sooner. Price is absent from the signal list on purpose, and a zero price must not return as a silent extra reason to upload.

Test plan before anyone trusts the branch

Before anyone trusts the helper, three local checks should pass on files that never leave the laptop. A fixture containing the marker token must return the local seat even when the remote loop time is tiny. A fixture marked dirty or offline must return the local seat even when the remote sample looks faster. A clean batch fixture should return the remote seat only when the gain meets the placeholder margin and loop time is present.

Run those checks with hand-written JSON files and do not point them at a live provider while the script is still a proposal. Replace the placeholder margin only after the idle laptop sample shows what the editor can already tolerate. Keep the failing fixtures in the repository so a later change to the marker list has something honest to break against. If a check requires uploading a secret to prove the refusal, the test is misdesigned and should be deleted.

Limitations and who should skip the method

This method is a poor fit for production incidents, regulated data, and any tree that cannot be redacted before the next standup. It is also a poor fit for teams that need a signed benchmark, because the helper was not executed for this draft. The numeric thresholds are placeholders, and publishing them as if they were measured results would mislead a later reader. Developers who already measure a private cluster should not migrate work only because a free server sends an empty invoice.

The marker list will miss secrets that use unfamiliar field names, encoded blobs, or values split across adjacent tool arguments. Human review of the fixture remains mandatory before any upload, and a green script is not a substitute for that review. Link loss, conflicting edits from another session, and drift in model output are separate failures that this budget does not close. Anyone who cannot accept those gaps should keep the entire loop on the laptop and skip the remote sample altogether.

Close the loop on one fixture

A team that already keeps interactive agent work beside the editor can still seek relief when a clean batch is cooking the chassis. The practical next step is to time one redacted fixture on both seats and keep the raw samples next to the script. Confirm the current free-model and free-server terms before that offline queue is allowed to grow past a single fixture. That reading takes less time than explaining how a credential left a machine that was only trying to cool down.