Haunch already holds the structured record of a project — calcs with their cited clauses, the calc ↔ drawing graph, tasks, an immutable audit trail. An MCP server hands that record to Claude Code as grounded context — so an AI can answer questions about your job without making anything up.
Plenty of tools can now talk about engineering. Almost none can talk about your project — because they can't see it, and when they guess, they guess wrong in a discipline where someone signs the calc.
Haunch's whole value is that the record is structured and trustworthy. So the question wasn't “can we add a chatbot” — it was “how do we let the AI an engineer already uses read our record, with the citations intact?” The answer turned out to be a standard one.
The server ships as a small package. You add it to Claude Code's MCP config with a scoped token from your Haunch account — read-only by default — and that's the whole setup.
{ "mcpServers": { "haunch": { "command": "npx", "args": ["-y", "@haunch/mcp"], "env": { "HAUNCH_TOKEN": "hnch_sk_••••••••", // scoped, read-only "HAUNCH_SCOPE": "projects:read calcs:read drawings:read" } } } }
Writes — creating a task, marking a drawing re-issued — need an explicit write scope, and every one of them lands in the project's audit trail with “via Claude Code” against your name. More on that below.
We kept the surface deliberately small and honest. Resources are the things it can read; tools are the things it can run. The writes are few, and all of them are gated.
Find projects and jobs by name, ref, client or address across the whole practice.
A calculation with every result tied to its Eurocode clause, formula and value.
Drawings issued against an older calc revision than the one now approved.
The immutable who-did-what-when for any project, calc or drawing.
Draft a task with members, files and a note attached — proposed, never silent.
write scope · audit-loggedMark the drawings a revised calc affects as behind — the consequence cascade, by API.
write scope · audit-loggedHere's where the conductor earns its place. A revised drawing lands in your inbox from the architect. Instead of reading it, opening the job, working out what it touches and remembering to act — you ask once, and Claude works across both connectors.
Claude Code never touches the Haunch database. It talks to the MCP server, and the server is where scope is enforced and every call is recorded. That middle layer is the whole point.
The MCP server is one connector, not the whole story. Claude Code already reaches your filesystem, the CLIs on your machine, and other MCP servers — Git, cloud storage, email. Haunch is one source among several, and Claude Code is the conductor. The job stops being “open six tools and copy between them” and becomes “ask once, where you already work.”
The thing only a tool on your machine can do: reconcile the files on disk against the Haunch register, and file new ones where they belong.
Precedent search across every past job — grounded in what your practice has actually done, not the internet.
RFI responses, transmittals, the revision note from a calc diff — written into your repo as plain text for you to sign off.
One revision, the whole chain — draft the tasks, assign them, and hand to your email CLI to tell the client. Proposed as a single batch.
The default token reads. Writing anything is an explicit scope a person turns on — and even then the server only ever drafts and proposes.
Results carry the tool call and the audit entry behind them. An answer you can't trace is an answer Haunch won't give.
It reads results a human signed. It does not re-derive load paths or invent capacities. The signature stays human.
Anything done through Claude Code is logged as such, against your name. The record stays complete — and honest about how it was made.
The server is in private beta with a handful of practices. The resources are stable; we're adding tools carefully, write by write, each one gated and logged. If you run Claude Code and want your Haunch projects in reach of it, tell us — we'll get you a token.