A2A Agent Card · Datatreehaus

Skopia

Provider: Datatreehaus Card identifies: Datatreehaus Conformance: Conformant Protocol: 2026-07-28 Transport: Version: 0.4.0 Host: skopia.datatreehaus.com Skills: 18
Discovery

An A2A client finds this agent by fetching the well-known path on the provider's own host. That is what makes an agent card different from every other agent artifact in this catalog: it is provider-published by construction — it cannot be derived, generated, or reconstructed on a provider's behalf.

https://skopia.datatreehaus.com/.well-known/agent-card.json
Interfaces
https://skopia.datatreehaus.com/v1 · transport · protocol https://skopia.datatreehaus.com/bindings/mcp-streamable-http/1
Skills (18)

Build or change a floor plan edit_layout

Apply operations to a layout document and get the updated document back. Omit `document` to start from nothing: placing the first corner of a new room is the ordinary way to begin. Operations are the same vocabulary a person uses in the editor, so anything drawable is callable; list_operations gives the full set with arguments. The whole batch is checked before any of it runs, so a typo in the last operation leaves no half-built room. A document that does not yet validate (a ring with two corners, say) is returned anyway, with `findings` saying why. A part-drawn room is an ordinary intermediate state, not an error.

floor-plancore

The operation vocabulary list_operations

Every operation edit_layout accepts, grouped by what it acts on. Call this once before building; the names are permanent, so the answer can be cached for the life of a session.

floor-plancore

Check a layout validate_layout

Typed, permanent error codes naming which object offended: overlapping objects, an opening too near a corner, a boundary that crosses itself. An empty list means the document is sound, and `checked` says what that verdict rests on rather than leaving silence to be read as a pass: how many walls, openings, objects and fixtures were examined, and for every fixture the wall its back is on and, per placement rule, the millimetres REQUIRED and the millimetres AVAILABLE (measured to `measured_to_mm`). `tightest` is the smallest margin in the room — "six fixtures checked, tightest 440 of 600 at the bidet" is read off it. This is a check, not an opinion: a layout that breaks a venue's own spacing preference is still valid here; use check_rules for that.

floor-plancore

Draw the plan render_layout

The layout as SVG. Deterministic — identical input gives byte-identical output, so a render can be diffed. Optionally paint occupancy (which objects are in use) or highlight one object. A plan is a horizontal SECTION, cut about 1200 above the floor — which is why an opening shows as a gap in a wall at all. Give it `heights` and an opening clear of that plane keeps the wall unbroken and is drawn dashed instead, long for one above and short for one below. Without heights every opening is treated as cut, which is what this has always done. A drawing is at 1:50 unless `scale` says otherwise — annotation is sized on the paper, so a section mark and its lettering stay the same size on the sheet whatever the scale.

floor-plancore

Project an elevation from the plan project_elevation

The elevation of one side of the building, PROJECTED from the plan rather than drawn, which is why it cannot disagree with it. Horizontal positions come back as references to plan features (`opening:3.jamb.left`, `vertex:2.outer`), never as numbers, so there is no field anywhere that could hold a wrong one. Heights must be supplied and are never assumed: a cill height cannot be got from a plan, and a plausible invented one is indistinguishable from a measured one forever after. Faces at an angle report their own foreshortening, so a bay's splayed return is drawn at its projected width rather than the width you measured along it. A BOWED wall is the same rule taken to a curve: drawn at the width you would see, never unrolled, reporting `curved: true` with its arc length in `true_mm` — and no `splay_deg`, because a curve sweeps a range of angles rather than having one. It comes back DRAWN by default, on its own and at its own scale, because the drawing is the thing to check and a sheet is where it goes afterwards.

floor-planelevation

Cut a section project_section

