---
name: set-agent-driven-development
description: Set's public AGENTS.md and llms.txt, the guide to the whole system. Read first when building a game or a simulation with set.world. It gives the build path from one seed to a running simulation (cast, state, orbs, equipment, combat, rewards, replay), how orbs bridge a game's own economy to Set, the map of every data endpoint, the table of contents of every skill with the API calls and schemas each one owns, how to add the Anima System's models and combat rules, and the terms of use.
license: "Free to use when obtained from set.world, commercially too (the API, what it returns and the skills). Its models, animations and textures, Anima included, are CC BY 4.0: free to use with attribution to Jimmy Lee (j@internet.dev). The source code of Set is © Jimmy Lee under CC BY-NC 4.0 and its commercial use needs a paid waiver."
metadata:
  version: "0.15.3"
  title: AGENTS.md
---

# AGENTS.md

> You are an agent building a simulation with Set: a game, a battle, a dungeon run, a world of NPCs. Set gives you seeded characters and items, their grades and prices, reference tables, in-world text, 3D models and two complete combat rule sets. This file is the guide to the whole system: the same document is served as `AGENTS.md` and as `llms.txt`. It gives the order to build in and the table of contents of everything Set documents. Each line links one skill: a plain-text page with the calls to make, the exact schema of what comes back and a full example.

