Score the Lane First: Free Shared Workspace, Paid API, or Self-Hosted

The cheapest lane is rarely the correct one once an agent starts retrying its own assumptions. I score every coding job on secrets, retry amplification, isolation, and ops appetite before choosing. Free model access on a free server remains a solid default for public scratch work. Paid APIs and self-hosted boxes win when the loop can leak data or starve neighbors.

The question I ask before any model name

Have you noticed how agent write-ups skip the control-plane choice and jump straight into tools? I made that jump, and the retries quietly multiplied cost, noise, and blast radius together. A free shared workspace is not a tiny paid API, and a paid API is not your box. The real fork is who absorbs a bad tool call at two in the morning.

I keep this comparison intentionally boring so architecture theater cannot hide the actual operational tradeoff. Fancy diagrams rarely tell you whether a runaway loop should share a server with strangers. That is the question this scorecard answers, and it answers it with integers you can replay. If I cannot explain the score to a teammate, I do not ship the agent loop yet.

Four dimensions, not a vibe check

I use four integer scores from zero through three, and I refuse half points on purpose. Zero means the dimension barely matters, while three means it should dominate the lane choice. I write the numbers beside the ticket because memory gets generous after a long debug session.

1. Secret gravity

Does the prompt, the repo, or the tool output contain secrets I cannot rotate casually? Customer tokens, private keys, and production logs always score a three on this dimension. Public docs, license files, and synthetic fixtures score a zero, and I try to stay there. If I hesitate for more than a breath, I score a two and I stop bargaining with myself.

2. Retry multiplier

Will the agent loop, reflect, and call tools again when it assumes a path already exists? One-shot summarization scores a zero because a single miss does not amplify the blast radius. Multi-step coding agents that edit, test, and retry without a hard cap score a three. This is where free shared lanes get noisy, because retries arrive correlated, bursty, and unapologetic.

3. Isolation need

Do I need process isolation, network policy, or a quiet neighbor guarantee for this loop? Shared free servers are fine for throwaway katas that I can kill without waking anybody. They are a poor home for long jobs that pin CPU, fill disks, or hold file locks. If a runaway loop can hurt a stranger, I raise this score and I do not look away.

4. Ops appetite

Will I patch, backup, and watch the box if the free lane disappears next Tuesday? Self-hosting is not a discount; it is a pager I chose and a patch calendar I own. If I will not run updates, I must not pick self-hosted just to feel more serious. Low ops appetite is not a moral failure; it is a signal to rent a managed lane.

A numbered workflow I can repeat

I run the same six steps for every new agent-shaped job, even when the demo looks tiny. The ritual is the artifact I trust, because vibes do not survive contact with retries. Would I skip the write-up if I were in a hurry? I would, and that is the failure mode.

1. Write one sentence for the job, and name the data it may touch during retries.
2. Score secret gravity, retry multiplier, isolation need, and ops appetite from zero to three.
3. Sum the first three scores into a risk total, and keep ops appetite as a separate axis.
4. Map that pair onto the decision table below, and refuse to average away a three.
5. Run a dry pass on synthetic data in the cheapest lane that the table still allows.
6. Re-score after the first real failure, because the first estimate is almost always too kind.

Would I skip step six if the first demo looked clean and the logs were quiet? I used to skip it, and that is how assumed files sneaked into the wrong lane. The second score is the one I keep, not the optimistic one I wrote before lunch.

The decision table

Read the table as vetoes plus ranges, not as a precise optimizer you can blindly automate. A three on secrets never goes to a shared free server, even when the total looks small. That single veto matters more than the sum, and I treat it as a hard gate.

Risk total (secrets + retries + isolation)	Ops appetite	Lane I pick
0–2	any	Free shared workspace
3–5	0–1	Paid API with spend caps
3–5	2–3	Self-hosted or paid, decided by data gravity
6–9	0–1	Paid API, with tools still sandboxed
6–9	2–3	Self-hosted with network policy, not a shared free box

When I need a scratch lane with free model access and a free server option, I put MonkeyCode in the first row of that table.

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

I do not treat that lane as a production control plane, and I do not hide that limit. I treat it as a place to prove the workflow on public fixtures before money or hardware appears.

A scorecard you can rerun

The script below is a decision aid you can run locally, and it never calls a vendor. It is not a benchmark, and every input is an estimate you must be willing to defend. Paste it, answer the prompts, and keep the JSON next to the job ticket for the re-score.

#!/usr/bin/env python3
"""lane_score.py — choose free shared vs paid API vs self-hosted.

This is a decision aid, not a benchmark. Re-run after the first failure.
"""
from __future__ import annotations

import argparse
import json
import sys
from dataclasses import asdict, dataclass


def parse_score(value: str) -> int:
    n = int(value)
    if n not in {0, 1, 2, 3}:
        raise argparse.ArgumentTypeError("expected 0, 1, 2, or 3")
    return n


