Skip to main content

What is install.md?

install.md is a proposal to standardize software installation using task-oriented markdown files that AI agents execute autonomously. When you ask an AI agent to install software today, you have no idea what context it receives—it might search the web, find outdated docs, or hallucinate commands. With install.md, developers define exactly what instructions the agent gets. install.md files are direct commands, not just documentation. The format is structured to trigger immediate autonomous execution.
# Pipe directly to an AI agent
curl -fsSL https://example.com/install.md | claude

# Or paste into any coding assistant like Claude Code or Cursor
This works for any software—developer tools, CLIs, desktop applications, system utilities, or complex multi-component setups.

Why install.md?

Verifiable

Developers and users know exactly what context the AI agent receives. Test it yourself, iterate on it, trust it.

Adaptable

AI agents adapt instructions to your environment—detecting your OS, package manager, project structure, and more.

Verifies success

install.md files include success criteria so the agent knows when installation is complete and working.

Human-readable

See exactly what will happen before it happens. Modify the instructions yourself if needed.

Advantages

For developers shipping software

You define installation once and it adapts to every environment. Encode edge cases and troubleshooting knowledge without cluttering your main documentation. You control exactly what context the LLM receives, and installation instructions for agents can differ from your public docs. You’re writing directly to your actual users—which increasingly are agents.

For users installing software

A single command installs your software, or paste the file into any LLM. The instructions are human-readable so you can review every step before it executes. The LLM adapts to your specific environment automatically. Because the file is fetched at runtime, you never deal with stale data or depend on the LLM’s outdated knowledge.

For agents

Installation instructions live in a predictable location that’s easy to find. The structured format provides clear success criteria for determining when installation is complete. The file is markdown, not HTML—clean input for the model.

Example: Firecrawl install.md

Here’s a real install.md file for Firecrawl, a web scraping API:
# firecrawl

> Documentation and setup instructions for firecrawl

I want you to install Firecrawl for me. Execute all the steps below autonomously.

OBJECTIVE: Install the Firecrawl SDK and verify it works by scraping a webpage.

DONE WHEN: You have successfully scraped a URL and received markdown content back from the Firecrawl API.

## TODO

- [ ] Install the Firecrawl SDK (Python or Node)
- [ ] Set up the API key as an environment variable
- [ ] Create a test script that scrapes a webpage
- [ ] Run the script and verify markdown output is returned

## Installation

You need to install the Firecrawl SDK. Choose Python or Node based on your project:

**Python:**
```bash
pip install firecrawl-py
```

**Node:**
```bash
npm install @mendable/firecrawl-js
```

## API Key Setup

You must set your Firecrawl API key as an environment variable. The API key is required for all requests.

**On macOS/Linux:**
```bash
export FIRECRAWL_API_KEY="fc-YOUR-API-KEY"
```

**On Windows:**
```powershell
$env:FIRECRAWL_API_KEY="fc-YOUR-API-KEY"
```

Note: You need to obtain an API key from https://firecrawl.dev/app/api-keys before proceeding.

## Create Test Script

Your task is to create a test script that scrapes a webpage and outputs the result.

**Python - create `test_firecrawl.py`:**
```python
import os
from firecrawl import Firecrawl

firecrawl = Firecrawl(api_key=os.environ.get("FIRECRAWL_API_KEY"))

# Scrape a website
doc = firecrawl.scrape("https://firecrawl.dev", formats=["markdown"])
print(doc)
```

**Node - create `test_firecrawl.js`:**
```javascript
import Firecrawl from '@mendable/firecrawl-js';

const firecrawl = new Firecrawl({ apiKey: process.env.FIRECRAWL_API_KEY });

const doc = await firecrawl.scrape('https://firecrawl.dev', { formats: ['markdown'] });
console.log(doc);
```

## Run the Test

You must execute the test script to verify the installation works:

**Python:**
```bash
python test_firecrawl.py
```

**Node:**
```bash
node test_firecrawl.js
```

