A Free Token Does Not Buy a Blind Retry

A free retry is still a decision you own.
Cheap tokens do not erase a repeated mistake.
You need a stop rule before the first call.

The claim you can test

Do not retry an agent only because the call is free.
A free allowance changes the bill, not the evidence.
Evidence is the only reason a second call exists.

This piece argues from failure classes, not from scores.
It does not rank models, vendors, or hosted runners.
You can reject the opinion after you count your own logs.

Why retry talk is the wrong comfort

Public posts this week keep circling retries and swaps.
Treat those titles as untrusted signals, not as facts.
No headline here is used as a measurement.

Better inference does not dissolve a local lock.
Missing files and wrong paths stay on your machine.
A remote model cannot invent a file you never sent.

What free access tempts you to skip

A paid meter used to force a short pause.
You read the error before you spent again.
A free pool removes that pause unless you rebuild it.

That pause was doing classification work for you.
It made you name the failure in plain words.
Without a name, you resend the same prompt again.

Excuses that should not spend a call

Reject a retry that rests on these excuses.
Write the excuse down, then throw the call away.

• The last reply looked almost right to you.
• The log was long, so another summary feels due.
• The allowance is large, so waste feels harmless.

Each excuse avoids naming even one new fact.
A retry without a new fact is noise.
Noise gets cheaper when the meter reads zero.

Classify the failure before the network

Read the failure on your own machine first.
Put it in one class from the table.
Only then decide whether the network is owed.

Rows you can apply today

Class	What you saw	Retry	Why
Local lock	Dependency or file lock	No	Another call will not release it
Missing input	Empty diff or absent file	No	Fix the fixture, then call once
Tool mismatch	Command is not on PATH	No	Repair the host before any rephrase
Flaky check	Local rerun already passed	Once	Record the flake and cap it
Wrong file	Edit landed outside the brief	No	Narrow the path list first
New compiler fact	Fresh error after a real edit	Yes	The error text is new evidence

Copy this table as a starting proposal only.
It is not a recorded result from production traffic.
Change every row until it matches your repo.

Keep a referee next to the table

Keep the referee on the machine you trust.
Keep the classifier in code you can diff.
The script below is an unexecuted local example.

#!/usr/bin/env python3
"""Local retry referee. Proposal only. Not a recorded run."""

from dataclasses import dataclass

STOP = "stop"
ONCE = "once"
ALLOW = "allow"

@dataclass(frozen=True)
class Verdict:
    action: str
    reason: str

def classify(kind: str, evidence_changed: bool, attempts: int) -> Verdict:
    local = {"lock", "missing_input", "tool_mismatch", "wrong_file"}
    if kind in local:
        return Verdict(STOP, "local fact is unchanged")
    if kind == "flake" and attempts < 1:
        return Verdict(ONCE, "one local rerun, then stop")
    if kind == "new_compiler_fact" and evidence_changed and attempts < 2:
        return Verdict(ALLOW, "new error text justifies one more call")
    return Verdict(STOP, "no new evidence or cap reached")

if __name__ == "__main__":
    samples = [
        ("lock", False, 0),
        ("missing_input", False, 0),
        ("flake", False, 0),
        ("flake", False, 1),
        ("new_compiler_fact", True, 0),
        ("new_compiler_fact", True, 2),
        ("wrong_file", True, 0),
        ("unknown", True, 0),
    ]
    for kind, changed, attempts in samples:
        verdict = classify(kind, changed, attempts)
        print(f"{kind} changed={changed} attempts={attempts} -> {verdict.action}: {verdict.reason}")

Save the file as retry_referee.py beside your repo.
Run the samples before you trust the gate.

python3 retry_referee.py

What those samples should show

Expect stop on locks, missing files, and wrong paths.
Expect one local chance when the class is flake.
Expect allow only when compiler text actually changed.

If the kind is unknown, the referee must stop.
An unknown kind is not a prompt to invent a class.
You add a row, then you run the samples again.

Put the referee in front of the call

Wrap the referee in a thin shell gate.
The gate reads a class you already wrote down.
It refuses the network when the verdict is stop.

#!/usr/bin/env bash
set -euo pipefail

kind="${1:-unknown}"
changed="${2:-false}"
attempts="${3:-0}"

