FAQ: Five Myths About Promoting Code Off a Free Agent Box

Did the free box just become your origin?

I keep catching that assumption in review. A remote agent workspace is a draft. It is not a release channel.

This FAQ is about promotion, not prompting. You drafted on a cheap remote box. Fine. Then someone treats that box like CI. That is the bug.

What this FAQ is not

I already wrote about empty scratch hosts. I already wrote about chat logs versus git status. This one is narrower.

How do you move bytes from a free agent box into a real repo without lying?

Where a free box actually helps

I still use a throwaway remote shell for first drafts.

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

MonkeyCode offers free model access and a free server option. I treat both as a scratchpad with a network. I do not treat them as production. I do not treat them as CI.

The value is cheap iteration. The risk is a fake handoff. The rest of this post is the handoff.

The five myths

Each myth has a claim, a check, and a better mental model. None of these need a vendor benchmark. They need hashes, lockfiles, and a local command.

Myth 1: The transcript file is the whole file

Claim: "I copied the function from chat. Ship it."

Did the model truncate the tail? Did the UI fold imports? Chat is a viewport. It is not a filesystem.

Check I actually run:

# Label: proposed local check, not a production metric.
sha256sum src/billing/quote.py
wc -l src/billing/quote.py

On the remote box, write the same two numbers into a manifest. If either number drifts, you copied a window. You did not copy a file.

Corrected model: Promote paths, not bubbles. Hash the path. Then copy. Then hash again.

Myth 2: The free box runtime is your runtime

Claim: "It imported on the agent server. We are good."

Which Python? Which glibc? Which Node? A free server is one image. Your laptop is another. CI is a third.

I ask three questions before I trust a remote green run:

• What does python -V or node -v print there?
• What does it print here?
• What does CI pin in the workflow file?

# Label: collect facts. Do not invent a match.
python -V; which python
node -v 2>/dev/null || true
cat .python-version 2>/dev/null || true
cat .nvmrc 2>/dev/null || true

Corrected model: A remote interpreter is a guest. Guest success is a clue. It is not a contract.

Myth 3: A remote install gave you a trustworthy lockfile

Claim: "The agent ran install. The lockfile is current."

Did it? Or did it mutate package.json and skip the lock? Or rewrite poetry.lock with a different resolver?

Green install on a throwaway box is not a pin. I already beat that drum for local installs. The remote case is worse. You cannot see the resolver logs unless you kept them.

Check:

git diff --stat -- lockfile.txt poetry.lock \
  package-lock.json pnpm-lock.yaml Cargo.lock

If the lockfile is missing, stop. If it changed without a reason, stop. If the agent "helpfully" regenerated it, treat that as a new change. Review it like code.

Corrected model: The lockfile is the artifact. The install log is commentary.

Myth 4: Remote green means skip the local smoke

Claim: "Tests already passed on the box. Why rerun?"

Wrong machine. Wrong caches. Wrong secrets. Wrong working directory.

This is not the old "did the agent really run tests" question. Assume they ran. They still ran over there.

I want one boring command on my checkout. Not a full suite. A smoke that proves the files I copied are the files I think I copied.

# Label: example smoke only. Swap in your real target.
python -m compileall src/billing/quote.py
pytest -q tests/test_quote.py -k parse --maxfail=1

If that fails locally, the remote green build was a tourist photo. Nice lighting. Wrong city.

Corrected model: Remote tests answer "could this work." Local smoke answers "did this land."

Myth 5: A workspace link is a pull request

Claim: "I will just share the free server URL."

With whom? For how long? With which secrets still in the env?

A workspace link is not review. It has no diff. It has no CI. It has no CODEOWNERS. It often has your paste buffer.

Check before you paste a URL:

• Is .env in the tree?
• Did the agent echo tokens in a log?
• Can a stranger fetch the workspace?
• Do you even own the retention story?

I do not know your provider's retention. I refuse to guess. If you cannot answer retention, do not share the box. Open a PR from your repo instead.

Corrected model: Git is the handoff protocol. HTTP to a scratch VM is a demo.

Artifact: a promotion manifest

I use a tiny two-file protocol. No special platform. No claimed speedup.

File one lives on the remote box: promo.manifest. File two is this local checker. The checker is a proposal. Run it on a throwaway branch first.

Remote side, after the agent stops talking:

# Label: proposed remote snapshot.
# Run inside the project root on the free box.
{
  echo "# promo.manifest"
  echo "pwd $(pwd)"
  echo "head $(git rev-parse --short HEAD 2>/dev/null || echo nogit)"
  echo "python $(python -V 2>&1)"
  echo "node $(node -v 2>/dev/null || echo none)"
  git ls-files -o -m --exclude-standard | sort | while read -r f; do
    [ -f "$f" ] || continue
    printf '%s  %s\n' "$(sha256sum "$f" | awk '{print $1}')" "$f"
  done
} > promo.manifest
cat promo.manifest

Copy promo.manifest home with the files. Not through chat if the tree is large. Use scp, a bundle, or a patch.

# Label: proposed local verifier. Save as scripts/check_promo.sh
set -euo pipefail
manifest="${1:?usage: check_promo.sh promo.manifest}"
fail=0

while read -r hash path; do
  case "$hash" in
    \#*|pwd|head|python|node) continue ;;
  esac
  if [ ! -f "$path" ]; then
    echo "MISSING $path"
    fail=1
    continue
  fi
  got=$(sha256sum "$path" | awk '{print $1}')
  if [ "$got" != "$hash" ]; then
    echo "DRIFT $path"
    echo "  remote $hash"
    echo "  local  $got"
    fail=1
  fi
done < "$manifest"

if [ ! -f package-lock.json ] && [ ! -f pnpm-lock.yaml ] \
   && [ ! -f poetry.lock ] && [ ! -f Cargo.lock ]; then
  echo "WARN no lockfile in this snapshot"
fi

exit "$fail"

Then the smoke you already trust:

bash scripts/check_promo.sh ./promo.manifest
git status --short
# only then: your local smoke command

Decision table I keep next to the script:

• Hash match, lockfile unchanged, smoke green → open the PR from this repo.
• Hash match, lockfile changed → review the lockfile as its own diff.
• Hash drift → stop copying from chat. Recopy the path.
• Smoke red → the remote green build does not travel. Fix locally.
• No manifest → you do not have a promotion. You have a story.

Limitations

This protocol does not prove correctness. It proves the bytes moved. It does not pin a model. It does not pin a server image. It does not replace CI.

Hashes ignore file modes on some copies. Newlines can bite you. Windows versus Unix will lie. If you copy through Slack, you already lost.

Who should not use this?

• Anyone shipping secrets that already touched the free box.
• Anyone who needs a long-lived remote environment. I did not claim one.
• Anyone without a real git remote they control.
• Regulated work that forbids unknown hosted shells.

If MonkeyCode's free server is your draft box, export the manifest before you copy anything home. That is the whole ask.

The mental model I want stuck in your head

Ask four questions, in this order:

1. Which machine ran the command?
2. Which bytes am I about to commit?
3. Which lockfile travels with those bytes?
4. Which system will rerun the check besides me?

If you cannot answer all four, you are not promoting. You are hoping.

A free model can draft. A free server can compile. Your repo still has to receive the patch. CI still has to hate it in public.

That split is the job. Keep it.