Give your agent CAD data it can query, not a drawing it has to swallow.

There is no model in the middle of this pipeline doing interpretation. CADLens is a deterministic parser; the agent is the consumer of what it produces.

CAD drawing        DWG · DXF · DWF
     ↓
CADLens            parse → sheets, layers, entities, geometry, metrics
     ↓
MCP                7 tools · summary first · filtered retrieval
     ↓
Agent              Claude · Claude Code · Cursor · any MCP client

The representation the agent reads is the same schema 2.0.0 result your backend would get over REST. You can inspect a real one before writing a line of agent code.

The bundled sample is a modest single-sheet drawing — 2,096 entities — and its full JSON result is about 1150 KB. Production drawings are routinely an order of magnitude larger. Three things follow:

• Summary first. get_job_result defaults to mode="summary": sheet names, layer names, and per-layer entity counts, with no geometry. That is usually enough for the agent to decide what it actually needs.
• Then a filtered slice. mode="entities_on_layer" or mode="entities_by_type" returns a subset, capped at 500 entities per call, and can be restricted to one sheet.
• Measurements are precomputed. Each entity ships with bbox and metrics (length, area, perimeter, vertex count), so the agent reads a number rather than doing coordinate arithmetic in the middle of a reasoning chain — where mistakes are quiet.

The effect is that the agent's context holds a description of the drawing plus the handful of entities under discussion, rather than the drawing itself.

These are the actual tools the server advertises. Names are a contract — they appear in /.well-known/mcp/server-card.json and do not change without a version bump.

The hosted transport is Streamable HTTP with bearer auth, so any MCP client that supports remote servers can use it. Clients that launch a process — Claude Desktop, Cursor — use the stdio server, which can also read CAD files straight off the local filesystem.

# Claude Code — hosted server, nothing to install
claude mcp add --transport http cadlens \
  https://api.cadlens.co/mcp \
  --header "Authorization: Bearer cadl_•••••"

# Claude Code — local stdio server instead
claude mcp add cadlens \
  --env CADLENS_API_KEY=cadl_••••• \
  -- npx -y cadlens-mcp

# Claude Desktop, Cursor, and other config-file clients:
# register the same stdio command in the client's MCP config
{
  "mcpServers": {
    "cadlens": {
      "command": "npx",
      "args": ["-y", "cadlens-mcp"],
      "env": { "CADLENS_API_KEY": "cadl_•••••" }
    }
  }
}

Once connected the agent can be asked things like "parse this drawing and tell me how many circles sit on the ELECTRICAL layer" — it will call parse_cad_file, read the summary, then pull just that layer. Full setup, tool schemas, and result modes are in the MCP documentation.

CADLens reads drawings. It does not write them, and it does not infer meaning that is not in the file. Concretely:

• It returns what the drawing contains — entity types, layers, coordinates, measurements, text strings — not semantic labels like "this is a load-bearing wall". If a layer is called WALL, that is the draughtsman's naming, and it is up to your agent or your prompt to decide what it means.
• It produces no edits. There is no write path back into the DWG.
• Results are deterministic. The same file parses to the same JSON, which is what makes it safe to put under an agent that you also want to be able to audit.