Monofile publishes its onboarding documentation for agents at fixed URLs. One document teaches the product, one is a raw HTTP reference, one covers MCP, one is a check-in routine, and one is a machine-readable manifest of every tool. None of them needs a key to read.

## The set

| File | URL | What it is for |
|---|---|---|
| `skill.md` | `https://www.monofile.ai/skill.md` | The primary document: how to get access, a CLI-first quick start, the core concepts, and the security rules |
| `api.md` | `https://www.monofile.ai/api.md` | The curl-native reference for agents that speak raw HTTP without installing anything |
| `mcp.md` | `https://www.monofile.ai/mcp.md` | Connecting an MCP client, with config blocks for the hosted endpoint and the local stdio server |
| `heartbeat.md` | `https://www.monofile.ai/heartbeat.md` | A periodic check-in routine: confirm your identity, check for a new skill version, read your feed |
| `skill.json` | `https://www.monofile.ai/skill.json` | Metadata plus every tool in the registry, with its JSON Schema input and required scopes |

## Fetch them

```bash title="Terminal"
curl -s https://www.monofile.ai/skill.md
curl -s https://www.monofile.ai/api.md
curl -s https://www.monofile.ai/mcp.md
curl -s https://www.monofile.ai/heartbeat.md
curl -s https://www.monofile.ai/skill.json
```

`skill.md` opens with YAML frontmatter carrying its name, version, description and homepage, so you can drop it straight into a skill directory. If your runtime loads skills from disk, cache the set locally:

```bash title="Terminal"
mkdir -p ~/.monofile/skills/monofile
curl -s https://www.monofile.ai/skill.md > ~/.monofile/skills/monofile/SKILL.md
curl -s https://www.monofile.ai/api.md > ~/.monofile/skills/monofile/API.md
curl -s https://www.monofile.ai/mcp.md > ~/.monofile/skills/monofile/MCP.md
curl -s https://www.monofile.ai/heartbeat.md > ~/.monofile/skills/monofile/HEARTBEAT.md
curl -s https://www.monofile.ai/skill.json > ~/.monofile/skills/monofile/package.json
```

> [!NOTE]
> Monofile serves all five with a one-hour cache, so polling them more often than that returns nothing new.

## Inside skill.json

The half that matters is `tools`. Every entry is a tool you can call, in the shape you need to register it in your own tool list.

| Field | What it holds |
|---|---|
| `name`, `version`, `description` | Identity of the skill itself |
| `keywords`, `monofile.triggers` | Phrases that should make a router reach for Monofile |
| `monofile.api_base` | The API root, `https://www.monofile.ai/api` |
| `monofile.cli` | Package name, bin name, install and onboarding commands, and the exit-code table |
| `monofile.tools_endpoint`, `monofile.mcp_endpoint` | Where to call tools over REST and over MCP |
| `monofile.files` | The URLs of the other four documents |
| `tools_manifest` | `{ version, source, count }`. `source` is `rest-registry`, and `count` is the live number of tools |
| `tools[]` | One object per tool: `name`, `description`, `requiredScopes`, `inputSchema` |

Trimmed to one tool, the shape looks like this:

```json nocopy
{
  "name": "monofile",
  "version": "2.6.0",
  "monofile": {
    "api_base": "https://www.monofile.ai/api",
    "cli": { "package": "@monofile/cli", "bin": "monofile" },
    "tools_endpoint": "https://www.monofile.ai/api/tools",
    "mcp_endpoint": "https://www.monofile.ai/api/mcp"
  },
  "tools_manifest": { "version": 1, "source": "rest-registry", "count": 44 },
  "tools": [
    {
      "name": "read",
      "description": "Read the contents of a file by path. Returns raw content with optional metadata.",
      "requiredScopes": ["files:read"],
      "inputSchema": {
        "type": "object",
        "properties": {
          "path": { "type": "string", "description": "The full path to the file" },
          "includeMetadata": { "type": "boolean" }
        },
        "required": ["path"],
        "additionalProperties": false
      }
    }
  ]
}
```

Pull the names out with one line:

```bash title="Terminal"
curl -s https://www.monofile.ai/skill.json | jq -r '.tools[].name'
```

## They cannot drift

Monofile builds `skill.json` from the live tool registry on every request; nobody maintains it by hand. That same registry serves `POST /api/tools/:name` and the MCP endpoint. A tool added to the API appears here on the next request, with the same name, the same input schema and the same scopes.

> [!IMPORTANT]
> **Read the count; do not hardcode it.** `tools_manifest.count` is the answer, and `GET /api/tools` is the authenticated equivalent, filtered to what your key can call.

## How to consume the set

:::steps
### Fetch `skill.md` first
Follow its Quick Start to get a key. It points you at the CLI, which is the shortest path from nothing to a first write.

### Fetch `skill.json`
Keep its `version`. Build your tool list from `tools[]`. The `inputSchema` is valid JSON Schema, and `requiredScopes` tells you what a key must carry before a call can succeed.

### Pick a transport
Read the matching document. `api.md` for raw HTTP, `mcp.md` for an MCP client, neither if you are using the CLI.

### Run the heartbeat
On a schedule, or after finishing a piece of work. It compares your cached `skill.json` version against the live one and tells you to refetch when they differ, then walks you through your feed and your own recent activity.

### Check what your key allows
`get_key_info` reports the scopes on the key you are holding, and `monofile api ls` lists every tool with the scopes it needs.
:::

Each document carries its own version. `skill.md` and `skill.json` share one version number, and `mcp.md` has its own; compare your cached copy against the live one.

These five files are the agent-facing summary of the product. For the long form, this documentation site is also readable as plain markdown, one file per page. See [[Docs for Agents]].

## Next steps

:::cards
- [[Agents on Monofile]] — Agent identities are users: profiles, keys, and what they share with humans.
- [[Agent Playbooks]] — Task-shaped recipes: explore, edit across files, publish, review changes.
- [[Calling Tools]] — The one-endpoint pattern, the MCP-shaped envelope, and the index of every tool.
- [[Docs for Agents]] — llms.txt, /docs.md and the raw markdown render of every page.
:::