FAQ: Five Myths About Free Models on Free Servers

Is a zero invoice the same thing as a working lab? I keep hearing developers talk like it is. They pair a free model with a free shell.

Then the chat looks finished, so process disappears. Nobody copies the hashes off that box. Nobody pins the interpreter for a replay.

This FAQ is about that pairing, not leaderboards. I am not ranking models in this post. I want evidence that survives after the session ends.

Why I wrote this as an FAQ

Last week stayed loud about agent vocabulary again. People explained terms and then argued about architecture. I still want a smaller question answered first.

What evidence still exists when the session closes? A confident summary is not a file on disk. A green-looking command is not a pipeline.

I use a free model on a free server for scratch work. Disclosure: This article was prepared as part of MonkeyCode's product outreach. MonkeyCode offers free model access and a free server option.

I treat that pair as a scratch pad only. I do not treat it as a lease or a quota. I also do not treat it as a hardware spec sheet. Those plan details change, so I will not invent them here.

How I test each myth

I keep three columns for every repeated claim. They are claim, check, and corrected mental model. If I cannot run the check, I drop the claim.

No vendor scoreboard lives in this post. I am not publishing fake latency numbers either.

The helper script sits at the bottom of this post. Run it on the box, then copy the receipt out. If the copy fails, the run did not count.

Myth 1: Free means I can skip ops

The claim developers repeat

It costs nothing, so the process is optional. People say this when the model is free. They repeat it when the server is free too.

The check

I ask three boring questions every time.

• Did I save the command exit code in a receipt?
• Did a file hash actually change on disk?
• Did I copy that hash onto a machine I control?

If any answer is no, I do not have ops. I only have a confident vibe from the chat.

echo "exit=$?"
git status --porcelain
git rev-parse HEAD
sha256sum ./out/app.py || true

Did the model thank itself in prose? That is not a check. Show me the hash and the exit code.

The corrected mental model

Price is not a process for agent work. A zero invoice still needs boring receipts. Treat free compute like a whiteboard you can wipe.

Myth 2: The model and the box share memory

The claim developers repeat

The agent has a shell, so it knows the machine. That sentence hides two clocks that drift. Token context is not filesystem state.

The check

I never ask the model what sits on disk. I ask the disk, then I keep the output.

pwd
ls -la
test -f ./out/app.py && echo "present" || echo "missing"
stat ./out/app.py
git diff --stat

Did the model claim a file exists? Prove it with test -f. Did it claim a patch landed cleanly? Prove it with git diff --stat.

The corrected mental model

A context window is not stat(2). A tool call is not persistence either. The model can narrate, but only the kernel records.

Myth 3: Exit zero means the artifact is mine

The claim developers repeat

The command succeeded, so we are done here. Succeeded where, and for how long? On which dirty working directory?

Free servers get recycled without a ceremony. Working trees collect other people's node_modules. Exit zero is an event, not a deed.

The check

I write a receipt file, not a feeling. Then I move that file off the box.

