The Free Server Is Not Localhost: A Six-Myth FAQ

Is your free coding endpoint just localhost with extra steps? I hear that claim in almost every agent thread. The claim is wrong, and the mismatch burns hours.

A laptop owns disk, secrets, and process lifetime. A free shared server owns none of those for you. Mixing those two mental models creates quiet failures. Want the short version? Treat the remote box as a capability, not a machine.

Why this FAQ exists

Agent reviews keep repeating the same six claims. They sound reasonable in Slack. They are not contracts you can ship. I wrote this as a pasteable review checklist, not a product tour.

You get a probe script. You get a decision table. You do not get fake latency charts or unnamed vendor scores.

Disclosure: This article was prepared as part of MonkeyCode's product outreach. I point this probe at whatever free endpoint I am testing that day. MonkeyCode's free model access and free server option is one valid target for the same checks. I still do not treat that option as a dedicated box.

Myth 1: A URL means I own the machine

Claim I keep hearing: "It is just SSH without the SSH."

Is it, though? Open a shell on your laptop. List /tmp. Kill a runaway agent by PID. You can do that because you own the process tree. A remote completion API gives you tokens. It does not give you a process tree.

Corrected mental model:

• You own the client, the repo, and the loop.
• They own the scheduler, the weights, and the queue.
• Your files never "live" on that server unless you sent them.

How I check the hello, not the lease:

curl -sS -D - -o /tmp/models.json \
  -w "http=%{http_code} ttfb=%{time_starttransfer}\n" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  "$OPENAI_BASE_URL/models" | head

A 200 is a greeting. It is not a lease on hardware. Did the response name a machine you can SSH into? If not, stop calling it your box.

Myth 2: Yesterday's model is today's model

Claim I keep hearing: "The name in the env file is a pin."

Free pools rotate. Display names stay pretty. Weights do not. Did you store a digest? Or only a marketing string in .env?

Corrected mental model:

• Record model on every probe run.
• Record system_fingerprint when the host sends one.
• Hash a tiny fixture prompt and the raw completion.
• Fail the probe when identity moves without a review note.

I do not treat a missing fingerprint as proof of stability. Silence is not a pin. Silence is a gap in the contract.

Myth 3: Tool calling is on or off

Claim I keep hearing: "The docs say tools are supported."

Supported by whom? On which route? Under which load? A boolean in a feature list is not a schema your agent can trust.

I ask three questions, every run:

1. Does the response include a tool_calls array?
2. Are name and arguments both present?
3. Is arguments parseable JSON, not a chopped stream?

If any answer is no, your loop is guessing. Guessing is not a tool runtime. Would you ship a REST client that sometimes returns HTML?

Myth 4: Free means I can skip a kill-switch

Claim I keep hearing: "It is only a prototype."

Prototypes still loop. Loops still write files. Loops still leak tokens into logs. Why would "free" cancel any of that?

Corrected mental model:

• Cap steps. Cap wall-clock seconds. Cap file writes.
• Abort on repeated identical tool calls.
• Keep secrets in the client environment.
• Do not paste .env into the system prompt "just once."

Who skips the kill-switch? Nobody with a repo they still care about. Free compute does not make rm -rf cheaper. It makes it easier to ignore.

Myth 5: Prompts on a free host are private like /var/log

Claim I keep hearing: "It is my server because I did not pay."

Payment is not a privacy control. Free often means shared operations. Shared operations mean more eyes and more retention you did not configure. "We debug with samples" is a policy, not a rumor.

Corrected mental model:

• Redact emails, tokens, and customer ids before send.
• Truncate stack traces. Hash ticket identifiers.
• Read the host retention note before the first real bug.

If you cannot name the retention policy, you do not have one. Localhost logs follow your disk. Remote prompts follow theirs. Same word, different landlord.

Myth 6: One green smoke test is a platform

Claim I keep hearing: "It answered. Ship the agent."

One answer is an anecdote. Platforms need failure rows. What happens on 429? On a truncated finish_reason? On a tool name you never registered?

Corrected mental model: a four-row contract, not a demo GIF.

Signal	Pass if	Fail if	Client action
HTTP status	200	401, 404, 5xx	Stop the agent. Do not retry-blind.
Rate limit	rare 429 with Retry-After	tight loops of 429	Backoff. Then shed load.
Finish reason	stop or complete tool_calls	length mid-arguments	Refuse to parse. Ask again with a smaller payload.
Identity	fingerprint unchanged	name same, fingerprint moved	Re-run fixtures. Do not silently accept drift.

Does your smoke test fill every row? If not, you have a clip, not a gate.

Artifact: a capability probe, not a benchmark

This is a proposed harness. I am not publishing vendor numbers here. Run it against your endpoint. Keep the JSON next to the PR.

Save as probe_free_endpoint.py:

#!/usr/bin/env python3
"""Capability probe for an OpenAI-compatible chat endpoint.

Label: unexecuted until you point it at a real base URL.
It records identity and tool-call shape. It does not score quality.
"""
from __future__ import annotations

import argparse
import hashlib
import json
import os
import sys
import time
import urllib.error
import urllib.request

FIXTURE_PROMPT = (
    "Call the tool add_ints with a=2 and b=3. "
    "Do not explain. Do not answer in prose."
)
TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "add_ints",
            "description": "Add two integers and return the sum.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {"type": "integer"},
                    "b": {"type": "integer"},
                },
                "required": ["a", "b"],
            },
        },
    }
]