A section is the same projection as an elevation with the picture plane moved INSIDE the building. Everything in front of the plane is discarded; what the plane passes through is CUT through its thickness and comes back flagged `cut: true` so it can be drawn heaviest; an opening the plane passes through is a void, so the wall is cut above its head and below its cill and nowhere between. Name a section by its reference (`A` for the drawing A–A) and the line comes from the plan, so the mark and the drawing cannot be cut in different places. An ad-hoc `line` is for exploring before one is committed. Internal walls are cut and seen exactly as external ones are — a section across a house shows the rooms — and their doorways appear in them. A beam the plane crosses with no measured soffit is refused by name rather than omitted, because a section that leaves it out says there is headroom where there is a beam. A partition with no given head refuses the same way and for the same reason. THE ROOF IS CUT when `heights.construction.roof` gives its thickness: rafter lines mitred at the ridge, the underside offset perpendicular rather than vertically, exact at any cut angle. A wall stops at `wall_head` only where the roof COMES DOWN to it — a gable end, a lean-to’s high wall and its sides carry on up to the roof’s underside, because capping those draws a wall that is not there and leaves the roof resting on nothing. It comes back DRAWN by default, on its own and at its own scale, because the drawing is the thing to check and a sheet is where it goes afterwards.

floor-planelevation

Where a section could go, and what each place would show suggest_sections

Candidate cut lines with the evidence for choosing between them — how many walls each would cut, how many INTERNAL walls (counted apart: one says how much of the envelope the cut crosses, the other how many rooms it goes through), how many openings it would pass through as voids, which overhead members it would catch, and how much it would reveal beyond. Offered in BOTH directions, because a set of drawings conventionally carries one section each way and a single cut can only answer one of the questions. **It suggests and never decides.** There is no score and no recommendation: choosing the cut that best conveys a design is a judgement, and the engine puts the facts in front of whoever is making it. A candidate that cannot be drawn yet comes back `refused`, which is far more use now than after it is chosen.

floor-planelevation

One section or elevation across several storeys join_drawings

A house is storeys, and a section is across all of them. Each storey is an ORDINARY document with its own heights; this projects the same section (`section: "A"`) or the same elevation (`elevation: "south"`) from every storey and JOINS them into ONE drawing that `draw_sheet` takes as it stands — or pass `storeys` to draw_sheet directly and skip the round trip. Horizontal alignment comes from the `fixed` points and is NEVER fitted: two pairs that disagree on the shift between two plans are refused (`storeys_misaligned`) with the millimetres. Vertical alignment needs nothing, because every height is already against the shared datum. The junction between two storeys is OVER-DETERMINED — the lower ceiling and its construction, the upper floor and its construction, the lower wall head — and is CHECKED, not chosen: a gap or clash beyond the tolerance is `storeys_junction_mismatch` naming the millimetres; one inside it is closed and reported in `findings`. Two sections must be the SAME cut once the plans are aligned, or the join refuses (`storeys_views_differ`). What comes back is one feature list: the same wall stated by two storeys is one band from the slab to the eaves, an elevation face runs through the floor line with no seam, and the renderer draws every storey’s cut as one region with one outline, so the junction is clean by construction rather than by anybody looking at it. Only the top storey’s roof is drawn; a lower one (a lean-to, a bay) is dropped and reported — hidden-line work between storeys is not done. **Nothing is a black box.** `alignment` in the response says which fixed point was the anchor, the shift every storey took, the residual at every other fixed point (zero or not), and where each point lands on the joined drawing (`u`); `marks` is the same as a drawing list, and `draw_sheet` with `mark_fixed: true` draws every fixed point on every plan and, full height, on every joined section and elevation with the same label — so a person can see that F1 on the ground floor plan, F1 on the first floor plan and F1 on the section are one corner. Nothing here does the plans: each storey’s plan is `draw_sheet` with `plan: true`, one sheet per floor or all on one, your call.

floor-planelevation

Put the drawings on paper draw_sheet