mkdir -p "$HOME/receipts"
stamp=$(date -u +%Y%m%dT%H%M%SZ)
cmd='python3 -m compileall ./out'
set +e
eval "$cmd"
code=$?
set -e
{
  echo "stamp=$stamp"
  echo "host=$(hostname)"
  echo "pwd=$(pwd)"
  echo "cmd=$cmd"
  echo "exit=$code"
  echo "head=$(git rev-parse HEAD 2>/dev/null || echo none)"
  sha256sum ./out/* 2>/dev/null || true
} > "$HOME/receipts/$stamp.txt"
cat "$HOME/receipts/$stamp.txt"

Copy that receipt to a laptop you control. Object storage you control also works. The loaned shell is not the archive.

The corrected mental model

Exit codes are events. Artifacts are objects you can hash. You own the object only after a trusted machine holds that hash.

Myth 4: A sandbox is a safe place for secrets

The claim developers repeat

It is just a playground, so drop the token in .env. I hear this on free boxes all the time. Scratch pads are not vaults.

I do not know who else had that disk. I do not know snapshots or reuse. I do not need that mystery near a key.

The check

Before any agent run, I scan the tree. I fail the run if a secret shows up.

git status --porcelain
grep -RInE 'API_KEY|BEGIN OPENSSH|aws_secret|TOKEN=' --exclude-dir=.git . || true
find . -name '.env' -o -name '*.pem' -o -name 'id_rsa'

If I need a secret, I keep it local. I inject the smallest value at run time. I never ask the model to echo it back.

Did the agent offer to save credentials for later? That is a fail. Delete the tree and start again.

The corrected mental model

Scratch pads are hostile, like a cafe laptop. No customer data. No production tokens. No private keys on the loaned disk.

Myth 5: If it ran on the free box, CI will love it

The claim developers repeat

Green on the sandbox means green in the pipeline. The sandbox PATH is a rumor. System Python is not your Python.

Package indexes move under your feet. Unpinned tools drift between two runs. One lucky shell is not a runner definition.

The check

I pin what I can see. Then I replay one command twice, without the chat.

python3 --version
command -v python3
pip freeze > /tmp/freeze.txt
wc -l /tmp/freeze.txt
sha256sum /tmp/freeze.txt

Replay on a clean venv:

python3 -m venv .venv
. .venv/bin/activate
pip install -r requirements.txt
python3 -m pytest -q
echo "pytest_exit=$?"

If I cannot name the interpreter, I distrust the green. If I cannot replay without the model, I distrust the green.

The corrected mental model

A free box is a canary perch, not the pipeline. CI still needs pins, caches, and a runner you define.

The artifact: receipts.sh

This is a proposed local helper. It is not a product feature. It is not a benchmark.

#!/usr/bin/env bash
# receipts.sh — proposed helper. Label: unexecuted until you run it.
set -u
stamp=$(date -u +%Y%m%dT%H%M%SZ)
out="${RECEIPT_DIR:-./receipts}/$stamp"
mkdir -p "$out"

{
  echo "# receipt $stamp"
  echo
  echo "## identity"
  echo "- hostname: $(hostname)"
  echo "- pwd: $(pwd)"
  echo "- user: $(id -un)"
  echo
  echo "## git"
  echo "- head: $(git rev-parse HEAD 2>/dev/null || echo none)"
  echo "- branch: $(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo none)"
  echo "- porcelain:"
  git status --porcelain 2>/dev/null || echo "not a repo"
  echo
  echo "## interpreter"
  echo "- python: $(command -v python3 || echo missing)"
  python3 --version 2>/dev/null || true
} > "$out/RECEIPT.md"

if [ "$#" -gt 0 ]; then
  set +e
  "$@"
  code=$?
  set -e
  echo "- command: $*" >> "$out/RECEIPT.md"
  echo "- exit: $code" >> "$out/RECEIPT.md"
else
  code=0
  echo "- command: none" >> "$out/RECEIPT.md"
fi

if [ -d ./out ]; then
  sha256sum ./out/* > "$out/hashes.txt" 2>/dev/null || true
  echo >> "$out/RECEIPT.md"
  echo "## hashes" >> "$out/RECEIPT.md"
  cat "$out/hashes.txt" >> "$out/RECEIPT.md"
fi

echo "wrote $out/RECEIPT.md"
exit "$code"

Commands I actually type after the agent stops talking:

chmod +x receipts.sh
./receipts.sh python3 -m pytest -q
scp -r ./receipts "$HOME/safe-receipts/"

Did scp fail halfway? Then you do not have a receipt. Retry the copy. Do not trust the chat log.

Decision table

Print this. Tick boxes. Argue with ticks, not vibes.

Claim you hear	Cheap check	Pass only if	Still a myth if
Free means skip ops	receipt file exists off-box	hash, exit, and git head copied	the chat said done
Model knows the disk	test -f and stat	kernel output matches the claim	the summary sounds right
Exit zero owns the file	sha256sum then scp	local hash equals remote hash	the compile finished
Sandbox can hold secrets	grep for tokens	no matches and no .env	it is just a test key
Sandbox green equals CI	pin plus venv replay	replay passes without the model	one lucky PATH

Which row do you fail most often? For me it is the copy step. People stop at exit zero.

What this workflow does not prove

This workflow does not measure model quality. It does not prove uptime. It does not freeze a free plan in time.

I am not listing model names in this FAQ. I am not listing quotas or CPU counts. I cannot see those from a blog post, and I will not invent them.

The script does not sign artifacts. It does not replace SLSA attestations. It does not replace a real CI runner you define.

Network can fail in the middle of a copy. Then you hold a remote hash and no local file. That is a failed receipt, not a partial win.

Who should not use this pairing

Do not use a free model plus a free server for regulated data. Do not park customer exports on that disk. Do not pretend the box is production CI.

Do not use it if you need a signed environment. Do not use it if other tenants are in your threat model. Do not use it if you cannot copy files off the box.

If you want a second laptop, buy a second laptop. This pairing is a scratch pad. The FAQ will not stretch it into a lease.

The loop I actually run

1. State the change in one boring sentence.
2. Let the agent work on the free scratch pair.
3. Ignore the victory text in the transcript.
4. Run receipts.sh against the real command.
5. Copy receipts/ onto a machine I control.
6. Replay once locally, or inside CI I define.

Did step five happen? If not, I do not have a result. I have a story the model liked.

Closing

Is the stack free? Sometimes the invoice really is zero. Is the work free of evidence work? Never.

Keep the myths on a list you can tick. Keep the hashes on a disk you own.