There is a whole category of agent work that does not need a model at all: compressing a session log, scraping clean text out of a URL, minifying a bloated prompt, converting JSON to CSV, generating an image on a local GPU. Every one of those is a deterministic operation, and every one of them burns tokens when you make an LLM reason through it step by step.
Agent Media Tools ships Blueprints — 13 Python scripts and 2 kits — for exactly that work. They are free to download with no account and no API key, and the download surface is a normal HTTP API, which means an agent can find and install its own tooling with two calls. This post is the download half of the shop API: catalog, single-file downloads, kit ZIPs, and the MCP tools that wrap them.
A Blueprint is a single-file Python CLI that runs on your machine or server, next to your model. Examples from the live catalog:
gen.py — image generation against any ComfyUI server, with a --jpeg export flaggen-sd.py — txt2img against Stable Diffusion WebUI (A1111 / Forge / ReForge) via SDAPIweb-scrape.py — clean text extraction from a URLdeliver.py — send files and messages to Discord or Telegramcontext-compressor.py, context-filter.py, context-saver.py, session-handoff.py, session-resume.py — context and session state workloop-buster.py — detect repetition loops and emit an intervention promptprompt-minify.py, data-convert.py, lean-context.py — prompt slimming, format conversion, and a proxy that strips prompt bloatThey are not hosted tools. Nothing is uploaded, no credits are spent, and no key is involved — the tradeoff is that you supply the local runtime (ComfyUI, SD WebUI, or nothing at all for the stdlib-only scripts). The hosted REST/MCP catalog stays separate, with its own free daily allowances and credits. Each Blueprint also has its own documentation page, for example /docs/gen.
GET /api/shop/items is public. No key, no session, no rate-limit dance for a single read:
curl -s https://agentmediatools.com/api/shop/items
The response carries everything an installer needs:
| Field | What it holds |
|---|---|
scripts[] | id, name, description, filename, tokens_saved_per_call, dependencies, tier, price_usd, download_url |
bundles[] | Kit id, scripts_included, total_tokens_saved_per_session, download_url |
credit_packs[] | Optional credit packs for the hosted side (never needed for downloads) |
how_agents_buy | Plain-language instructions for agents reading the payload |
Every script is returned with "tier": "free" and "price_usd": "0.00". To get a quick inventory without parsing HTML or loading jq:
curl -s https://agentmediatools.com/api/shop/items | python3 -c "
import json, sys
catalog = json.load(sys.stdin)
for s in catalog['scripts']:
print(s['id'].ljust(22), s['tier'].ljust(6), str(s['tokens_saved_per_call']).rjust(6), s['dependencies'])
"
That dependencies field is the useful part for automation. It is an array of strings: the context tools report ["none (stdlib only)"], while gen.py reports ["requests", "Pillow"] and web-scrape.py reports ["beautifulsoup4 (optional)", "requests (optional)"]. A few scripts mix in optional extras such as "urllib (optional, for API mode)" or "curl (system tool)", so treat the list as advisory and match on the leading word rather than testing equality. That is enough to decide what is installable before you pull anything down.
GET /api/shop/download/{item} serves the file directly. -O -J keeps the server-provided filename:
curl -sO -J https://agentmediatools.com/api/shop/download/gen.py python3 gen.py --help
Then drive it like any CLI. The image generator takes real sampling flags, so the model never has to plan the workflow:
python3 gen.py --prompt "misty forest at dawn, volumetric light" \ --steps 30 --cfg 7 --width 1024 --height 1024 \ --jpeg --output-dir ./out
If you want zero third-party libraries, download a stdlib-only Blueprint instead:
curl -sO -J https://agentmediatools.com/api/shop/download/context-compressor.py python3 context-compressor.py --file session.log --minify --stats
loop-buster.py works the same way: python3 loop-buster.py --file session.log --threshold 3 --output report.json.
The two kits are streams, not archives stored on disk. Requesting a kit id returns Content-Type: application/zip with a download filename, so the same curl flags work:
curl -sO -J https://agentmediatools.com/api/shop/download/toolkit-bundle curl -sO -J https://agentmediatools.com/api/shop/download/rescue-kit unzip -o toolkit-bundle.zip -d blueprints
| Kit | Files inside |
|---|---|
toolkit-bundle | gen.py, gen-sd.py, web-scrape.py, deliver.py, context-saver.py, data-convert.py |
rescue-kit | context-compressor.py, loop-buster.py, prompt-minify.py, session-resume.py |
Two MCP tools cover this surface on the hosted server. list_shop_items takes no arguments and returns the same catalog JSON you just fetched with curl — so it is safe to call in an agent loop, since the endpoint behind it is public. initiate_purchase takes an item id such as gen.py, lean-context.py, or toolkit-bundle.
The important detail: for any Blueprint or kit, that call is not a purchase. The API short-circuits and returns a free download instruction instead of a Stripe checkout URL:
{
"free": true,
"download_url": "/api/shop/download/gen.py",
"message": "Blueprints are free. No payment or agent spend approval is required."
}
Only credit packs — items like credits-100 — reach Stripe, and only those need an agent key with the hosted spend policy satisfied. That means the common agent mistake (a model refusing to install a helper script because it assumes money is involved) is easy to design around: call the tool, read free: true, download, move on.
If you want to check entitlement before downloading anything, the agent-key version of the access endpoint answers in one call:
curl -H "Authorization: Bearer YOUR_AGENT_KEY" \ "https://agentmediatools.com/api/agent/shop/check-access?item=rescue-kit"
{ "has_access": true, "via": "free_library" }
Here is the pattern in Python: read the catalog, mirror every free script into a local folder, and report what each one needs beyond the standard library so the agent knows what it can run right now. Notice that it uses the catalog's own download_url field instead of hardcoding paths, and treats dependencies defensively because it can be missing in reduced responses.
import json, os, shutil, stat, urllib.request
BASE = "https://agentmediatools.com"
DEST = "./blueprints"
os.makedirs(DEST, exist_ok=True)
with urllib.request.urlopen(f"{BASE}/api/shop/items", timeout=30) as r:
catalog = json.load(r)
def extras(script):
"""Libraries a script needs beyond the standard library."""
deps = script.get("dependencies") or []
if isinstance(deps, str):
deps = [deps]
return [d for d in deps if not str(d).startswith(("none", "urllib", "curl"))]
for script in catalog["scripts"]:
path = os.path.join(DEST, script["filename"])
with urllib.request.urlopen(BASE + script["download_url"], timeout=60) as src:
with open(path, "wb") as out:
shutil.copyfileobj(src, out)
os.chmod(path, os.stat(path).st_mode | stat.S_IEXEC)
needs = extras(script)
status = "ready to run" if not needs else "needs " + ", ".join(needs)
print(f"{script['id']:<24} ~{script['tokens_saved_per_call']} tokens/call {status}")
print("kits:", [b["id"] for b in catalog["bundles"]])
On the current catalog that prints 13 scripts, eight of which are ready immediately (context-saver.py, context-filter.py, session-handoff.py, context-compressor.py, loop-buster.py, prompt-minify.py, session-resume.py, lean-context.py) and the rest labelled with the one or two libraries they want. Wire the same loop into a scheduled job and your agent can refresh its own helpers whenever the catalog changes. If you want everything at once instead, skip the loop and pull both kits from step 3.
GET /api/shop/items — always public; use it as a health check for the download surface.GET /api/shop/download/{item} — 200 with the file, or 404 {"error":"Unknown item: X"} when the id is not in the catalog. Never guess filenames; always read them from scripts[].id.application/octet-stream should branch on content type.{"free": true, ...} rather than charging — old integrations fail safe.| Surface | Cost | Key required |
|---|---|---|
| Blueprint scripts and kit ZIPs | Free | No |
GET /api/shop/items catalog | Free | No |
| Hosted REST/MCP tools (screenshot, transcription, background removal, hosted image/video generation, browser sessions, and more) | Free daily allowances, then usage credits | Yes for programmatic use |
| Optional credit packs for hosted usage | Paid via Stripe Checkout | Agent key for the agent-initiated flow |
Blueprints stay free; tips in the browser are optional and never unlock anything. If you only ever download scripts and run them locally, you can use this part of the product forever without creating an account. See the current plan details on pricing if you want the hosted side.
Two follow-ups worth doing while you are here. First, set up Easy Mode for a local model so a 3B–8B model can call these Blueprints as tools instead of guessing at shell strings. Second, read how tool calling was made reliable for small models — persistent task memory, bounded retries, and loop prevention — because that is the layer that decides whether your agent actually reaches for context-compressor.py instead of reasoning through the same job at 20x the token cost.
Free downloads, no account required — or run the hosted tools in the browser when you would rather not install anything.
Open the Blueprint library