FAQ: Five Myths About Green Builds on a Free Agent Host

Did that rented agent box actually prove your patch?

I keep hearing five claims in review threads. They sound careful, but they are not.

This FAQ treats a free coding host as scratch. You still owe local truth after export.

Why start with a rented box?

A model drafts a patch in chat. A remote shell then runs tests. The transcript prints pass, so someone merges.

Does that log replace your laptop? Does it replace CI?

Usually no. The host is a rental. Your checkout is the contract.

I use MonkeyCode here only as that rental. It offers free model access plus a free server option for throwaway runs.

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

The product is not the proof. The fingerprint is the proof.

The artifact: fingerprint, then export

Do not trust a green sentence in chat. Capture the host. Export a bundle. Replay at home.

Label this as a proposed workflow. I am not publishing secret timings or fake pass rates.

Step 1 — dump a host fingerprint

Run this on the remote shell first. Save stdout as remote-fingerprint.txt.

#!/usr/bin/env bash
# proposed checklist, not a vendor benchmark
set -euo pipefail
{
  echo "=== host ==="
  uname -a
  echo "USER=${USER:-}"
  id
  pwd
  echo "=== interpreters ==="
  command -v python3 && python3 -V || true
  command -v node && node -v || true
  command -v go && go version || true
  echo "=== vcs ==="
  command -v git && git --version || true
  git rev-parse --is-inside-work-tree 2>/dev/null || echo "not a git work tree"
  echo "=== time ==="
  date -u +%Y-%m-%dT%H:%M:%SZ
} | tee remote-fingerprint.txt

Copy that file off the box. Do it before you celebrate.

Step 2 — write a tiny local comparator

Keep this script in your repo. Run it after you pull the patch home.

#!/usr/bin/env python3
"""Proposed: compare two fingerprint dumps. Not executed against a vendor SLA."""
from pathlib import Path
import sys

KEYS = ("Linux", "Darwin", "python", "node", "go version", "git version")

def lines_of(path: Path) -> list[str]:
    return path.read_text(encoding="utf-8", errors="replace").splitlines()

def interesting(lines: list[str]) -> list[str]:
    out = []
    for line in lines:
        lower = line.lower()
        if any(k.lower() in lower for k in KEYS):
            out.append(line.strip())
    return out

def main() -> int:
    if len(sys.argv) != 3:
        print("usage: compare_fingerprints.py remote.txt local.txt")
        return 2
    remote = interesting(lines_of(Path(sys.argv[1])))
    local = interesting(lines_of(Path(sys.argv[2])))
    print("REMOTE"); [print(" ", x) for x in remote]
    print("LOCAL"); [print(" ", x) for x in local]
    if remote == local:
        print("MATCH: fingerprints agree on the coarse keys.")
        return 0
    print("DRIFT: do not treat remote green as local green.")
    return 1

if __name__ == "__main__":
    raise SystemExit(main())

A match is still coarse. A mismatch is a hard stop.

Step 3 — export a replay bundle

Green logs do not travel. Files do. Pack only what you can rebuild.

#!/usr/bin/env bash
# proposed export; review paths before you run it
set -euo pipefail
STAMP=$(date -u +%Y%m%dT%H%M%SZ)
OUT="replay-bundle-$STAMP.tgz"

git status --porcelain > /tmp/bundle-status.txt
git rev-parse HEAD > /tmp/bundle-head.txt 2>/dev/null || echo "NO_HEAD" > /tmp/bundle-head.txt

tar -czf "$OUT" \
  remote-fingerprint.txt \
  /tmp/bundle-status.txt \
  /tmp/bundle-head.txt \
  $(git ls-files -m -o --exclude-standard 2>/dev/null || true)

ls -lh "$OUT"
echo "Copy $OUT off the host. Replay from a clean clone."

If you cannot name the files, you cannot ship them. Chat is not an artifact store.

Decision table I actually want in review

Paste this into the PR. Fill the right column with commands, not vibes.

