Pass Four Fit Gates Before You Choose Free or Isolated Agent Compute

Free shared inference is a fit only when four written gates pass, and the invoice is the last argument. I refuse to debate price while an agent still carries live secrets inside the planning prompt. Can you replay yesterday's failure against the same model identifier your tests already named? If that answer stays fuzzy, the free option is not your runtime yet, no matter how attractive the cost looks.

This article is a comparison framework for choosing free shared compute, a hybrid split, or a host you pay to isolate. I score secret proximity, replayability, concurrency shape, and model pinning as four independent gates. Only after those gates are written do I pick a runtime, because an unsigned workload card turns every vendor debate into theater.

Write the workload card before you pick a place to run

I start with a card in git, not with a signup form and a hopeful screenshot. The card is deliberately boring, because boring facts are easier to challenge than a vibe about good enough models. Would you let a teammate change the runtime without reading this card first, and still call the setup engineering?

Here is the template I keep as workload-card.json, and you should treat it as a labeled proposal rather than a production benchmark. Copy it, rename the agent, and lie to the file only if you also enjoy lying to your future self.

{
  "name": "doc-triage-agent",
  "touches_live_secrets": false,
  "customer_payload_in_prompt": false,
  "can_store_full_trace_locally": true,
  "needs_same_model_id_tomorrow": false,
  "parallel_runs_per_hour": 8,
  "standup_blocked_if_queue_stalls": false,
  "tool_execution_host": "local",
  "planning_host_preference": "shared_free"
}

Notice that tool_execution_host is already a decision, not a wish you hope the vendor will honor later. If tools run locally, a planning model can live on shared capacity without ever holding those keys. If tools and prompts share one opaque server, you have already failed the secret-proximity gate before the first token arrives.

Four fit gates, scored in a fixed order

I score each gate as pass, split, or fail, and I refuse to average them into a fake total. A split means the planning loop may use free shared inference while tools stay on a box I control. A fail means I will not park that workload on a free shared server, even when the queue is idle and the dashboard looks friendly.

Gate 1 — Secret proximity

Ask one blunt question that does not care about marketing pages or complimentary tiers. Can a log from this run be pasted into a public issue without a security review from someone sober? If the honest answer is no, free shared compute is the wrong place for the full loop, and you should redact or relocate before you continue.

I still allow a free model to see a scrubbed task statement, and I call that a split rather than a pass. Passing means the entire prompt bundle is already public-safe, including tool arguments and recovered files. Why would a zero invoice justify a prompt that still names an internal hostname?

Gate 2 — Replayability

Engineering needs a trace you can replay, which is the gap between sketching with a model and actually shipping an agent. Can you store prompts, tool calls, and outputs for at least seven days on storage you own? Shared free queues are fine for sketches, but they are a weak archive when a stakeholder asks what happened on Tuesday.

If replay lives only in a browser tab, I score this gate as fail and I stop. Export the bundle on every run, even when the model itself arrives through a free path. Without that export, you cannot tell whether the runtime failed or your prompt did.

Gate 3 — Concurrency shape

Count the runs you expect in a busy hour, not the runs you wish were complimentary. One developer iterating can absorb jitter, retries, and a queue that hiccups during someone else's spike. A cluster of agents feeding a morning standup cannot absorb that same jitter without turning the free tier into an accidental dependency.

I treat fewer than ten parallel runs per hour, with no human blocked on the queue, as a pass for free shared capacity in this proposal. Above that threshold, or if people wait on the output, I move the queue to paid isolation or a self-hosted runner. The number ten is a conversation starter, and you should replace it when you have real traffic.

Gate 4 — Model pinning

Do your tests name a model, or do they name whatever the free pool happens to serve after lunch? If the suite assumes stable tool-call shapes, you need a pin you can still resolve tomorrow. Free shared pools can change what they serve without booking a meeting on your calendar, and your assertions will rot quietly.

I only pass this gate when I can tolerate a different completion tomorrow without invalidating the last week of debugging. Assertion tests that freeze expected tool-call shapes usually need a runtime I can pin. If you cannot pin, do not pretend the test still measures the same system.

Decision table I actually walk

Secrets	Replay owned	Concurrency	Pin needed	Recommendation
pass	pass	pass	no pin required	Free shared planning is in play; keep tools local if they exist
split or fail	pass	pass	no pin required	Hybrid: local tools and redacted plans, never the raw payload
any	fail	any	any	Do not use shared free compute as the system of record
pass	pass	fail	any	Paid or self-hosted queue; free path only for off-peak sketches
any	any	any	pin required	Isolated or paid runtime where you can name the model tomorrow

I read the table from top to bottom and stop at the first row that matches the card. Ties go to the more isolated option, because isolation is cheaper than an incident you cannot reconstruct. Why would you optimize the invoice of a run you cannot defend in a review?

A reproducible scorer you can run locally

