Skopia

Skopia

Describe a building; Skopia draws it — plan, section and elevation, from one document. You give it a brief or a measured survey. It draws the floor plan in a CAD register, in real millimetres, and then projects the section and the elevation of that same building from the same document, so the three drawings cannot disagree with each other. One floor or a whole house. Then a true-to-scale sheet, or a DXF to refine in AutoCAD, Revit or Vectorworks.

Every drawing draws itself, whole and at its own scale: the plan, each section and each elevation come back as an SVG to look at and check. A sheet is where drawings go once they are right, not where you start.

*A contemporary house, ground floor: built and furnished through the operations an agent calls, every fixture from the stock and turned by the wall it names, both cut lines placed by rule. The engine's own render of the document, not a drawing of it.*

*Section A–A, cut on the line marked in the plan above and projected from the same document. Nothing here was drawn twice: the window is the plan's window and the kitchen is the plan's kitchen.*

https://skopia.datatreehaus.com/v1

%22%7D%5D%7D)

Every call needs a key. Getting one is free, instant, and needs no approval. The one-click installs above carry no key: Cursor reads SKOPIA_KEY from your environment, VS Code asks for it as it installs.

Quick start

# 1. get a key

curl -X POST https://skopia.datatreehaus.com/v1/keys \ -H 'content-type: application/json' \ -d '{"label":"my agent","email":"you@example.com"}'

2. add the server

claude mcp add --transport http skopia \ https://skopia.datatreehaus.com/v1 \ --header "Authorization: Bearer YOUR_KEY"

Cursor, VS Code, Codex, .mcp.json and raw HTTP are covered at /setup.

ChatGPT, Claude Desktop and claude.ai need no key at all. Their connector dialogs take an MCP server that speaks OAuth, and this one does: paste https://skopia.datatreehaus.com/v1, and the consent page mints a key for that connection which you never see. No account is created; the key is the whole of it, and it is revocable like any other. In a client that can show one (ChatGPT, or anything on the MCP Apps extension), a plan or a sheet arrives as a picture rather than as SVG text.

Protocol: MCP over Streamable HTTP. The server is built on revision 2026-07-28 (server/discover, no initialize) and also speaks the initialize-era revisions — 2025-11-25, 2025-06-18, 2025-03-26, 2024-11-05 — so an ordinary client just connects: open with initialize, name your revision in MCP-Protocol-Version, and none of the newer revision's mirrored headers or _meta fields are asked of you. initialize and ping are the only calls that need no key.

What it does that a model cannot do for itself

A model asked to draw a floor plan will emit SVG, and it will look entirely fine. The walls will not quite close, the elevation will not agree with the plan, and the door will swing out of its hinge. Nothing will fail. That is the problem this exists to remove.

An agent cannot draw a door wrong here, because it does not draw the door. It names one — panelled, part-glazed, three rows — and the same component answers in the plan, the elevation and the section. The swing is derived once and reviewed once, and cannot come out of the hinge on a Tuesday.

• Elevations cannot disagree with the plan. Not through care. A horizontal position in an elevation is a *reference* to a plan feature (opening:3.jamb.left), so there is no field anywhere that could hold a wrong number.
• It asks instead of guessing. Give it a survey and missing_dimensions tells you which measurements were never actually taken, rather than picking a plausible number that closes the ring. From the moment software invents that number it is indistinguishable from a measured one.
• Components are asked for, not drawn. {"type": "sash", "panes": [3, 2]} is a six-over-six sash. The same window as SVG path data is around fifty times the tokens, and a model can get path data subtly wrong in ways nothing checks.
• Refusals name the problem. Typed, permanent error codes saying *which* object offended, because an agent cannot act on "invalid layout".
• Advisory reads never decide. suggest_joins reports which tables could be pushed together and changes nothing. Adjacency may suggest; a person decides.
• No regulatory figures ship here. Gangway widths, egress distances and wheelchair ratios are yours to supply and yours to stand behind. Wrong numbers inside software a fire officer reads are a liability, not a bug.

We wrote the alternative, and it was wrong three times