@dataclass
class Score:
    job: str
    secrets: int
    retries: int
    isolation: int
    ops: int

    @property
    def risk(self) -> int:
        return self.secrets + self.retries + self.isolation

    def vetoes(self) -> list[str]:
        notes: list[str] = []
        if self.secrets >= 3:
            notes.append("secrets=3 vetoes any shared free server")
        if self.isolation >= 3 and self.ops <= 1:
            notes.append(
                "isolation=3 with low ops appetite needs a managed paid API"
            )
        return notes

    def lane(self) -> str:
        if self.secrets >= 3 and self.ops <= 1:
            return "paid_api_sandboxed_tools"
        if self.secrets >= 3:
            return "self_hosted_with_network_policy"
        if self.risk <= 2:
            return "free_shared_workspace"
        if self.risk <= 5 and self.ops <= 1:
            return "paid_api_with_spend_caps"
        if self.risk <= 5:
            return "self_hosted_or_paid_by_data_gravity"
        if self.ops <= 1:
            return "paid_api_sandboxed_tools"
        return "self_hosted_with_network_policy"


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        description="Score which lane should own an agent loop"
    )
    parser.add_argument("--job", required=True)
    parser.add_argument("--secrets", type=parse_score, required=True)
    parser.add_argument("--retries", type=parse_score, required=True)
    parser.add_argument("--isolation", type=parse_score, required=True)
    parser.add_argument("--ops", type=parse_score, required=True)
    parser.add_argument("--self-check", action="store_true")
    return parser


def self_check() -> None:
    toy = Score("public kata rename", 0, 2, 1, 0)
    assert toy.risk == 3
    assert toy.lane() == "paid_api_with_spend_caps"
    tight = Score("public kata, one repair pass", 0, 1, 1, 0)
    assert tight.lane() == "free_shared_workspace"
    secret = Score("rotate customer tokens", 3, 1, 1, 0)
    assert secret.lane() == "paid_api_sandboxed_tools"
    print("self-check ok", file=sys.stderr)


def main(argv: list[str] | None = None) -> int:
    args = build_parser().parse_args(argv)
    if args.self_check:
        self_check()
    score = Score(
        job=args.job,
        secrets=args.secrets,
        retries=args.retries,
        isolation=args.isolation,
        ops=args.ops,
    )
    payload = {
        **asdict(score),
        "risk_total": score.risk,
        "vetoes": score.vetoes(),
        "lane": score.lane(),
        "note": "proposal only; re-score after the first real failure",
    }
    json.dump(payload, sys.stdout, indent=2)
    sys.stdout.write("\n")
    return 0


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

Save that as lane_score.py, then compile it and run the labeled walkthrough numbers below. The --self-check flag only asserts the table, and it still requires a job description so the command stays honest.

python3 -m py_compile lane_score.py
python3 lane_score.py --self-check \
  --job "rename tests in a public kata" \
  --secrets 0 --retries 2 --isolation 1 --ops 0

Expected JSON includes "risk_total": 3 and "lane": "paid_api_with_spend_caps". If those keys drift, the table in the script no longer matches the table in this article.

A labeled walkthrough

I have not run this against a production tenant, so treat the numbers as a labeled walkthrough. Suppose I want an agent to rename tests in a public kata repository with no private fixtures. Secrets are zero, retries are two, isolation is one, and ops appetite stays at zero. Risk total is three and ops is zero, so the table says a paid API with spend caps.

That result surprised me, because the repository is public and the task looks like a toy. The retry score pushed it off the free shared row, which is the point of scoring. If I drop retries to one by forbidding unbounded loops, the total becomes two again. The free shared workspace returns, and I did not have to rent a box to get there.

Have you tried shrinking the agent before you argue about hardware, vendors, or monthly invoices? I rerun the same command with --retries 1 and keep both JSON files beside the ticket. The diff is the decision record, not a vibe I will misremember next week.

python3 lane_score.py \
  --job "rename tests in a public kata, one repair pass" \
  --secrets 0 --retries 1 --isolation 1 --ops 0

That second pass should print "lane": "free_shared_workspace". Constraints moved the job, and no new capacity had to appear for that move to count.

Limitations, and who should not use this

This method will not pick a model, quote a quota, or promise that a free lane lasts. Free tiers change, and I will not freeze a number here that I cannot verify next week. It also will not replace legal review when tools can reach regulated or customer-owned data. If your agent can touch production, this scorecard is a conversation starter rather than a permit.

Who should skip this approach entirely, even as a whiteboard exercise on a Friday afternoon? Anyone with a mandated VPC, a signed vendor list, and an auditor who wants names, not scores. Skip it if you need hard latency SLOs, because none of these lanes are scored on p95. Teams that cannot answer the secret question should inventory data before they score anything else.

I also would not use a free shared server as a cache for customer prompts or traces. Shared means shared, and hobby isolation is not a control you can show an auditor. That sentence is the whole security review I give myself for weekend-scale agent experiments.

What I keep after the score

Pick the lane with the failure you can own, and let the model remain a later detail. If your score lands on the free shared column, dry-run the workflow on a throwaway public repository first. I keep the JSON beside the ticket so the next retry does not get an unearned vote. The score is allowed to change; the habit of scoring before switching lanes is not.