ONE sheet, TRUE TO SCALE: the SVG declares real paper millimetres and a viewBox of paper × scale, so a rule laid on the print agrees with the drawing rather than with whatever size a browser chose. **A sheet is the LAST step, not the first.** Look at each drawing on its own first — `render_layout` for the plan, `project_section` and `project_elevation` draw themselves — because a section in a cell on an A3 at 1:50 is 200mm wide, which is where a wrong cill or a missing jamb goes unseen. Compose a sheet once the drawings are right. **A set is several sheets, not one crowded one.** Put the PLAN on its own sheet; give the SECTIONS a sheet and the ELEVATIONS a sheet. Call this once per sheet — it is a pure function, so that costs nothing but the call. Mixing them is what makes a sheet unreadable and forces a scale nobody can measure. A drawing too big for its paper is REFUSED by name (`sheet_overflows`) with what it measures and what the sheet leaves, and the message says when it would fit turned 90° — a browser quietly fitting a drawing to the page is the one failure nobody notices until it is measured on site. Rotation is a sheet decision: `rotate` on a drawing turns it 0/90/180/270, or "auto" to turn it only if that is what makes it fit. The drawing turns; its TITLE does not, so it still reads horizontally. Drawings lay out on a GRID — `columns` (a number, or "fit") — of equal CELLS spread across the sheet rather than a stack packed against the corner. House rules, both about the eye finding things in the same place on every sheet: LEFT-ALIGNED never centred, and titles on a grid — one x down a column, one baseline across a row. Within a row the drawings stand on a COMMON GROUND LINE, because elevations and sections stand on the ground and top-aligning them would say something untrue about their levels. A drawing is never stretched to fill: it is at a scale, so filling the sheet is an arrangement and never a size, and `sheet_overflows` measures against the CELL and names the grid — `columns: 4` on an A3 is a cell a quarter the width, which is usually the real answer rather than a bigger sheet. The scale bar is a real distance rather than annotation, so it is still true after a photocopier. Nothing here reads a clock: a date in the title block is a string you supply, and the same inputs always give the same bytes. A HOUSE is `storeys` instead of `document`: each storey an ordinary document with its heights and two `fixed` points shared by every floor (see join_drawings). Then `sections` and `elevations` are joined ACROSS the storeys — one drawing each, junction checked and drawn clean — and `plan: true` draws every storey’s plan, titled by its name — one sheet per floor, or all on one, your call. `mark_fixed: true` draws the fixed points on every plan and every joined drawing, and `alignments` in the response is the basis in numbers.

floor-plancore

Export the drawings as DXF export_dxf

The drawings draw_sheet puts on paper, as ONE DXF for CAD — AutoCAD, Vectorworks, Revit, a CNC bed. Model space, millimetres, y UP, at 1:1: the plan lands exactly at the document’s own coordinates, so a wall measured in CAD is the wall the document stores. Layers are named by ROLE and the names are permanent: WALL, PARTITION, DOOR, DOOR-SWING, WINDOW, OPENING-HIDDEN, ZONE, OBJECT, FIXTURE, OVERHEAD, ROOFLIGHT, SECTION-MARK, TEXT, EVIDENCE, CUT, CUT-POCHE, SEEN, OPENING, GLASS, ROOF, GROUND. A wall is its two faces and the jambs at every opening — a CAD wall is lines, never a filled band — and on a section what the plane cuts is ONE region: its outline on CUT, its solid fill on CUT-POCHE. Every layer carries the register’s line weight, and the hierarchy is the drawing office’s: what is CUT is heavier than what is SEEN — walls, partitions and a section’s cut outline at 0.5 mm; objects, fixtures, doors and windows beyond the plane at 0.25; swings, glass lines and glazing bars at 0.13; anything over or under the cut plane at 0.18, dashed — so a plot from CAD reads as the sheet does; `weights` in the response states it. `scale` is for INK only — text heights, dash patterns and section-mark heads are paper millimetres times it, exactly as on the sheet — and geometry never moves. Drawings lay out in one row on ONE datum: the first plan at its world coordinates, then every other drawing moved along x only, so y on a section is still a height above the datum. `placements` says where each landed — `at`, `frame`, `extent`, `bounds` — in draw_sheet’s own vocabulary with y up: x = (u − origin_u) + offset_x + at.x, y = z + at.y. NOT in the file, on purpose: the sheet, title block and scale bar (paper things — a DXF is model space and the sheet is a layout in the receiving application), dimensions (the engine does not dimension), occupancy (runtime state, never drawing). Same arguments as draw_sheet less the paper. By default the file comes back as a LINK: `file.url`, fetched with the same key as a bearer (`curl -H "Authorization: Bearer $KEY" -o plan.dxf`), valid for an hour and for that key alone, so the DXF never passes through the conversation to be retyped. `deliver: "inline"` asks for the file itself as the first text block instead, for a caller with no way to fetch a URL; write that to a `.dxf` file rather than reading it — it is CAD, not prose.