**Two ways in, no key or account:** call `https://set.world/api` over HTTP, or add `https://set.world/mcp` to any Model Context Protocol client, which reaches the same endpoints and every skill through its tools (`set_api`, `set_skill` and `derive_seed`; see [Install, MCP and versions](#install-mcp-and-versions)).

## What you build with

Set comes in three parts. Each reads only the parts before it, so you can take the first alone, the first two, or all three.

| Part | What it is | Runs | Required |
| --- | --- | --- | --- |
| **1. Set** (the API and its references) | Stateless HTTP `GET` endpoints at `https://set.world/api`. No key, no account. They generate characters and items from a seed, grade them and price them in one currency, orbs. The tables behind them (items, materials, stats, talents, classes, traits, effects) and the formulas are served as JSON or CSV | On Set's server | Yes |
| **2. Anima System** (game rules) | Set's own reading of what a character and its equipment do in a fight: health and stamina, what each material weighs and protects, what each held item's weight, reach, tempo and range are, what every prefix, suffix and item quality gives, two combat modes (Dungeon mode, turn-based with everyone adjacent, and scene-based), and the stratagems that decide what each Anima does in a scene. It is arithmetic on API responses with no renderer in it | In your code, in any engine or on a server | Optional: reuse it, change it or replace it |
| **3. Three.js examples** (models, motion, scenes) | The demos on `https://set.world`, built on parts 1 and 2: one rigged body, a model for every item, motion clips, and the scenes that put them together, drawn with Three.js in a browser. The models and clips download as GLB and load in any engine | In the browser | Optional: copy from them or build your own |
| **Your simulation** | Everything that changes over time: health, positions, inventories, wallets, levels, saves | Wherever you run it | Yours. Set stores none of it |

Set generates, grades and prices. The Anima System says what those numbers do in a fight. The examples show both running. Your simulation chooses combat, keeps state and progresses. If a skill says a thing is yours to decide, no endpoint decides it.

**Set.World is a service first, and it is not open source.** The hosted API, everything it returns and everything it lets you download are free to build on, commercial games included; the 3D models, animations and textures ask only for a credit to Jimmy Lee (j@internet.dev). The source code may be read, and reused non-commercially with credit, but a static version for a commercial game (Set's own code running inside your game or on your server, with no call to set.world) needs a paid waiver from the author. Most games never need one. The terms are at the end of this file.

## Build a simulation, step by step

Each step names the call, the schema you receive, the skill that owns both, and what your simulation keeps.

| Step | You do | Call | You get | Skill | You keep |
| ---: | --- | --- | --- | --- | --- |
| 1 | Connect and discover | `GET /api`, `GET /api/spec` | `Spec` | [API connection](https://set.world/skills/api-connection) | The `contentVersion` you build against |
| 2 | Load the vocabulary once | `GET /api/tables`, `/api/stats`, `/api/slots` | `CatalogResponse`, `StatsResponse`, `SlotsResponse` | [Item properties](https://set.world/skills/item-properties), [Stats](https://set.world/skills/character-stats), [Slots](https://set.world/skills/equipment-slots) | A cache per `contentVersion` |
| 3 | Cast the actors | `GET /api/roll/character?seed=` once per actor | `Character` | [Rolling a character](https://set.world/skills/rolling-a-character) | The whole response, unedited |
| 4 | Turn one seed into many | `deriveSeed(seed, i)` in your code | `Roster` | [Rolling a group](https://set.world/skills/rolling-a-group) | The base seed and each member's seed |
| 5 | Give each actor state | None | `GameCharacter` | [Rolling a character](https://set.world/skills/rolling-a-character) | Health, stamina, level, wallet, inventory |
| 6 | Spend orbs for better outcomes | `GET /api/craft?orbs=`, `/api/craft?tier=`, `/api/boost/cost` | `LotteryCraft`, `GuaranteeCraft`, `BoostCost` | [Rolling an item](https://set.world/skills/rolling-an-item), [Crafting an item](https://set.world/skills/crafting-an-item) | The orb balance: orbs are your currency |
| 7 | Decide what equipment does | `GET /api/modifiers?rolls=`, or AnimaSystem's rules | `ModifiersResponse`, or `AnimaCharacter` and `ItemAttributeReceipt` | [Calculations](https://set.world/skills/calculations), or [Derived stats](https://set.world/skills/anima-derived-stats) and [Item attributes](https://set.world/skills/anima-item-attributes) | Your modifiers beside the birth |
| 8 | Choose how they fight | One of the three options below | `TurnEvent`, `HitEvent` or `DamageResponse` | [Derived combat](https://set.world/skills/anima-derived-combat), [Combat](https://set.world/skills/basic-lightweight-combat) | All combat state |
| 9 | Run the loop | None: no request per hit | `Scene`, `StratagemDocument` | [Scenes](https://set.world/skills/anima-scenes), [Stratagems](https://set.world/skills/anima-stratagems) | Your clock, your rule versions and each actor's stratagem |
| 10 | Reward and recycle | `GET /api/drop`, `/api/salvage` | `DropResponse`, `SalvageResponse` | [Crafting an item](https://set.world/skills/crafting-an-item) | An orb ledger and the items |
| 11 | Give it a voice | `GET /api/classes`, `/api/talents`, `/api/effects` | Rows with `flavor` or `description` | [Text flavor](https://set.world/skills/text-flavor) | Your codex and your own text |
| 12 | Save and replay | `GET /roll/character?seed=` for a permanent sheet | A birth certificate URL | [Rolling a character](https://set.world/skills/rolling-a-character) | Seeds, `contentVersion` and full responses |

### Step 6: orbs are your currency

Orbs are the one unit Set prices in, and Set holds none of them. There is no wallet, no balance and no rule for how an orb is earned: your simulation tracks the number, checks it before a call and subtracts the spend after. More orbs buy better outcomes (more candidates, higher grades, exact grades, higher stats), at prices that are the same for every game.

That makes orbs a bridge. A game keeps whatever economy it likes (wood, stone, ore, gold, time, reputation), sets its own rate from each resource to orbs, and converts at the moment of the craft. [Crafting an item](https://set.world/skills/crafting-an-item) owns the prices, the odds and a worked bridge; [Rolling an item](https://set.world/skills/rolling-an-item), [Rolling a character](https://set.world/skills/rolling-a-character) and [Rolling a group](https://set.world/skills/rolling-a-group) show what orbs buy for one item, one character and a whole roster.

### Step 8: three ways to fight

| Option | Led by | Range and position | Where it runs |
| --- | --- | --- | --- |
| **Combat API** | Your code calls it per attack or per window | None | Set's server. Experimental and optional |
| **Dungeon mode** (turn-based) | Rounds and initiative: who acts next, and how many attacks a turn holds | Do not exist: every combatant stands adjacent | Your client |
| **Scene-based** | Space: reach, range, contact, weight, tempo | Decide everything | Your client |

Dungeon mode and scene-based combat read the same Anima System: weapons, armor, materials, prefixes, suffixes and status effects count in both. Dungeon mode plays them in rounds with every combatant adjacent, so a party RPG, a roguelike or a dungeon crawler needs no real-time timing and no range management; scene-based combat adds positions and every spatial factor. [Derived combat](https://set.world/skills/anima-derived-combat) keeps them apart and gives the rules and state schema of each. Set's home page shows one of each: **Adventure mode with party** is Dungeon mode and **Battle with armies** is scene-based. Or write your own rules on the attributes: that is always allowed, and the function below does exactly that.

### A whole simulation in one function

Two parties of 4, a simple initiative fight of the function's own on the attributes the API returned (the combat API's cost and recovery, no Anima System), then orbs for the kills and one craft. It uses steps 3, 4, 5, 6, 8, 10 and 12. For weapons, armor and effects, play the fight in Dungeon mode instead (step 8).

```js
const API = 'https://set.world';
const STATS = ['strength', 'dexterity', 'intelligence', 'wisdom', 'agility', 'vitality', 'perception', 'resolve', 'luck'];
const PARTY = 4;
const deriveSeed = (seed, i) => ((seed >>> 0) + Math.imul(i, 0x9E3779B9)) >>> 0;
const get = async (path) => {
  const response = await fetch(API + path), body = await response.json();
  if (!response.ok) throw new Error(body.error.message);
  return body;
};

async function simulate(seed, random = Math.random) {        // pass your own seeded generator to replay the fight
  const cast = [];
  for (let i = 0; i < 2 * PARTY; i++) {                       // one request at a time
    const birth = await get(`/api/roll/character?seed=${deriveSeed(seed, i)}`);
    cast.push({ id: `actor-${i}`, side: i < PARTY ? 'party' : 'enemy', birth, health: Math.floor(birth.attributes.maxHealth), stamina: Math.floor(birth.attributes.stamina), nextAt: 1000 / birth.attributes.initiative });
  }

  const living = (side) => cast.filter((actor) => actor.side === side && actor.health > 0);
  let clock = 0;
  while (living('party').length && living('enemy').length) {
    const actor = cast.filter((candidate) => candidate.health > 0).sort((a, b) => a.nextAt - b.nextAt)[0];   // initiative leads
    const elapsed = actor.nextAt - clock;
    clock = actor.nextAt;
    actor.nextAt += 1000 / actor.birth.attributes.initiative;
    for (const other of cast) if (other.health > 0) other.stamina = Math.min(Math.floor(other.birth.attributes.stamina), other.stamina + 10 * elapsed / 1000);
    if (actor.stamina < 20) continue;                                // rest
    actor.stamina -= 20;
    const target = living(actor.side === 'party' ? 'enemy' : 'party')[0], attack = actor.birth.attributes, defence = target.birth.attributes;
    if (random() < defence.dodgeRate * (1 - attack.clarity)) continue;   // dodged
    const critical = random() < attack.criticalHitChance;
    target.health -= Math.min(target.health, Math.max(1, Math.floor(attack.physicalDamage * (1 - defence.physicalDamageReduction) * (1 - defence.globalResistance) * (critical ? 2 : 1))));
  }

  let orbs = 0;
  for (const fallen of cast.filter((actor) => actor.side === 'enemy' && actor.health <= 0)) {
    const stats = STATS.map((stat) => fallen.birth.finalStats[stat]).join('-');
    orbs += (await get(`/api/drop?stats=${stats}&class=trash&seed=${fallen.birth.seed}`)).orbs;
  }
  const craft = orbs ? await get(`/api/craft?orbs=${orbs}&seed=${deriveSeed(seed, 1000)}`) : null;
  return { seed, contentVersion: cast[0].birth.contentVersion, winner: living('party').length ? 'party' : 'enemy', cast, orbs, crafted: craft ? craft.item : null };
}
```

Everything the function returns is enough to show the result and to roll the same cast again at the same `contentVersion`.

### Add the Anima System

To make the same simulation visible and spatial, add parts 2 and 3 piece by piece. None of it changes an API response. Steps 1 to 3 are assets from the Three.js examples and work in any engine; steps 4 to 6 are the Anima System's rules and need no renderer; step 7 puts them together.

1. **A body for each actor**: one rigged model, coloured by the character's advantages and disadvantages. [Character models](https://set.world/skills/anima-character-models).
2. **A model for each item**, in its rolled material, held or worn by rule. [Item models](https://set.world/skills/anima-item-models).
3. **Motion**: downloadable clips and the timing of every weapon action. [Animations](https://set.world/skills/anima-animations).
4. **Equipment that matters**: weight, protection, ward and hit power from each item's material ([Derived stats](https://set.world/skills/anima-derived-stats)), and what each prefix and suffix gives at its item's quality: stats, speed, health, protection, effects on hit, buffs and the rest ([Item attributes](https://set.world/skills/anima-item-attributes)).
5. **Combat with equipment**: Dungeon mode for turns with everyone adjacent, or the scene-based rules with positions. [Derived combat](https://set.world/skills/anima-derived-combat).
6. **Behaviour**: a stratagem per actor, an ordered list of conditions and acts (attack, kite, lunge, guard, protect, run…) that decides what it does whenever it rethinks, in a file format any game can read. [Stratagems](https://set.world/skills/anima-stratagems).
7. **The scene itself**: queueing requests, clocks, teams, movement, bodies, cleanup. [Scenes](https://set.world/skills/anima-scenes). How a scene fits its resolution, antialiasing, shadows, floor and detail to every screen, the same on every device: [Viewport performance](https://set.world/skills/anima-viewport-performance). How it loads everything at once without loading anything twice, putting what is on screen first and never leaving a loader that does not finish: [Orchestration](https://set.world/skills/anima-orchestration).

### Rebuild one of Set's own pages

Every column of `https://set.world` and each of its showcase pages (listed below) is one of these skills running live. The columns are worked examples: **Roll an item** ([Rolling an item](https://set.world/skills/rolling-an-item)), **Roll a character** ([Rolling a character](https://set.world/skills/rolling-a-character)), **Roll a party** ([Rolling a group](https://set.world/skills/rolling-a-group)), **Adventure mode with party** (Dungeon mode, the turn-based half of [Derived combat](https://set.world/skills/anima-derived-combat)), **Craft an item using orbs** ([Crafting an item](https://set.world/skills/crafting-an-item)) and **Battle with armies** (its scene-based half). [Scenes](https://set.world/skills/anima-scenes) has a build sheet for each one, says how faithful a replica can be, and maps every mechanic to its skill, its section of the math reference and its source file.

## All of Set's data is an endpoint

Nothing has to be copied out of a document. Every table in the lists below names its endpoint; each answers JSON, most answer CSV with `format=csv`, and the list endpoints take filters (`name`, `id`, `q` and their own), so a game can ask for one row ([API connection](https://set.world/skills/api-connection)). The numbers with no endpoint are the Anima System's own, because the API never reads its local game layer: the material readings are printed in full in [Derived stats](https://set.world/skills/anima-derived-stats), the held items' level-1 readings in [Derived combat](https://set.world/skills/anima-derived-combat), and what every item prefix and suffix grants is JSON inside the page `https://set.world/anima-prefixes-suffixes-effects` ([Item attributes](https://set.world/skills/anima-item-attributes) says how to read it).

## The table of contents

This is the sidebar of `https://set.world`, in the same order: the showcase pages (the sidebar opens `https://set.world/anima-scene` from its red **Battle!** button above them), then the skills in three groups. Every skill is at `https://set.world/skills/<slug>`, where the slug is its frontmatter `name` without the `set-` prefix.

### Showcase pages

Pages where a person can watch what the skills describe; each is a live build of the skills in its Read column, and those skills are what to build from. Most need a browser to show more than their text: each build sheet in [Scenes](https://set.world/skills/anima-scenes) says what a plain fetch of its page returns. The API never needs them.

| Page | Shows | Read |
| --- | --- | --- |
| https://set.world/anima-object-models | Every item on Anima and alone, in any material, with a model download | [Item models](https://set.world/skills/anima-item-models) |
| https://set.world/anima | The base model in each of its motions, with model and motion downloads | [Character models](https://set.world/skills/anima-character-models), [Animations](https://set.world/skills/anima-animations) |
| https://set.world/anima-all-weapons | Every mainhand held by its own Anima | [Derived combat](https://set.world/skills/anima-derived-combat), [Animations](https://set.world/skills/anima-animations) |
| https://set.world/anima-scene | Generated characters on a mat, and two teams of 16, each built by totally-random, designed by a model from random births (places, every item, growth and a stratagem for each Anima) or imported from a battle file saved on `/anima-battle`, fighting when you press Start | [Scenes](https://set.world/skills/anima-scenes), [Stratagems](https://set.world/skills/anima-stratagems), [Derived combat](https://set.world/skills/anima-derived-combat) |
| https://set.world/anima-stratagem | Two Animas outfitted side by side, then a duel between them | [Stratagems](https://set.world/skills/anima-stratagems) |
| https://set.world/anima-battle | Two teams of 16 on one battleground, each Anima outfitted and given its own stratagem, saved and loaded as one battle file, whose teams also play on `/anima-scene` | [Stratagems](https://set.world/skills/anima-stratagems), [Scenes](https://set.world/skills/anima-scenes) |
| https://set.world/anima-battle-effects | Every battle effect on its own pair of Animas (64 pairs), one striking the other once a round: each combat outcome the scenes play, THORNS! and CLEANSE! among them, made certain with an item that causes it, and each status effect taking hold on every hit or, for a buff, from the start | [Derived combat](https://set.world/skills/anima-derived-combat), [Status effects](https://set.world/skills/status-effects) |
| https://set.world/anima-analysis | Every held item read by the Anima System at any level | [Derived stats](https://set.world/skills/anima-derived-stats), [Derived combat](https://set.world/skills/anima-derived-combat) |
| https://set.world/anima-prefixes-suffixes-effects | What every item prefix, suffix and status effect does in the Anima System, at every item quality | [Item attributes](https://set.world/skills/anima-item-attributes) |
| https://set.world/anima-talents | Every talent (288), beside an Anima dressed in any items; what each one does is a work in progress | [Talents](https://set.world/skills/character-talents) |
| https://set.world/anima-class-talents | Every class (155), beside an Anima that can hold its mainhand; each class's own talent is a work in progress | [Classes](https://set.world/skills/character-classes) |
| https://set.world/anima-model-teams | Each model's designed team of 16, built from the same births, at practice: every Anima attacking its own timber statue, beside the designer's own account of why it built that team; `?model=<name>` opens one designer's team | [Scenes](https://set.world/skills/anima-scenes), [Derived combat](https://set.world/skills/anima-derived-combat) |

### Set: the API

| Skill | Use it to | Endpoints | Schemas it defines |
| --- | --- | --- | --- |
| [API connection](https://set.world/skills/api-connection) | Reach the API, read errors, pass seeds, keep `contentVersion`, get CSV, filter a table, connect over MCP | `/api`, `/api/spec`, `/mcp` (`/api/mcp`) | `Spec`, `ErrorEnvelope`, `Replay`, the MCP tools, `SkillEntry` |
| [Rolling an item](https://set.world/skills/rolling-an-item) | Generate one item or a full equipment set; spend orbs for a better one; share and appraise it | `/api/roll/item`, `/api/roll/set` | `Item`, `RollItemResponse`, `Equipment`, `RollSetResponse`, `SlotBreakdown`, `InventoryItem` |
| [Rolling a character](https://set.world/skills/rolling-a-character) | Generate a complete character; read its sheet; spend orbs on its gear and stats; save a birth certificate | `/api/roll/character`, `/roll/character` | `Character`, `GameCharacter` |
| [Rolling a group](https://set.world/skills/rolling-a-group) | Turn one seed into a party, an army or a wave; budget orbs across it | `deriveSeed` | `Roster` |
| [Crafting an item](https://set.world/skills/crafting-an-item) | Run the orb economy: orbs as the bridge from your own resources, guarantees, the lottery, salvage, drops, stat boosts | `/api/craft`, `/api/craft/cost`, `/api/salvage`, `/api/drop`, `/api/drop/classes`, `/api/boost/cost` | `CraftCost`, `GuaranteeCraft`, `LotteryCraft`, `SalvageResponse`, `DropResponse`, `DropClasses`, `BoostCost`, `OrbLedgerEntry` |

### Anima System: models and Set's own game rules

[Derived stats](https://set.world/skills/anima-derived-stats), [Item attributes](https://set.world/skills/anima-item-attributes), [Derived combat](https://set.world/skills/anima-derived-combat) and [Stratagems](https://set.world/skills/anima-stratagems) are part 2, the rules: every formula and table needed to implement them in your own code. [Character models](https://set.world/skills/anima-character-models), [Item models](https://set.world/skills/anima-item-models), [Animations](https://set.world/skills/anima-animations) and [Scenes](https://set.world/skills/anima-scenes) are part 3, the Three.js examples: the downloads, and a build sheet for every demo. Every scene runs on two systems: [Viewport performance](https://set.world/skills/anima-viewport-performance) decides how much it draws, and [Orchestration](https://set.world/skills/anima-orchestration) decides in what order everything is loaded. [Randomness](https://set.world/skills/anima-randomness) says, for everything Set gives you, whether it is fixed, seeded or fresh.

| Skill | Use it to | You get | Schemas it defines |
| --- | --- | --- | --- |
| [Character models](https://set.world/skills/anima-character-models) | Give a character a rigged 3D body and its trait colour | `anima.glb`, the published metadata file | `AnimaMetadata`, `CharacterBody` |
| [Item models](https://set.world/skills/anima-item-models) | Get the model of any held or worn item, and the rules for holding and wearing | A GLB per item | `ItemModelRef`, `ItemExportExtras`, `ItemAsset` |
| [Derived stats](https://set.world/skills/anima-derived-stats) | Decide what materials weigh, how armor protects and how hard a weapon hits | Material tables and formulas | `AnimaSystemReceipt`, `AnimaCharacter` |
| [Derived combat](https://set.world/skills/anima-derived-combat) | Fight in Dungeon mode (rounds and initiative, everyone adjacent; Adventure mode with party) or scene-based (all spatial factors; Battle with armies) | Two rule sets on one Anima System, the attack budget per turn and the reading of every held item | `DungeonHand`, `DungeonCombatant`, `DungeonEncounter`, `DungeonEvent`, `DungeonTurn`, `CombatantState`, `HitEvent` |
| [Item attributes](https://set.world/skills/anima-item-attributes) | Decide what every prefix and suffix does at each item quality, how the same effect stacks over items, and how chances meet effect resistance | A price list, every word's grants and the receipt of a character's words | `ItemAttributeReceipt`, `ItemAttributeItem`, `ItemAttributeTotal` |
| [Scenes](https://set.world/skills/anima-scenes) | Compose a scene from API responses, or rebuild any of Set's own pages and home columns | A build sheet per scene and the map of every mechanic | `SceneActor`, `Scene` |
| [Viewport performance](https://set.world/skills/anima-viewport-performance) | Render a scene at the resolution, antialiasing, shadow and floor detail each screen can show, the same on a phone and a desktop | The AnimaViewportPerformanceSystem: its inputs, its plan for a frame, a forecast for every common canvas and zoom | `ViewportInputs`, `ViewportPlan` |
| [Orchestration](https://set.world/skills/anima-orchestration) | Load a scene's requests, models, armor, motions, shaders and portraits in parallel: nothing twice, what is on screen first, no loader that never ends | The job orchestrator: jobs shared by key, stalls, priorities, concurrency slots, barriers and idle, and the keys and priorities Set uses | `Job`, `JobOptions`, `JobPriority`, `JobRecord` |
| [Randomness](https://set.world/skills/anima-randomness) | Get real randomness or a replayable seed on purpose, and know which of Set's values are fixed, seeded or fresh | AnimaSystemRandomness: the three kinds, how a fresh number is drawn, every seeded stream Set runs, and what is computed once when Set is built | `Randomness`, `Drawn` |
| [Stratagems](https://set.world/skills/anima-stratagems) | Decide what each Anima does in scene-based combat: rules of a condition and an act, read in order; write, import and export them | The universal stratagem format, every condition and act, and the default | `StratagemDocument`, `StratagemRule` |
| [Animations](https://set.world/skills/anima-animations) | Get motion clips and the timing of weapon actions | A GLB per clip | `ClipMotion`, `AnimationClipAsset` |

### References

One skill per table or formula set. Each gives the endpoint for the full data and the schema of a row.

| Skill | Subject | Endpoint | Schemas it defines |
| --- | --- | --- | --- |
| [Item properties](https://set.world/skills/item-properties) | The 19 item tables, roll vectors and indexes; the whole catalog in one call | `/api/tables`, `/api/tables/:table` | `Table`, `TableEntry`, `CatalogResponse`, `TableResponse` |
| [Prefixes](https://set.world/skills/item-prefixes) | The prefix table | `/api/tables/prefix` | `PrefixEffect` (your game's) |
| [Suffixes](https://set.world/skills/item-suffixes) | The suffix table | `/api/tables/suffix` | `SuffixEffect` (your game's) |
| [Materials](https://set.world/skills/item-materials) | Materials and the grades F to S | `/api/tables/material-wearables`, `/api/tables/material-tools`, `/api/rarity/tiers` | `Grade`, `Material`, `GradeTiersResponse` |
| [Slots](https://set.world/skills/equipment-slots) | The 13 slots and 15 equipped items | `/api/slots` | `Slot`, `SlotsResponse`, `Loadout` |
| [Stats](https://set.world/skills/character-stats) | The 9 base stats | `/api/stats` | `StatName`, `StatBlock`, `StatsResponse` |
| [Talents](https://set.world/skills/character-talents) | The 288 character talents | `/api/talents` | `CharacterTalent`, `TalentsResponse` |
| [Classes](https://set.world/skills/character-classes) | The 155 classes | `/api/classes` | `CharacterClass`, `ClassesResponse` |
| [Advantages](https://set.world/skills/character-advantages) | The 144 advantages | `/api/advantages` | `Advantage`, `AdvantagesResponse` |
| [Disadvantages](https://set.world/skills/character-disadvantages) | The 144 disadvantages | `/api/disadvantages` | `Disadvantage`, `DisadvantagesResponse` |
| [Effects](https://set.world/skills/status-effects) | The 49 status effects | `/api/effects` | `StatusEffect`, `EffectsResponse`, `EffectRule` |
| [Text flavor](https://set.world/skills/text-flavor) | All of the in-world prose: talent flavor, class descriptions, effect descriptions, and the voice they are written in | `/api/talents`, `/api/classes`, `/api/effects` | `CodexEntry` |
| [Calculations](https://set.world/skills/calculations) | Derived attributes, power rating, trait impacts, rarity, item budgets | `/api/attributes`, `/api/attributes/spec`, `/api/power`, `/api/traits/impact`, `/api/traits/impacts`, `/api/rarity`, `/api/modifiers`, `/api/modifiers/spec` | `AttributesResponse`, `PowerResponse`, `TraitImpact`, `TraitImpactsResponse`, `RarityResponse`, `ModifiersResponse` |
| [Algorithms](https://set.world/skills/algorithms) | The full math reference, section by section, and the other hosted references | `/algorithms`, `/api/guides/:guide` | |
| [Combat](https://set.world/skills/basic-lightweight-combat) | The optional, experimental combat fallback | `/api/basic-lightweight-combat`, `/api/basic-lightweight-combat/spec` | `DamageResponse`, `InitiativeResponse` |

## How to read a skill

1. **One skill per task.** Find the task above and fetch that one skill. It owns its calls, its schemas and its rules.
2. **Follow links instead of guessing.** A fact is written in one skill only; every other skill links to it. A schema named in another skill is defined in the skill listed for it above.
3. **Trust the examples.** Examples, counts, prices, odds and rule stamps are computed by Set's own code when a skill is served, against the current tables (`contentVersion` `7.1bmmTgz1B0Y9UKhiu84STg`). The few values recorded by hand name the rule stamp they were recorded under, and anything chosen only for illustration says so.
4. **Read data from endpoints, not from prose.** Tables are served whole as JSON, or as CSV with `format=csv`. A skill shows the columns and a few rows.
5. **Keep what you are told to keep.** Every roll returns a `seed` and a `contentVersion`. Store them with the full response: old snapshots are not hosted.
6. **Name the part.** Grades, prices and attributes are Set's. Weight, protection, hit power, what prefixes and suffixes do, both combat modes and stratagems are the Anima System's, one reading among many. Models, motion and the look of a scene are the examples'. Label them so in anything you show.

## Install, MCP and versions

```sh
mkdir -p .claude/skills/set-rolling-an-item
curl -s https://set.world/skills/rolling-an-item/SKILL.md -o .claude/skills/set-rolling-an-item/SKILL.md
```

- Save a skill under its frontmatter `name`. Every skill answers at `https://set.world/skills/<slug>` and, for installing, `https://set.world/skills/<slug>/SKILL.md` (the endpoint `/api/skill/:slug`). This file is `/api/skill`, served at `https://set.world/AGENTS.md`, `https://set.world/llms.txt`, `https://set.world/llm.txt` and `https://set.world/skills`, and at `https://set.world/` to a request whose `Accept` header names `text/markdown`.
- To call Set through the Model Context Protocol, add `https://set.world/mcp` (protocol `2026-07-28`, `2025-11-25`, `2025-06-18`, `2025-03-26`, `2024-11-05`): the tools `set_api`, `set_skill` and `derive_seed`, and every skill as a resource and through the Skills extension (`skills/list`, `skills/get`). [API connection](https://set.world/skills/api-connection) has their inputs, limits and headers.
- Every skill carries one version, `metadata.version` in its frontmatter. It is Set's release version and is the same in every skill. **When it differs from the version in a copy you installed or remember, fetch the skills again.** Over MCP, the server's `serverInfo.version` (from `server/discover`, `initialize` or any result's `_meta`) is the same number.
- `contentVersion` on a response is different: it is the snapshot of the tables and rules that produced that response.
- Every rule stamp reads `set-world-<release>-<system>-<n>`, now `set-world-0-15-3-…`: Set's namespace, this release with dashes, then the rule. A stamp in it is a rule exactly as set.world ships it; the release part moves every release, the rule's own number only when the rule changes. Name the rules your own world changes or adds with your own prefix ([API connection](https://set.world/skills/api-connection), Rule stamps).

## Terms: free to use, not open source

Set is made by Jimmy Lee, Head of Design at Vmax.ai and Partner at Internet Development Studio Company (INTDEV, internet.dev). The terms differ by what you use:

- **Using set.world is always allowed.** Calling the API, and using anything it returns or lets you download (characters, items, table data, flavor text, these skills, 3D models, animations), is free for any purpose, including commercial games. No key, no fee, no waiver. This is all most games need.
- **Models, animations and textures need a credit.** Anima, every item model, every clip and the craft marble and cutting-mat textures are CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/): free for any purpose, commercial games too, as long as you credit **Jimmy Lee (j@internet.dev)** in your credits, documentation or store listing. Every downloaded model and clip carries that credit in its metadata ([Character models](https://set.world/skills/anima-character-models#credit-it)).
- **The source code is not open source.** Where you can see Set's source, it is © Jimmy Lee under CC BY-NC 4.0 (https://creativecommons.org/licenses/by-nc/4.0/), except vendored third-party code, which keeps its own notices: you may read it, and copy and adapt it non-commercially with credit. A static version for a commercial game, meaning Set's own code run, shipped or sold as part of your product, needs a paid waiver from the author: write to j@internet.dev.

So build your simulation on the hosted API and its downloads, and implement any rule or formula these skills describe in your own code. Do not copy Set's source files into a commercial product. Where a skill names a source path, it is for reading and for non-commercial reuse.