The following script is a proposal, and I have not attached production metrics to its thresholds. Save it as fit_score.py and point it at the JSON card so the decision is generated instead of performed in Slack.

#!/usr/bin/env python3
"""Proposal: score an agent workload card for free vs isolated compute."""
import json
import sys

PIN_FAIL = "self_hosted_or_paid_pinnable"
REPLAY_FAIL = "do_not_use_shared_free_as_record"
QUEUE_FAIL = "paid_or_self_hosted_queue"
HYBRID = "hybrid_local_tools_free_planning"
FREE_OK = "free_shared_ok_for_this_card"


def score(card: dict) -> str:
    secrets_ok = (not card["touches_live_secrets"]) and (
        not card["customer_payload_in_prompt"]
    )
    replay_ok = bool(card["can_store_full_trace_locally"])
    pin_needed = bool(card["needs_same_model_id_tomorrow"])
    busy = int(card["parallel_runs_per_hour"]) >= 10
    blocked = bool(card["standup_blocked_if_queue_stalls"])
    tools_local = card.get("tool_execution_host") == "local"

    if not replay_ok:
        return REPLAY_FAIL
    if pin_needed:
        return PIN_FAIL
    if busy or blocked:
        return QUEUE_FAIL
    if not secrets_ok:
        return HYBRID if tools_local else PIN_FAIL
    return FREE_OK


def main() -> None:
    path = sys.argv[1] if len(sys.argv) > 1 else "workload-card.json"
    with open(path, encoding="utf-8") as handle:
        card = json.load(handle)
    print(json.dumps({"name": card.get("name"), "decision": score(card)}, indent=2))


if __name__ == "__main__":
    main()

Run it like this from the same directory as the card:

python3 fit_score.py workload-card.json

You should see a single decision string that you can paste into a pull request. If you disagree with the string, change the card fields, not the narrative around the vendor. That habit is the entire difference between a fit check and a purchase argument.

Numbered workflow I follow on a new agent

1. Fill workload-card.json before you request any shared runtime or paste a secret into a prompt.
2. Run fit_score.py and paste the JSON decision into the pull request that adds the agent.
3. If the result is hybrid, move credentials and tool runners onto a host you control before the first live call.
4. Export a trace on the first failing run and confirm you can replay that bundle without the original web session.
5. Re-score after the first week, because concurrency always lies during the demo and the first internal fan-out.

I keep step five because the card rots in quiet ways that never show up in a launch checklist. A solo experiment becomes a team habit, and then the free queue is suddenly sitting in the critical path. Did anyone update the card when that promotion happened, or did the invoice stay at zero while the waiting queue grew?

Where a free model and a free server belong

When the card says free_shared_ok_for_this_card or hybrid_local_tools_free_planning, I look for a place that offers free model access without merging tools and secrets into the same box. Disclosure: This article was prepared as part of MonkeyCode's product outreach. MonkeyCode is an open project that currently offers free model access and a free server option, which I treat as one parking spot for the non-secret planning loop.

I do not treat that option as a pin, a quota promise, a hardware spec, or a production SLA, because none of those claims belong in this article. I still run the scorer first. If the scorer says isolate, I isolate, even when the shared option costs nothing and the signup is easy.

The useful split looks ordinary once the card exists. Planning prompts with redacted context can hit the free model path without inheriting production credentials. Tool execution, secret material, and the trace archive stay on a machine whose disk I can image, and the free server only sees what the card already marked public-safe.

Who should not use this approach

Do not use this scorer as a compliance stamp for regulated work, because it does not know your retention policy or your on-call rotation. Teams in healthcare, payments, or any environment with a contractual audit trail should assume fail until a security review says otherwise. The script will cheerfully recommend free shared planning if you lie on the card, which is a feature of honesty, not a bug in Python.

Do not use it if you cannot export traces to storage you control, since a pretty web session with no local bundle fails gate two by construction. Do not use it to justify stuffing customer data into a shared prompt because the invoice is zero. I also would not leave a hackathon demo on free shared compute after it grows a public URL, without filling the card again.

Limitations of the artifact

The thresholds are arbitrary on purpose, and they will be wrong for your traffic on a busy Thursday. Ten parallel runs per hour is a prompt for a conversation, not a load test you can cite. The script never measures latency, token spend, or answer quality, and those omitted numbers go stale faster than a written secret-proximity answer.

I have not claimed that any vendor, including a free option, will keep the same models available next month. Pinning is a requirement you bring to the runtime, not a feature I can invent in a blog post. If your work needs a named model tomorrow, budget for a runtime that lets you name it, then keep the free path for cards that passed without that need.

Closing

Write the four gates, run the scorer, and only then pick free, hybrid, or isolated compute for that agent. Keep the card in git either way, because the next argument should be about fit rather than about a price tag. If you want a shared place to park a card that already passed, MonkeyCode's free model access and free server option are one way to try that split.