floor-plancore

What the roof still needs roof_report

A roof is OVER-DETERMINED: span, eaves, ridge and pitch are four numbers with one equation between them, so the plan plus any TWO of the heights fixes it. This says which readings are still missing, as questions somebody can go and answer — and it never picks a value. A gable/hip/mono/flat roof drawn at a plausible pitch because the pitch was not measured is indistinguishable, forever after, from one that was. Give all three and it CHECKS them against each other rather than quietly preferring two: three readings that disagree are refused by name with the discrepancy in millimetres, which is what a homeowner holding a tape, a laser and a builder's recollection actually needs to hear. The form itself is stated on the document (`roof`: kind, the eaves walls the ridge runs parallel to, overhang) and its outline is derived from the plan — the footprint is the boundary ring, so nothing states a roof coordinate. Half-hipped, mansard, gambrel, catslide, dormers and a valley between two wings are NOT built and are refused by name rather than approximated. `roof.covering` states what it is covered with (`{"type": "slate"}`) and an elevation then draws the courses at their real trade size, foreshortened by the pitch — on the slopes you are looking AT, never on a gable end, which is the verge. Nine types; a roof with no covering stated is drawn plain, because inventing one is the same mistake as inventing a cill height.

floor-planadvisory

The window and door stock list_components

The component types an elevation can hang on an opening, with their defaults. A component is ASKED FOR, not drawn: `{ "type": "sash", "panes": [3, 2] }` is a six-over-six sash in about six tokens, where the same window as SVG path data is around three hundred, measured at 55:1 across the whole stock. A component never carries its own width or height: it is handed the box its opening cuts and draws inside it, so it cannot disagree with the plan. An unknown type is refused by name rather than falling back to something plausible.

floor-planelevation

The kitchen, bathroom and furniture stock list_fixtures

What can stand in a room and be drawn as what it is: kitchen units and appliances, sanitaryware, a stair, beds, sofas, wardrobes — each at a typical trade size, with its plan symbol, its front and side, and its SECTION profile through either axis, from one description. Place one with `edit_layout`’s `add_fixture` — `{ "op": "add_fixture", "type": "bath", "at": {x, y} }` — by its INSERTION POINT, the back-left corner that goes into the room’s corner (`at`), or by centre (`x`, `y`); `rot` turns it counter-clockwise, and its back is the side that goes against the wall. Sized from the stock unless you give `w` (along the wall) or `d` (out from it); `height` is the one size the spec itself may state. A spec never carries a footprint: that is the object’s own w, h and rot, so the plan’s bath and the section’s bath cannot disagree. A section then SEES a fixture beyond the plane as the face it is looking at, and CUTS one the plane passes through as its profile — which face and which profile are derived from the object’s rotation against the plane, never stated. Its extent on the drawing is a reference to the plan (`object:.left`, `.right`, `.centre`), so it lands where the plan put it. An elevation is of the outside and never shows one. A wall unit hangs at its own height and is drawn hidden on a plan cut below it; two fixtures whose heights never meet (a wall unit over a base unit) are not an overlap. A stair climbs from its front to its back; `arrives: true` is its head on the floor above. EVERY TYPE SHIPS ITS PLACEMENT RULES in `place`: `back` says whether its back edge stands against a wall (a WC’s cistern, a basin’s taps, a bed’s head) or is free; `clear` says the millimetres a person needs off each edge to use it (600 in front of a sofa to sit, 700 at a basin, 900 along a kitchen run); `either` names edges of which at least one must be clear; `note` says why. `rot` is counter-clockwise and its BACK faces the wall: rot 0 the north wall, 90 the WEST, 180 south, 270 the EAST — or say `against: {wall: }` (or `{partition: , side: "left"|"right"}`) and the engine derives the rotation from that wall, which is the way to never get it wrong. `validate_layout` then reads each fixture’s own rules back: `fixture_faces_wall` (with the rotation that turns it), `fixture_off_wall` (with the gap) and `fixture_access_blocked` (naming the wall, partition or object in the way). Findings, not refusals. Sizes and clear spaces here are typical trade practice, not regulations — no gangway, turning circle or escape width is built in; those are a `check_rules` ruleset with your citation. An unknown type is refused by name.

