Connect Writ.
Your agent gets hands on the web.

Add one MCP server and your AI agent can drive the real web: open a live browser, log in, turn any site into a callable API, record a workflow, and crawl whole sites at scale. Ask once and it builds the automation; ask again and it replays it instantly, at zero token cost.

Most agents can only call the handful of services that ship an API. Connected to Writ, yours can reach anything a person can open in a browser, on your own authorized accounts. Six capabilities, one server:

All six run on your machine, on your own accounts. No Writ AI key, no cloud account. Linking a free Writ Cloud account adds two more: writ_search_api / writ_install_api to find and install ready-made marketplace APIs, and public HTTPS endpoints for callers that aren't on this machine.

curl -X POST https://api.usewrit.app/api/crawl/scrape \
  -H "Content-Type: application/json" \
  -d '{"url":"https://example.com"}'

{ "url": "https://example.com",
  "markdown": "# Example Domain\n…" }

claude mcp add writ-cloud \
  -e WRIT_API_KEY=wt_your_api_key \
  -- npx -y writ-mcp

import { WritAgent, runRowId } from "@usewrit/agent-sdk";

const client = new WritAgent();              // discovers the running agent + token
const { data: workflows } = await client.workflows.list();
const run = await client.workflows.runAndWait(workflows[0].id, {
  inputs: { city: "Paris" },
});
const { data: rows } = await client.runs.data(runRowId(run));
console.log(run.status, rows);

from writ_agent import WritAgent, run_row_id

with WritAgent() as client:                  # discovers the local daemon
    run = client.workflows.run_and_wait(3, inputs={"city": "Paris"})
    print(run["status"], run["rows_extracted"])
    print(client.runs.data(run_row_id(run))["data"])   # extracted rows

client, err := writ.Discover(ctx)                        // find the running agent
page, _ := client.Workflows.List(ctx, nil)
item, _ := client.Workflows.RunAndWait(ctx, page.Data[0].ID, nil)
rowID, _ := item.RowID()
csv, _ := client.Runs.DataCSV(ctx, rowID)                // extracted rows as CSV
fmt.Println(item.Status, "
", csv)

use writ_client::{RunOptions, WritAgent};

let agent = WritAgent::discover().await?;                // find the running daemon
let workflows = agent.workflows().list().await?;
let wf = &workflows.data[0];
let outcome = agent.workflows().run_and_wait(wf.id, &RunOptions::default()).await?;
let rows = agent.runs().data(outcome.run.row_id().unwrap()).await?;
println!("{} → {}: {}", wf.name, outcome.run.status, rows.data);

The first time you ask your agent for a reliable way to drive a site, Writ does the hard work once: opens a browser, works through the steps, and saves the result as a workflow. Every ask after that skips straight to a replay: instant, deterministic, and free of token cost. Watch both halves:

The saved workflow is also a REST endpoint and MCP tool, so the same automation your agent built is callable from your code, other agents, or a schedule. See Website → API and Automations.

An MCP server that just dumps page text can't submit forms, update dashboards, trigger approved workflows, or pull data from behind a login. Writ packages full browser workflows - including authenticated, multi-step ones - as MCP tools. Your agent calls a tool; Writ runs the real workflow and returns structured output.

Each Writ MCP server exposes a set of tools. A tool has a name, a description the agent reads to decide when to use it, a typed input schema, and a structured output. You map a published workflow to a tool name and description in the MCP endpoint config - Writ advertises it over the Model Context Protocol.

{
  "tool_name": "check_competitor_price",
  "tool_description": "Look up the current price and stock for a product URL.",
  "workflow_slug": "price-check",
  "server_version": "1.0.0"
}

Point any MCP-compatible client at your Writ server URL and authenticate with a wt_ key. Tools appear automatically; your agent picks them by description.

{
  "mcpServers": {
    "writ": {
      "url": "https://api.usewrit.app/mcp/acme",
      "headers": { "Authorization": "Bearer wt_8f2c...a91" }
    }
  }
}

Because each tool is a real browser workflow, it handles login, TOTP and mailbox-OTP two-factor on your own authenticated accounts, dynamic pages, and 30+ step types. Recorded recipes plus AI navigation survive UI changes, so tools keep working when sites move.

Two-factor and login run on your own authenticated accounts - see personas.

Writ runs on your own accounts, with your own credentials and data, on sites you are authorized to use. It automates work a person could do by hand in a browser. Secrets live in an encrypted vault, tools are scoped by wt_ key, and every tool call is logged and attributable to a run.

See trust, security, and the acceptable use policy.