The response should contain a `markdown` field with the scraped content and a `metadata` object with page information.

## Additional Features

Once installation is verified, you can use these additional capabilities:

**Crawl entire websites:**
```python
docs = firecrawl.crawl(url="https://docs.firecrawl.dev", limit=10)
```

**Search the web:**
```python
results = firecrawl.search(query="firecrawl", limit=3)
```

**Extract structured data with JSON mode:**
```python
from pydantic import BaseModel

class CompanyInfo(BaseModel):
    company_mission: str
    is_open_source: bool

result = firecrawl.scrape(
    'https://firecrawl.dev',
    formats=[{"type": "json", "schema": CompanyInfo.model_json_schema()}]
)
```

## MCP Integration (Optional)

If you're using Claude Code, Cursor, or Windsurf, you can add Firecrawl as an MCP server:

**Claude Code:**
```bash
claude mcp add firecrawl -e FIRECRAWL_API_KEY=your-api-key -- npx -y firecrawl-mcp
```

**Cursor - add to MCP settings:**
```json
{
  "mcpServers": {
    "firecrawl": {
      "command": "npx",
      "args": ["-y", "firecrawl-mcp"],
      "env": {
        "FIRECRAWL_API_KEY": "your_api_key_here"
      }
    }
  }
}
```

EXECUTE NOW: Complete the above TODO list to achieve: Successfully scraped a URL and received markdown content back from the Firecrawl API.

---

> If you think the above is not enough to accomplish the task, you can find navigation and other pages relevant to this product by using the llms.txt file at: https://docs.firecrawl.dev/llms.txt

Relationship to llms.txt

install.md works naturally with llms.txt. While llms.txt helps LLMs understand your software broadly, install.md tells them specifically how to install it. Your install.md can link to your llms.txt so the agent can reference it for troubleshooting, configuration details, or additional context needed during installation. We recommend putting any reference pages or your llms.txt at the end of your install.md file.
---

> If you think the above is not enough to accomplish the task, you can find navigation and other pages relevant to this product by using the llms.txt file at: https://your-docs.com/llms.txt

Get started

FAQ

Wizards solve the same problem: reliable installation across environments. They require significant engineering to build and maintain. install.md is a lighter-weight alternative—you define instructions in markdown, and the LLM handles adaptation. For complex integrations with many configuration options, a dedicated wizard may still be the right choice. For most software, install.md gets you most of the benefit with far less effort.
install.md doesn’t replace your existing tools—it works with them. Your install.md can instruct the LLM to run your CLI, execute your scripts, or follow your existing setup process. Think of it as a layer that guides the LLM to use whatever tools you’ve already built.
This is a fair concern. A few things make install.md different:
  1. Human-readable by design. Users can review the instructions before execution. Unlike obfuscated scripts, the intent is clear.
  2. Step-by-step approval. LLMs in agentic contexts can be configured to request approval before running commands. Users see each action and can reject it.
  3. No hidden behavior. install.md describes outcomes in natural language. Malicious intent is harder to hide than in a shell script. This is less safe than a shell script for example, because an install.md file can contain a script or even multiple scripts. But it’s easier to audit than a sophisticated wizard or any tool that runs LLM prompts under the hood.
install.md doesn’t eliminate trust requirements. Users should only use install.md files from sources they trust—same as any installation method.
No. install.md can be used for any software—desktop applications, system utilities, complex multi-component setups. If it can be installed via terminal commands, it can have an install.md.
Not necessarily. It can be a snippet users copy-paste, or embedded directly in your existing installation page. The key is that users and agents can access the structured instructions.

The vision

As AI agents become more capable, we envision a future where:
  • Developers control exactly what context AI agents receive for installing their software
  • AI agents adapt installation to any environment and verify success automatically
  • Users can read, modify, and trust installation instructions before execution
  • The yak-shaving of software installation is handled entirely by AI

Read the full proposal

Learn more about the specification and join the conversation.