Pin the Fixture Before a Weekend Agent Demo Leaves Localhost

A weekend agent demo survives Monday only when three files travel with the code: a frozen task fixture, an endpoint pin, and a local usage ceiling. Free model access can execute that fixture. It should not decide what the demo is.

This log is a scope cut for one side project. It is not a product review, and it is not a benchmark. The scripts are proposed examples. They were not run against a live quota, and they report no latency, accuracy, or cost.

Cut the demo to one label

The finished path does one thing. It reads a synthetic support note and writes one label: billing, access, or other. There is no second task hiding in the same function.

That limit is what makes the weekend reviewable. A demo that also opens tickets, browses a docs site, and drafts a reply cannot be hashed as a single input. When the label flips on Monday, the author will not know which extra behavior moved.

The note is invented. Names, invoices, and symptoms in the fixture are placeholders. A copied inbox, a production log, or a real company identifier does not enter this directory. Public write-ups about models noticing a live target are a reason to stay on fake text. They are not a procedure to repeat, and this log does not describe one.

Files that define done

Four paths are the whole project. Anything beyond them is a different weekend.

• fixtures/note.txt is the only model input.
• pins/demo_pin.json stores the fixture hash, base URL, model id, character ceiling, and a network flag.
• scripts/pin_check.py exits non-zero when those fields disagree with disk.
• scripts/run_demo.py prints a label from a local stub, or from the pinned endpoint if the flag allows it.

Skipped on purpose: a web UI, streaming output, automatic retries, extra tools, and any store of past runs. Those pieces answer different questions. This cut asks whether the same note still maps to a label after the endpoint changes.

Freeze the note

The fixture stays short so a human can read it during review. The refund wording is there so the stub has an obvious branch. No card number, no email address, and no account id appear.

Customer asked for a refund on invoice 1842 after a duplicate charge.
No payment instrument is included in this synthetic note.

A longer note is a different task. If the file grows past the pin's character ceiling, the checker fails closed. Growing the fixture and raising the ceiling in the same commit is a scope change, and it should look like one in review.

Pin data, not a slogan

The pin is configuration. The model id is whatever string the operator copies from current documentation on the day of the run. This log does not nominate a model, a hardware shape, a duration, or a token grant.

{
  "fixture": "fixtures/note.txt",
  "fixture_sha256": "REPLACE_AFTER_HASH",
  "base_url": "http://127.0.0.1:8787",
  "model_id": "REPLACE_FROM_CURRENT_DOCS",
  "max_chars": 1200,
  "allow_network": false
}

allow_network begins false. The first passing run never leaves the machine. Switching the base URL to a hosted server is a deliberate edit, reviewed like any other config change.

Refuse the run when the pin drifts

The checker below is unexecuted example code. Run it locally, and keep the exit codes only after they match the operator's tree.

import hashlib
import json
import pathlib
import sys

ROOT = pathlib.Path(__file__).resolve().parents[1]

def file_sha256(path: pathlib.Path) -> str:
    return hashlib.sha256(path.read_bytes()).hexdigest()

def main() -> int:
    pin = json.loads((ROOT / "pins/demo_pin.json").read_text())
    fixture = ROOT / pin["fixture"]
    text = fixture.read_text(encoding="utf-8")
    if file_sha256(fixture) != pin["fixture_sha256"]:
        print("fixture hash drift", file=sys.stderr)
        return 2
    if len(text) > int(pin["max_chars"]):
        print("fixture exceeds local ceiling", file=sys.stderr)
        return 3
    local = pin["base_url"].startswith("http://127.0.0.1")
    if not pin["allow_network"] and not local:
        print("network disabled; pin is not local", file=sys.stderr)
        return 4
    print("pin ok")
    return 0

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

max_chars is not a billing tokenizer. It cannot prove what a vendor will meter. It only stops a swollen file from masquerading as the weekend task. Real usage, if the vendor shows it, is read from that vendor's own page on the day of the call.

Exit codes stay boring on purpose. 2 means the note changed. 3 means the local ceiling was crossed. 4 means the pin points off-box while network is still forbidden. A later script can map those codes to a message, but the weekend version should fail in a way a human can see in the terminal.

Prove the layout before any network call

Hash the fixture, write the digest into the pin, then check. The stub comes last among the local steps, and it still does not open a socket.