floor-plancore

Which objects could be pushed together suggest_joins

Objects close enough and aligned enough to be joined, with the evidence for each. It SUGGESTS and never decides: joining is a decision with consequences a plan cannot see, so nothing is changed and `covers_if_joined` stays null unless both objects carry a real count. Pairs only, same rotation only, rectangles only. Every one of those refusals is a place a person is genuinely deciding.

floor-planadvisory

Which way should this object face suggest_rotation

Answers twice over, because the two answers usually disagree: the angle with the most clearance around it, and the angle that squares it with its neighbours and the room's own walls. Both come back with their evidence, and nothing is rotated. Apply the ordinary `rotate_table` operation if you want one.

floor-planadvisory

Check a layout against rules you supply check_rules

Rules are YOUR parameters, checked by a generic engine. Skopia ships no regulatory figures at all. No gangway widths, no egress distances, no wheelchair ratios: wrong numbers inside software a fire officer reads are a liability rather than a bug, and whoever supplies a figure is accountable for it. Deliberately separate from validate_layout, because a layout that breaks a venue's own spacing preference is still a valid document. One rule kind exists (`object_spacing`); any other is refused BY NAME rather than skipped, since silently ignoring a rule reports a clean layout against a check that never ran.

floor-planadvisory

What a section will have to reckon with overhead_report

Every member ABOVE the plan's cut plane — a beam over, today — and whether its heights are known. A beam is drawn hidden on a plan because you are looking down at a section taken below it; the moment a SECTION is cut through the room it becomes a real drawn member, and one whose soffit nobody measured cannot be drawn at all. This says so while there is still a tape in the room rather than afterwards at a desk. It reads, and it never invents a height.

floor-planadvisory

Which measurements the survey never actually took missing_dimensions

Given a layout and the dimensions actually MEASURED on site, says whether the shape is determined by those readings, and if not, which readings to go and take. It could pick a number that closes the ring. It must not: that is precisely the defect, because from the moment it does, the invented number is indistinguishable from a measured one. So the answer is a question. Each one names the two points to measure between and the value the drawing is currently assuming, flagged unconfirmed. Refuses by name on a bowed or splayed wall, where the reasoning does not hold. A wrong "your survey is complete" is worse than no answer.

floor-planadvisory
Documentation
Evidence. Fetched 2026-11-05 from https://skopia.datatreehaus.com/.well-known/agent-card.json, HTTP 200. The body was saved verbatim and is the sole source for everything on this page — no field is inferred. View the captured card. Providers change what they serve; if this card has moved or changed shape, the provider profile carries the current state as of the last build.

Work with this as data

Every agent card here is available over the APIs.io API and to AI agents over MCP. A2A Agent Cards is not yet its own endpoint on the v1 API. Reach it through catalog search and the tag graph, or the MCP server.

MCP server

One button, every client — Claude, Cursor, VS Code and the rest.

https://apis.io/mcp

Tools for a2a agent cards

3 MCP tools reach this
  • apis_io_searchSTART HERE — APIs, providers and tags for one query, each with its total.
  • resolveTurn a domain, URL or GitHub org into the provider it belongs to.
  • find_cohortsEvery scored population of providers in the catalog.
All 92 tools →

Call it yourself

curl for this page
Search the catalog
curl "https://apis.io/api/v1/search?q=datatreehaus-com&limit=10"
Everything under a tag
curl "https://apis.io/api/v1/tags/datatreehaus-com"

Calls without X-API-Key need no key. Calls with it need a paid plan — get a key.

Get an API key

Free tier, no form to fill in. Signing in shares your email address with us — we store it to create your key and to recognise you if you sign in with another provider. See our Privacy Policy and Terms.

A second provider on the same verified email joins the account you already have.