Claim in the agent log	What you must export	Local gate before merge
tests passed on the free host	fingerprint + command + cwd	same command from a clean clone
I installed a compiler	version string + package pin	pin exists in repo, not only in chat
I edited three files	git diff plus untracked list	git apply on an empty worktree
binary ran there	source + lockfile, not the binary	rebuild locally, then run
env looked fine	allowlisted env names only	replay with a stripped env

No row says "trust the screenshot." Every row says "replay."

Myth 1: Remote green equals local green

The claim: The free host passed, so your laptop will.

Why people repeat it: The command string looks identical.

Is the kernel identical? Is Python identical? Is cwd identical?

Run both fingerprint dumps. Then run the comparator.

Corrected model: Remote green is a hint. Local rebuild is the receipt.

Myth 2: The free disk is basically your laptop

The claim: Leave files there. Continue tomorrow.

Why people repeat it: The prompt still shows a path.

Paths lie. Ephemeral disks lie harder. A new session can be empty.

Write a sentinel, disconnect, reconnect, then ls that path.

echo "sentinel $(date -u +%s)" > /tmp/host-sentinel.txt
# later, in a new session
cat /tmp/host-sentinel.txt || echo "scratch disk forgot you"

Corrected model: Treat remote disk as ram. Export or it vanished.

Myth 3: The free host is a drop-in CI runner

The claim: Skip CI. The sandbox already ran the suite.

Why people repeat it: Both are Linux. Both print pytest.

CI has a pinned image. CI has an artifact store. CI has policy.

Does your free box pin the image? Does it keep artifacts after logout?

If you cannot answer, it is not CI.

Corrected model: Use the free host to fail fast. Keep CI as the merge gate.

Myth 4: Pasting the chat command is a replay

The claim: Copy the shell line. That is enough.

Why people repeat it: The line looks complete.

What was pwd? What was IFS? What did the previous step mutate?

Chat omits side effects. Chat omits umask. Chat omits leftover env.

Replay with an explicit working directory and a stripped environment.

env -i HOME="$HOME" PATH="/usr/bin:/bin" USER="$USER" \
  bash --noprofile --norc -lc 'cd /path/to/checkout && ./scripts/test.sh'

If it only passes in the dirty shell, it did not pass.

Corrected model: A replay is cwd plus env plus files. Not a quote.

Myth 5: Shipping the remote binary ships the truth

The claim: It compiled there, so ship that file.

Why people repeat it: Grabbing a binary feels faster than rebuilding.

Whose libc linked it? Which headers? Which CFLAGS?

You do not know. The fingerprint might tell you. The binary will not.

Export source, lockfiles, and the exact build command. Rebuild at home.

# proposed local rebuild after you unpack the bundle
git apply --check exported.patch
git apply exported.patch
python3 compare_fingerprints.py remote-fingerprint.txt local-fingerprint.txt
# then run YOUR build, not the copied ELF

Corrected model: The patch is the product. The remote ELF is debris.

A short review script for humans

I want reviewers to ask four questions. No fifth slogan.

1. Where is the fingerprint file?
2. Where is the export tarball or patch?
3. Did a clean clone replay the command?
4. Did CI still run on the exported tree?

If any answer is "the model said so," stop. Ask for files.

Limitations, said plainly

This checklist does not prove production behavior. It only kills lazy claims.

Coarse fingerprint keys miss glibc minors. They miss CPU flags. They miss locale.

The comparator can match and still hide a bug. A stripped env -i can hide a needed var.

Free hosts change under you. Do not pin a process to one anonymous box.

I am not claiming MonkeyCode quotas, model names, or hardware here. I only used the free model access and the free server option as a scratch lane for the checklist.

Want to try that lane yourself? Run the fingerprint first, then decide.

Who should not use this approach

Skip this if you already have pinned CI images. You already own the receipt.

Skip this if the change is a secret rotation. A free host is the wrong room.

Skip this if you cannot copy files off the box. Then you have no artifact.

Skip this if you need bit-identical builds today. You need a real reproducible pipeline.

Corrected mental model

A free agent host is a whiteboard with a shell. Useful. Temporary. Not the factory.

Green text is not a build artifact. A tarball is. A patch is. A CI job is.

Ask the five myths again on your next PR. Then demand the fingerprint.