Map

Polylane Map turns any repository into a shareable production map with the problems that matter: your agent maps entry points, services, queues, crons, datastores, external APIs, and deploy targets, then runs read-only queries against your live cloud accounts to find what is failing or primed to fail. Every problem is backed by evidence: a file and line in your repo, or a number measured from your telemetry. You get back a public unlisted link in about 2 minutes. No account is needed: your agent maps the repo and runs any live checks on your machine with your own credentials, and only the findings (aggregate numbers and file references) are sent to Polylane.

Connect the maps MCP

Add the Polylane maps server to your coding agent, then ask it to map the repository. No account or API key is required.

claude mcp add --transport http polylane-maps https://maps.polylane.com/mcp

{
  "mcpServers": {
    "polylane-maps": {
      "type": "http",
      "url": "https://maps.polylane.com/mcp"
    }
  }
}

{
  "servers": {
    "polylane-maps": {
      "type": "http",
      "url": "https://maps.polylane.com/mcp"
    }
  }
}

Then, inside the repository you want to map, tell your agent:

Use the Polylane maps server to map this repository. Call startMapping, follow each directive with getNextStep, and publishMap once a first document is ready.

The server directs the work step by step through five tools:

• startMapping: begin (or re-attach to) an anonymous, map-scoped session for this repo. On first contact it returns a durable machine token that your agent saves, so a later session on the same machine keeps updating the same map.
• getNextStep: fetch the next directive (investigate the repo, run read-only local checks, assemble and validate) and submit the current phase's results.
• publishMap: publish the assembled document and get back the shareable URL.
• getMapStatus: report the map's URL, expiry, staleness, and which files it watches.
• submitMapDelta: after mapped files change during normal work, update the same URL so the map stays current.

The first link arrives in about 2 minutes and the map fills in over the next 15. Once configured, the map updates as a side effect of your normal agent work: when a change touches a mapped file, your agent submits a delta and tells you at the end of its turn.

Copy-paste prompt (no MCP)

For an agent you have not set up with the maps MCP, paste this prompt instead. It works with any agent that can read files and run curl, and produces the same map at the same kind of URL.

How it works

The problems

Every map ships with the concrete problems your agent found: things failing now or primed to fail, each citing a file and line in your repo or a number measured from your live telemetry. No grades, no generic advice; a problem without evidence does not get published. Problems link to the components on the map, and each one is a ready-made starting point for an investigation.

What gets uploaded

A high-level architecture summary and the problem list: the names and relationships of services, stores, and deploy targets, plus per-problem evidence as file references and aggregate numbers (counts, ratios, quantiles). Never code, secrets, credentials, or raw log data. Cloud credentials are used only on your machine to authenticate read-only queries; they are never uploaded, and the server rejects anything that looks like one.

• Pages are public but unlisted: the URL contains a random suffix and pages are not indexed.
• A page stays live for 90 days after its last update, and every publish or delta resets that clock: a map your agent keeps fresh never expires, and publishing again after an expiry brings the same URL back.
• Your agent saves a token to ~/.polylane/maps.json in your home directory, keyed by the repository's git remote: a machine token for the MCP session, or an edit token for the copy-paste path. Either way, a later session on the same machine keeps updating the same page. For a map published through the copy-paste prompt, you can delete it anytime from inside the repository:

curl -sS -X DELETE https://api.polylane.com/v1/public/maps/<slug> \
  -H "x-edit-token: $(jq -r --arg k "$(git remote get-url origin)" '.[$k].editToken' ~/.polylane/maps.json)"

A map is a snapshot; each problem is a starting point. Connect your infrastructure and Polylane keeps the live topology and telemetry in sync and runs the investigations for you.