python -c "import hashlib,pathlib; p=pathlib.Path('fixtures/note.txt'); print(hashlib.sha256(p.read_bytes()).hexdigest())"
python scripts/pin_check.py
python scripts/run_demo.py --mode stub

The stub is intentionally crude. It exists so out/last_label.txt has a writer before a hosted model is introduced.

def stub_label(text: str) -> str:
    lowered = text.lower()
    if "invoice" in lowered or "refund" in lowered:
        return "billing"
    if "password" in lowered or "login" in lowered:
        return "access"
    return "other"

A keyword map will mis-label paraphrases. That failure is acceptable here. The log does not claim the stub, or any later model, is accurate. Accuracy would need a labeled set and a scored run, and neither is part of this cut.

The runner should pass --mode stub straight to that function and write the returned word. A hosted mode, if added later, should send the fixture bytes and store the label the same way. Two writers for one output file will make Monday's diff lie about which path produced it.

Where hosted free access fits

Once the stub writes a label from the hashed note, the same bytes can be posted to a hosted endpoint. MonkeyCode is the hosted option this log considers. Disclosure: This article was prepared as part of MonkeyCode's product outreach.

The operator supplied two availability claims and no further product sheet: free model access, and a free server option. The project was also described as open source. This draft does not verify a license, a repository statistic, a model list, or a numeric quota. It does not state that either free option is permanent, faster, or sufficient for a given hardware need.

A remembered token quota does not belong in the pin or in the article. Quotas change, and a number carried from an older page is how weekend write-ups go stale. Copy the model id from the current docs into an uncommitted pin. Leave the committed pin on localhost with allow_network set to false.

Choose the runner from the constraint

Constraint	Runner	Why
Layout or hash still failing	Local stub	A remote call will not fix a bad fixture
Need the label on a second machine without a private GPU	Hosted free server, if today's terms allow	The fixture stays the same; only the base URL changes
Note contains secrets or personal data	Stop	Hosted access does not make that upload acceptable
Need an SLA, a private network, or a frozen model build	Stop	A weekend pin is not a production control
Hoping for a speed or quality ranking	Stop	This log did not measure either

Remove the product name and the label task still stands. That is the test for whether the mention is doing work. Here it only names one place a free hosted process might execute the already-pinned fixture.

What the weekend refuses to add

The skip list is part of the result, not a backlog disguised as depth.

1. No tool registry, loop cap, or turn budget. Those controls solve other failures and are not restated as if they were new.
2. No retry loop. A refused or timed-out call stops, so a free pool is not burned by an unattended script this log does not implement.
3. No scoreboard. One synthetic note cannot support a quality claim.
4. No sign-up flow, no shared server, and no background worker.
5. No comparison that calls one host faster, cheaper, or stronger. That run was not performed.

If a later weekend adds retries, it needs its own ceiling and its own log. Bolting them onto this pin would hide the drift check.

Limits, and who should not use the pin

The checker trusts a file the operator can edit. It is a drift tripwire, not an authorization boundary. Flipping allow_network to true is a one-line change. Review that line the same way a dependency bump is reviewed.

A matching hash does not make a fixture safe. It only shows the fixture is the same file that was reviewed. Confidential text remains confidential after hashing. A local character ceiling is also not a cost cap, because the vendor may tokenize differently, add system text, or meter a failed request.

Walk away from this approach when any of the following is true.

• The input is production data, a credential, or customer text.
• The team needs retention controls, a private network path, or a contractual uptime target.
• The reader came for benchmark numbers. None are available from this draft.
• The pin is expected to stop a determined caller. It will not.

Free model access and a free server can also throttle, expire, or change models without this repository noticing. A demo that works only while a grant remains has an external dependency. Stub mode is the path that does not depend on that grant.

Before the demo is shown to anyone

Run the checker on a clean tree. Confirm the committed pin still points at 127.0.0.1 and still disables network. If a hosted trial is useful, keep that URL in an uncommitted pin and read the vendor page the same day for model ids and server terms.

For that trial, the current MonkeyCode docs are the place to confirm free model access and the free server option, then paste only those live values into the uncommitted pin. Do not promote a remembered quota into the article, the README, or the fixture.

Monday's reader should be able to hash the note, run the stub, and see the same label path without creating an account. That is the bar this cut was built to clear.