Run Free AI Tiers Through a Provenance Gate

A free model tier is safe for bounded work. It is dangerous for unattributed work.

That distinction decides whether a team ships faster. Every free endpoint removes the invoice, and the invoice was the thing that made someone watch the clock.

The recent DEV debates about AI fatigue and shrinking software quality share one root cause. The tools improved faster than the paper trail did. A service can now hold a stated free allowance, a free server option, and no memory of what it generated last Tuesday.

This playbook fixes the memory problem. MonkeyCode appears here because its operator describes free model access and a free server option, plus a stated free allowance of 10 million tokens. Treat those as operator-supplied availability claims. They are not independently benchmarked here, and quotas change without notice.

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

The failure is memory, not money

A free tier fails in three quiet ways. The quota runs dry mid-afternoon. The model behind a name changes under you. A shared server naps between requests and returns a cold start.

None of those break CI. They break the story you need six weeks later.

So the rule is simple: no artifact enters a shared branch without a provenance line. The line costs eight seconds. The investigation it prevents costs an afternoon.

Four roles, three handoffs

A small team needs four names. One person requests the change. One runs the model. One verifies the result by hand. One owns the tier and the budget of attention around it.

Call them Requestor, Runner, Verifier, Steward. One engineer can hold two roles on a quiet day. The Verifier must never be the Runner.

Handoff one: Requestor writes the intent in plain text. Handoff two: Runner returns a diff plus a provenance block. Handoff three: Verifier reproduces one behavior without the model, then approves.

The Steward resolves conflicts. When two people drain the shared allowance in one morning, the Steward decides who keeps the free tier and who waits.

The tier gate

Not every change deserves the same scrutiny. Route work through a table before anyone opens an editor.

Change type	Free tier	Gate before merge
Docs, comments, typos	yes	CI only
Test scaffolding, fixtures	yes	Verifier runs the suite once
Refactor inside one module	yes	Diff read line by line
Auth, payments, migrations	no	Human author, standard review
Production data paths	no	Separate threat review

The table is the whole policy. Everything below is bookkeeping.

Stamp every diff

Add one script to the repository. It appends a machine-readable block to the pull request body after the last push.

#!/usr/bin/env bash
# scripts/ai_stamp.sh <pr-number>
# Appends an [ai-provenance] block to the PR body. Run after the final push.
set -euo pipefail

PR="${1:?usage: ai_stamp.sh <pr-number>}"
: "${ENDPOINT_HOST:?set ENDPOINT_HOST}"
: "${MODEL_ID:?set MODEL_ID}"
: "${RUNNER:?set RUNNER}"
: "${VERIFIER:?set VERIFIER}"

DIFF_SHA="$(git diff origin/main...HEAD | sha256sum | cut -c1-16)"
PROMPT_SHA="$(printf '%s' "${PROMPT_TEXT:-}" | sha256sum | cut -c1-16)"

printf '%s\n' \
  '[ai-provenance]' \
  'tier: free' \
  "endpoint: ${ENDPOINT_HOST}" \
  "model: ${MODEL_ID}" \
  "diff: sha256:${DIFF_SHA}" \
  "prompt: sha256:${PROMPT_SHA}" \
  "runner: ${RUNNER}" \
  "verified-by: ${VERIFIER}" \
  "verified-when: $(date -u +%Y-%m-%dT%H:%MZ)" \
  | gh pr comment "$PR" --body-file -

Run it with the environment exported first.

export ENDPOINT_HOST='free-endpoint.example'
export MODEL_ID='whatever-the-server-reports'
export RUNNER='@you' VERIFIER='@peer'
export PROMPT_TEXT='summarize the failing test and propose a fixture'
bash scripts/ai_stamp.sh 412

A diff hash plus a prompt hash gives you a replay anchor. When the model under that name changes, the old blocks still point at the old behavior.

Probe before you trust

Free servers sleep. Prove the endpoint is awake and consistent before a work block starts. The script below is a proposal, not a run I performed.

#!/usr/bin/env bash
# scripts/probe.sh — smoke test a free-tier endpoint. Proposal, not executed here.
# macOS note: date +%3N is GNU-only; use gdate or perl for milliseconds.
set -euo pipefail
: "${BASE_URL:?set BASE_URL}"

BODY='{"model":"'"${MODEL_ID:-server-default}"'","messages":[{"role":"user","content":"reply with the single word ok"}]}'

for i in 1 2 3; do
  start=$(date +%s%3N)
  code=$(curl -sS -o /tmp/probe.json -w '%{http_code}' \
    -H 'content-type: application/json' -d "$BODY" \
    "$BASE_URL/v1/chat/completions")
  end=$(date +%s%3N)
  printf 'attempt=%s http=%s ms=%s\n' "$i" "$code" "$((end - start))"
done

grep -q 'ok' /tmp/probe.json && echo 'content ok' || echo 'CONTENT DRIFT'

Three attempts expose cold starts. A content mismatch on the last line means the name you call is not the model you tested.

A one-page runbook for the wiki

Paste this block into the team wiki. Edit the names, keep the shape.

# Free-tier AI runbook (one page)

1. Requestor writes intent, test to satisfy, and the tier-gate row.
2. Steward confirms the row; auth, payments, and data paths stop here.
3. Runner probes the endpoint, then generates the diff.
4. Runner stamps the PR with ai_stamp.sh before review.
5. Verifier reproduces one behavior by hand and signs the block.
6. Steward logs daily allowance use and rotates waiters.
7. Anything unstamped is reverted, not debated.

Seven lines cover a workday. The Steward reviews the log each Friday and moves heavy work off the free tier.

Failure modes that survive week one

The allowance drains faster than expected when long contexts repeat. Cache the prompt text and cap the diff size before generation.

Model drift shows up as confident nonsense, not errors. The probe catches it only when the content check runs.

Cold starts masquerade as slow reasoning. Measure milliseconds before you measure quality.

Finally, a stamp without a human signature is decoration. The Verifier's name in the block is the load-bearing part.

Limits and who should skip this

Skip this if your work touches regulated data, secrets, or customer records. A free tier is not the place for that, and a stamp does not make it safe.

Skip it for air-gapped environments and for teams with no second reviewer. The gate collapses when one person holds every role.

Skip it for deep performance work. Benchmarks need controlled hardware, and a shared free server cannot provide that.

The method also assumes the endpoint is reachable and OpenAI-compatible. If your provider differs, rewrite the probe, keep the gate.

Try the runbook on one repository before you widen it. The stamp script is the part worth copying first.