Generated worlds still need a parts bin
Polyfork is a low-poly 3D asset library built to be called, not browsed. Every asset states its real size in meters, its origin on the ground, its exact hex palette and its triangle count, and every kit publishes the contract its parts agree on: the grid they snap to and the knobs that have to match across a scene. An agent can lay out a street before it opens a single render, and the renders are there when it wants to check. Connect it in one command over MCP, or point any agent that can fetch a URL at the hosted guide.
Assembling a scene, not picking a model
Plan before you fetch
Sizes are real meters and origins sit on the ground. Grid kits state their grid_m, so positions are arithmetic rather than trial and error.
One scene, one look
A kit's usage names the knobs every part shares and the values curated per part. Set them once and 45 parts agree.
Stay inside the budget
Filter by max_triangles, then merge the static picks into one draw call with merge.mjs. Nothing here arrives at an unknown cost.
Three steps
Connect the catalog
One command if your tool speaks MCP: the asset tools appear in it and nobody pastes anything. Otherwise paste two lines pointing at the hosted guide, which teaches any agent that can fetch a URL the same catalog.
Add your key, it is free
The account and the key cost nothing, and everything free stays free. A key just lets the agent
know who it is working for: it sees what you already own instead of quoting you a
price for it, and the day you buy something the download works without editing a config
mid-build. Create one, then add it to the MCP connection above, or as
POLYFORK_KEY for the prompt.
Ask for what you want
Say "build a cozy medieval square" and the agent browses the catalog, compares hero renders, palettes and real-world sizes, then imports and composes the right models on its own.
Connect it (MCP)
The catalog is an MCP server, so the tools show up inside your assistant and nobody pastes documentation. It is one HTTP endpoint and no install, so any MCP client can reach it. Browsing needs no key.
claude mcp add --transport http polyfork https://polyfork.dev/mcp \ --header "Authorization: Bearer pf_YOUR_KEY"
export POLYFORK_KEY=pf_YOUR_KEY codex mcp add polyfork --url https://polyfork.dev/mcp \ --bearer-token-env-var POLYFORK_KEY
{
"mcpServers": {
"polyfork": {
"type": "http",
"url": "https://polyfork.dev/mcp",
"headers": {
"Authorization": "Bearer pf_YOUR_KEY"
}
}
}
}
{
"mcpServers": {
"polyfork": {
"type": "http",
"url": "https://polyfork.dev/mcp",
"headers": {
"Authorization": "Bearer pf_YOUR_KEY"
}
}
}
}
{
"servers": {
"polyfork": {
"type": "http",
"url": "https://polyfork.dev/mcp",
"headers": {
"Authorization": "Bearer pf_YOUR_KEY"
}
}
}
}
{
"mcpServers": {
"polyfork": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://polyfork.dev/mcp",
"--header", "Authorization: Bearer pf_YOUR_KEY"]
}
}
}
{
"mcpServers": {
"polyfork": {
"type": "http",
"url": "https://polyfork.dev/mcp",
"headers": {
"Authorization": "Bearer pf_YOUR_KEY"
}
}
}
}
Client config formats move around, so check your client's own MCP docs for where the
file lives. A few name the key differently: VS Code uses servers,
Zed uses context_servers. The
url is the same everywhere.
One key, two ways to hand it over. pf_YOUR_KEY is the
key itself: paste yours over it. POLYFORK_KEY is an environment
variable holding that same key, for the clients that prefer to read one rather than keep it
in a file. Codex does, and so does the pasted prompt below.
Worth adding the key. The account and the key are free, and everything free stays
free either way. What the key buys is an agent that knows who it is working for: it sees what
you already own instead of quoting you a price for it, who_am_i
answers instead of shrugging, and the day you buy something the download works without you
stopping to edit a config.
Sign in and make one without leaving this page. It lands in the snippet above, already
in place of pf_YOUR_KEY.
Or skip it entirely. Untick with my key and the snippet drops the header: browsing, every free asset and all eleven tools work with no account at all.
What it can and cannot do. Ten of the eleven tools only read: they search, fetch
metadata and compose preview URLs. The one that writes, report_need,
files a note about something missing. Nothing deletes, buys, or changes your account, and
there is no destructive call to guard against. Your key stays in the client config and is
never handed to the agent, so a paid download arrives as a link that is signed for one file
and expires in 15 minutes.
search_assets
Search the catalog, filtered by triangle budget, price or class.
get_asset
Everything about one asset: real size, palette, rig, renders, download URLs.
find_matching
What belongs in a scene with this one, spread across classes.
get_variant
Plain words to a ready createAsset() call, plus a GLB and a note on whether that file shows the variant.
preview_scene
Compose assets into a page your user can open and orbit.
list_kits
Sets built to one palette and one grid.
get_kit
Every published part of one kit, with the same detail get_asset gives, so you can compose a whole scene from one call…
get_terrain
AT WHAT HEIGHT DO I PLACE THIS, and where can I build. Every kit ships a procedural TERRAIN program for its own ground…
who_am_i
What this connection can do: key attached, what it owns, which downloads work.
get_help
How to use the server, by topic, when a tool did not behave as expected.
report_need
Report a gap: a missing asset, or a capability, output or explanation this server owes you.
Paste two lines (no MCP)
For agents that cannot speak MCP but can fetch a URL. You paste a pointer, the agent reads the guide itself. Claude Code · Cursor · Codex · anything that can fetch a URL
Read https://polyfork.dev/prompt.txt and follow it: it explains how to browse and use the Polyfork 3D asset catalog. My Polyfork API key is pf_YOUR_KEY. If you save it, put it in .env or another gitignored file, never in source or a commit.
Why a pointer, and not the whole thing. The guide lives at
/prompt.txt and is fetched at the start of
a session, so it teaches whatever the catalog does today. A prompt pasted into a project last
month goes on teaching last month's API, and nobody can reach it to fix that.
The key is optional here too. Untick with my key and the second line goes
away: browsing and every free asset still work. One difference from the MCP path, worth
knowing: a key on this line IS handed to the agent, because here the agent fetches the paid
file itself. The guide tells it to keep the key to .env or another
gitignored file and out of source, commits and logs, and it will read
POLYFORK_KEY from its environment instead if you would rather not
put a key in a chat at all.
What your agent can see
Wondering what it costs to build these at runtime? The measured numbers are here.
Real dimensions
Size in meters, origin on the ground, so scenes assemble without guesswork.
Exact palettes
The hex colors of every asset, for coherent scenes across picks.
Preview renders
Hero and turnaround PNGs the agent can actually look at before choosing.
Rig and hinge data
Every animatable part with its type, axis and range, pivots already at the hinge or axle. Characters carry a standard humanoid skeleton that stock animations retarget onto.
Inverse kinematics
Some models solve rather than pose: legs that find your ground and stay planted while the body moves, or a rooted boom whose tip you aim. The measured gait/arm block ships in the API, and walk.mjs drives it in three lines. Filter with ik=1.
Performance stats
Triangle counts and draw calls, plus a CDN merge helper that collapses whole static scenes into a single draw call.
License clarity
Commercial use, no attribution, stated on every payload.