action="$(python3 -c '
import sys
from retry_referee import classify
kind, changed, attempts = sys.argv[1:]
verdict = classify(kind, changed == "true", int(attempts))
print(verdict.action)
' "$kind" "$changed" "$attempts")"

if [[ "$action" != "allow" && "$action" != "once" ]]; then
  echo "refused: ${kind} has no new evidence"
  exit 2
fi

echo "permitted: ${action} for ${kind}"
# Place one real model call below this line.
# Do not hide a retry loop inside the client.

Save that file as retry_gate.sh next to the referee.
Try the gate with a lock before you try a model.

bash retry_gate.sh lock false 0
bash retry_gate.sh new_compiler_fact true 0

Run both commands from the directory that holds the scripts.
The first command should exit with status two.
The second should print a permit and then wait.

This gate is a sketch, not a finished product.
Label it unexecuted until it runs on your tree.
A printed permit is not a passing integration test.

Spend free access only after allow

Disclosure: This article was prepared as part of MonkeyCode's product outreach.

MonkeyCode is an open-source project for coding agents.
The outreach brief states free model access for readers.
It also states a free server option you can try.

The outreach brief states a free allowance of ten million tokens.
Confirm the live figure in the current project docs.
Do not budget a quarter from a copied number.

Free access can change without this article updating.
Model names, hardware, and duration are not assumed.
Permanence is not a feature you should plan on.

Use the free model only after the referee allows it.
Use the free server to host the agent loop.
Do not skip local classification because the host is free.

A practical order keeps the pool for new evidence.
Write the class down before you open a remote session.

1. Classify the failure on your own machine first.
2. Refuse the call when the class is local.
3. Send one bounded prompt only when evidence changed.
4. Re-run the same local checks after the patch.
5. Stop at two remote attempts even if tokens remain.

Two remote attempts is a hard cap in this opinion.
Leftover tokens are not an argument for a third call.
Stop even when the allowance still looks large.

Shrink the prompt the referee allows

When the referee allows a call, shrink the prompt.
Send the new error, the paths, and the last diff.
Do not resend the repository because the call is free.

Failure class: new_compiler_fact
Attempts so far: 1
Changed evidence: yes
Touched paths:
- src/retry_gate.py
New compiler text:
- src/retry_gate.py:40: NameError: verdict
Constraint:
- Edit only the touched paths.
- Do not add a retry loop.
- Stop after one patch.

If you cannot point at a new line, do not send it.
Abundance is not the same thing as context.
Context means the fact that changed since last time.

The opinion, without a hedge

Cheap inference rewards impatience more than careful work.
You should grow stricter as the meter disappears.
The stop rule matters most when retries feel free.

A free server does not outrank your worktree.
A large token pool does not outrank a missing file.
Another paraphrase does not outrank a held lock.

If you disagree, sample five failures from last week.
Count how many retries carried no new evidence.
Let that count accept or reject this opinion.

Limits that stay attached to the rule

This workflow does not measure model quality at all.
It does not compare hosts, prices, or latency.
It does not prove a free tier will remain available.

The script knows only the classes you pass in.
A wrong class produces a confident wrong stop.
You still have to read the log yourself.

Network flakes and partial writes need their own rows.
Add those rows before a shared branch uses the gate.
Never paste secrets or customer logs into the sample.

This draft was not executed against a live hosted agent.
Treat every command here as a local proposal.
Verify install steps and terms in the project docs.

A free server still needs your auth and your retention rules.
This draft does not describe those controls for you.
Read them before any source leaves your laptop.

Who should leave this workflow alone

Skip this when the edit is a typo you already see.
A referee is wasted on a fix you can type.
Human eyes are enough for that narrow case.

Skip this if you will not maintain the class list.
An abandoned table becomes theater within a week.
An unused table will not protect a shared branch.

Skip this if policy forbids a third-party agent server.
A free option is still a remote service.
Read the terms before you send repository source.

Skip this if you need audited numbers for a decision.
This article offers a rule, not a study.
Do not cite it as a performance result.

One check before you try the pool

Label five recent failures with the table above.
Run the referee against those labels before any call.
Call a free model only if the verdict is allow.

If current project terms still match the brief, use them.
If they do not, keep the referee and skip the host.
The stop rule stays on your machine either way.