def post_chat(base: str, key: str, model: str, timeout: float) -> dict:
    url = base.rstrip("/") + "/chat/completions"
    body = {
        "model": model,
        "messages": [{"role": "user", "content": FIXTURE_PROMPT}],
        "tools": TOOLS,
        "tool_choice": "auto",
        "max_tokens": 128,
    }
    data = json.dumps(body).encode("utf-8")
    req = urllib.request.Request(
        url,
        data=data,
        headers={
            "Authorization": f"Bearer {key}",
            "Content-Type": "application/json",
        },
        method="POST",
    )
    t0 = time.perf_counter()
    try:
        with urllib.request.urlopen(req, timeout=timeout) as resp:
            raw = resp.read()
            status = resp.status
            headers = dict(resp.headers.items())
    except urllib.error.HTTPError as exc:
        raw = exc.read()
        status = exc.code
        headers = dict(exc.headers.items()) if exc.headers else {}
    except Exception as exc:  # network / timeout
        return {
            "ok": False,
            "error": type(exc).__name__,
            "detail": str(exc),
            "elapsed_s": round(time.perf_counter() - t0, 3),
        }
    elapsed = round(time.perf_counter() - t0, 3)
    try:
        payload = json.loads(raw.decode("utf-8"))
    except json.JSONDecodeError:
        payload = {"_non_json": raw[:400].decode("utf-8", "replace")}
    return {
        "ok": 200 <= status < 300,
        "status": status,
        "elapsed_s": elapsed,
        "retry_after": headers.get("Retry-After"),
        "payload": payload,
    }


def inspect(result: dict) -> dict:
    payload = result.get("payload") or {}
    choice = (payload.get("choices") or [{}])[0]
    msg = choice.get("message") or {}
    tool_calls = msg.get("tool_calls") or []
    args_ok = []
    for call in tool_calls:
        raw_args = (call.get("function") or {}).get("arguments")
        try:
            json.loads(raw_args or "")
            args_ok.append(True)
        except json.JSONDecodeError:
            args_ok.append(False)
    identity = {
        "model": payload.get("model"),
        "system_fingerprint": payload.get("system_fingerprint"),
        "finish_reason": choice.get("finish_reason"),
    }
    fixture_hash = hashlib.sha256(FIXTURE_PROMPT.encode()).hexdigest()[:12]
    return {
        "http_ok": result.get("ok"),
        "status": result.get("status"),
        "elapsed_s": result.get("elapsed_s"),
        "retry_after": result.get("retry_after"),
        "identity": identity,
        "tool_call_count": len(tool_calls),
        "tool_arguments_json_ok": args_ok,
        "fixture_sha12": fixture_hash,
        "error": result.get("error"),
        "detail": result.get("detail"),
    }


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--model", default=os.environ.get("OPENAI_MODEL", ""))
    parser.add_argument("--timeout", type=float, default=30.0)
    parser.add_argument("--out", default="probe_result.json")
    args = parser.parse_args()
    base = os.environ.get("OPENAI_BASE_URL", "")
    key = os.environ.get("OPENAI_API_KEY", "")
    if not base or not key or not args.model:
        print("Need OPENAI_BASE_URL, OPENAI_API_KEY, and --model", file=sys.stderr)
        return 2
    inspected = inspect(post_chat(base, key, args.model, args.timeout))
    with open(args.out, "w", encoding="utf-8") as fh:
        json.dump(inspected, fh, indent=2, sort_keys=True)
        fh.write("\n")
    print(json.dumps(inspected, indent=2, sort_keys=True))
    if not inspected.get("http_ok"):
        return 1
    if inspected.get("tool_call_count", 0) < 1:
        return 1
    if not all(inspected.get("tool_arguments_json_ok") or []):
        return 1
    return 0


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

How I run it

export OPENAI_BASE_URL="https://YOUR_COMPATIBLE_HOST/v1"
export OPENAI_API_KEY="YOUR_KEY"
python probe_free_endpoint.py --model "$OPENAI_MODEL" --out probe_result.json
echo $?

Then paste probe_result.json into the PR. Reviewers should argue with the JSON. They should not argue with a screenshot of one lucky reply. Exit code 1 means the endpoint answered without a usable tool call. That is a contract miss, not a vibe miss.

Store the last good fingerprint beside the probe. Diff it on Monday. Did the name stay still while the fingerprint moved? That is Myth 2 in the wild.

Decision table: when the free host is enough

Job	Free shared endpoint	Not this approach
Fixture the tool-call shape	Yes	—
Teach the loop's kill-switch	Yes	—
Redaction dry-runs	Yes	—
Nightly identity drift check	Yes	—
Customer data in prompts	No	Paid, private, or local weights
Uncapped write loops on a repo	No	Local runner with PID control
Compliance evidence pack	No	A host with a named retention policy
"It must be the same weights tomorrow"	No	A pin you can actually verify

Notice the pattern? Free is for learning the contract. Free is not for pretending you rented a GPU.

Limitations, and who should not use this

This probe does not measure answer quality. It does not rank hosts. It does not prove safety. A parseable tool_calls array can still call the wrong function with the wrong ints.

Skip this approach if:

• You need a signed model digest for an audit.
• You cannot redact the prompt at all.
• Your agent must write production data on the first try.
• You expected SSH, GPUs, or a private queue from a free URL.
• You will not read a retention policy because "it is just a prototype."

I also will not claim a free pool lasts forever. Availability claims change. Re-run the probe. Do not screenshot an old 200.

The mental model I want in reviews

Ask four questions before anyone says "just point the agent at free":

1. Who owns the PID when the loop goes feral?
2. What identity fields did we persist besides a pretty name?
3. Which kill-switch fires first, time or steps?
4. What did we redact, and where is that tested?

If the answers are shrugs, you are still on localhost-in-your-head. The URL did not change that. The FAQ did not either, until you run the probe.

Run the probe. Argue with the JSON. Bring the failure rows, not the happy path.