The case for this had to be tested rather than asserted, so the competitor is a real file in our repository: a hand-written script that draws the same house. It was written with the engine's source open — its palette, its wall conventions, its house data — and corrected three times against renders with a person reviewing. It is not a cold run and we will not present it as one.

Which makes the failures sharper rather than softer. Given every one of those advantages, it was still wrong three times.

1. The door's swing arc sprang from the *hinge* instead of the leaf's tip, so it floated into the room ending nowhere near the far jamb.
2. Windows were bare white gaps — no frame, no glass line. A hole in a wall, not a window.
3. The internal walls had no doors in them at all. Three rooms, no way into any of them.

Every version rendered cleanly. Two of the three faults were invisible at the size the drawing was reviewed at, and the third survived two rounds of review looking perfectly reasonable. An agent running unattended ships it.

Tokens are not the argument. On raw count, a script an agent writes once still beats calling this — the drawing goes to a file, where a tool result comes back into the context — and our own benchmark says so plainly rather than burying it. The argument is that the cheap path's failures are silent, plausible, and found by a human or not at all.

The cheap version is the wrong one, every time.

We have not measured tokens-to-completion for a cold agent. That needs a real run against a brief, with no sight of this engine's source, recorded to the point where the drawings are actually right. We have not done it, and nothing above is quoted as though we had.

And then we ran it ourselves, and it was wrong too

One agent, one brief, this engine, September 2026. It cost about 269,000 tokens and the drawings came out wrong: a section facing the wrong way, a blank section B–B, a two-over-two sash that was not one, 1:50 too small for the sheet, and eight dimension queries too small to read.

• Looking is the job. About 100,000 of those tokens — 37% — were rendering a drawing and looking at it, roughly 8,000 a picture. An agent writing its own SVG has the identical loop at the identical price, so the biggest cost in the job is common to both sides and cancels out of the comparison entirely. Our own benchmark never counted it.
• Reading the engine cost ~65,000 tokens before any work started. Over MCP that is a tool list instead — which is the honest argument for the server, and one we had backwards.
• The refusals did their job. A spot level the schema could not hold and two unused wall thicknesses were reported rather than silently dropped.

So: naming a component removes a *class* of error, not the category. An agent can still ask for the wrong one, point a section the wrong way, or produce a drawing that comes out blank. We have done all three.

And then the ENGINE was wrong, four times in two days, with its suite green

The most useful evidence we have, because this is code written for nothing else, under 680 tests, and every one of these still shipped and was caught by a person looking at a drawing at a size they could read:

• A section that stopped at the wall head, so a house came back as a box with nothing on top while the elevation beside it drew the roof correctly.
• Then that roof, drawn right, floating above gable walls that stopped at the eaves — a wall stops at the head only where the roof comes *down* to it.
• One bowed segment refusing every section and every elevation, because the guard sat where both projections shared it.
• Ordinates reaching callers as -85.66329565734681, because every axis-aligned corner projects to a whole millimetre unaided and nothing showed it until a curve.

If code with a test suite and exactly one job gets those wrong, SVG written in one pass will not get them right. What it will do is render.

The arithmetic, with the numbers. None of it is exotic; it is what an elevation *is*:

Every one of those renders cleanly, and not one is the sort of thing a reader spots.

We have not run the other side cold. There is no A/B here and we will not imply one.

A house is storeys

*The first floor, a second document against the same datum. The stair arrives where the ground floor's leaves; a section through both is one drawing, joined by the engine and checked at the junction.*

A storey is not a new kind of thing. Each floor is an ordinary document with its own heights against one shared datum, and a section or an elevation is projected from every floor and joined into one drawing: the same wall stated by two floors is one band from the slab to the eaves, an elevation face runs through the floor line with no seam, and the junction is drawn as one outline because every floor's cut is in one region. Alignment comes from two fixed points you name on every plan (vertex:0.outer — the outer corner, which stays put when a wall thins upstairs), and it is checked, never fitted: a rotated survey, a floor that stops short of the one above, or a ceiling that does not meet the floor construction over it is refused with the millimetres. The basis is reported in numbers and, on request, drawn on every plan and joined drawing, so nobody has to take the join on trust. draw_sheet takes storeys instead of document and do