Harnesses

A working starting point, not just raw API calls.

Every domain ships a real MCP toolset alongside its REST API — the same compliance and engineering-compute functions, exposed as tools any MCP-compatible agent can call directly. Point an agent at a domain and your team has a working assistant for it, not an empty HTTP client. Five illustrative examples below show what that looks like in practice.

What's included

API access

The same real, cited domain endpoints as any API plan — nothing different underneath.

MCP toolset

Every function in the domain, exposed as a tool over the open MCP protocol — works with Claude, Claude Code, or any MCP-compatible agent you already use.

SDK access

Layer your own utility-specific standards on top with StandardsPack — same mechanism as any API plan.

Self-serve

Point your own agent at it

Pick a domain, get a scoped key, and connect any MCP client you already run — no separate onboarding. Use the SDK to make it yours from there.

Assisted

We build the front end for you

Want a real chat interface deployed and wired to your team's equipment and workflows, not just a toolset? We'll build and deploy that layer on the same API and MCP tools — you still own the customization on top.

Illustrative mockup — not a live session

Human-in-the-loop, not autopilot

This is what the assisted build looks like in practice. You ask for an analysis of a whole line. The harness runs a structural check and a framing check and proposes fixes: a deeper set, a larger class, a down-guy. Nothing is written back until a person approves it, and a dismissed fix leaves the design untouched. Watch one run, then hover a card to see where its fix lands and approve or dismiss it yourself. It replays on its own until you touch it.

Overhead harness — pole reviewIllustrative values
Loc 20 changes
PoleExisting
Height
45.0 ft
Class
3
Set depth
6.5 ft
Structural
FAIL
Bending SF
1.61 / 2.7
Capacity
168% used
Framing
fix needed

Scripted, not live. Every number, id and fix here is made up to show the interaction; the status lines flip by a scripted rule. In a real session the harness only proposes. A person approves or dismisses each fix, and nothing is written back until it is committed. The export formats shown (.spida, .pplx, .pol) are illustrative; which formats are available varies by harness, and no file is produced here.

Illustrative mockup — not a live session

Approved fixes land in the open design file

When a person approves a fix, the harness makes the change inside the open design file, through the design application’s own automation interface. Each session below shows what that application itself offers for reversing a change, including one case where it offers none.

Most engineering AI today

  • Wire#3 at 22.0 ft: raise to 24.5 ft
  • Add down-guy at 346 deg

review_report.pdf · PDF markup

The tool tells you what is wrong. Someone still opens the design application and does it.

This harness

  • Raise Wire#3 22.0 → 24.5 ftApprove
  • Add down-guy at 346 degApprove
Wire#3 height24.5 ft
Down-guy346 deg
  • Wire#3 22.0 → 24.5 ft
  • + down-guy 346 deg
Undo in the application
Approve, and the harness makes the change in the open file. Undo it in the application if you change your mind.
Design review — applied in the applicationIllustrative mockup — not a live session
BrainVerified live against all applications shown. Live use, not formally scored.

Scripted, not live. The windows are drawings, not the applications. Every file name, value and step is made up to show the interaction; the tool calls named are real tools of the harness servers, and a chip marked built or planned says what is not yet verified or does not exist today.

Requires the licensed design application installed, licensed and open on your machine. The harness attaches through the application’s own automation interface and does not replace, bundle or redistribute it.

Design edits run locally on your machine; analysis that proposes a fix sends the design data to the harness API.

Proposal cards as in the overhead harness; in the raceway, substation and plant sessions the finding is conversational today.

Verified so far

Any MCP-capable model can call these tools. The selector includes local models; verified so far: Claude against all applications shown; gemma4 26B and 12B and muse-glimmer 30B via a local server against the compute harnesses only, not yet against the desktop applications. Other hosted models are available in the selector and have not been independently evaluated.

ModelWhat was testedResultCaveats
ClaudeLive against the desktop applications shown (pole-analysis, raceway, substation and plant sessions).Not formally scored.Live use only; no scored evaluation of the desktop tools.
gemma4 26B (local server)Tool-calling eval against the compute harnesses’ tool schemas.100% on transmission, underground, substation, DER and building-service; 60–70% on overhead.Compute harnesses only, not the desktop applications. Slow over the full 103-tool overhead set on a local machine; results vary run to run even at temperature 0.
gemma4 12B (local server)Same eval, same tool schemas.100% on transmission, building-service, substation and DER; 67% on underground; 40% on overhead.Compute harnesses only. A four-turn overhead chain needed a longer request timeout than the default.
muse-glimmer 30B (local server)Same eval, same tool schemas.Raw: 100% transmission, 78% underground, 60% overhead; 11% substation, 0% DER, 75% building-service. Projected 100% on those last three after a dispatch normalisation fix, which is deployed.Compute harnesses only. The 100% is projected from the model’s captured outputs, not a re-run score.
Other hosted modelsNothing.Available in the model selector.Not independently evaluated.
Illustrative mockup — not a live session

Stage by stage: generation to substation

A generation plant and then its substation, walked through their design stages. The design basis is entered once; each stage says valid, incomplete, failed, stale or missing, and nothing passes by default. The plant’s fault contribution reaches the substation as a versioned hand-off, and a breaker that was adequate on the grid alone turns out not to be with the plant. A short coda runs the same pattern on a transmission line. It replays on its own until you touch it.

Staged design · generation to substationIllustrative values
Design0 of 12 stages run

Scripted, not live. Every number here comes from running the harness design workflow offline (generation, substation and transmission, run in-process at export time). The routes behind the chips are live in the REST API, but this demo does not call them, and the cards are scripted. The fault-study and sag-tension stages call sibling harnesses; whether the deployed gateway can reach them is not verified, so no working REST chain is claimed. The breaker ratings are illustrative: 19.5 kA is a minimum the harness found, not a product. The hand-off is a JSON object a person passes between two designs, and contract version 1 has no field for the state of the stage it came from. The status card never shows an overall verdict, and the export (.json) is illustrative: no file is produced. The loop runs about 100 seconds.

Harness maturity: generation, substation and transmission design workflows are draft, unvalidated harnesses; stages marked incomplete were not fully evaluated and should not be read as passed.

Illustrative mockup — not a live session

One design, six harnesses

A grid-fed datacenter hall, reviewed from the tap line to the cooling loop. Each harness checks its own stage and hands a result to the next. Two problems only show up when the stages are read together: the available fault current against the service device, and a hall that is redundant behind a station that feeds it on one circuit. Watch one run, then hover a card to see where its fix lands and approve or dismiss it yourself. It replays on its own until you touch it.

Cross-domain review · grid to rackIllustrative values
Review0 approved · 0 dismissed

Scripted, not live. Every id, name and sequence here is made up to show the interaction; the numbers are values from the harnesses’ own worked examples and are illustrative. In a real session each harness only proposes: a person approves or dismisses every fix, and the dismissed station-feed risk stays open. The status card never shows an overall verdict, and the export formats (.pdf, .json, .csv) are illustrative: no file is produced. The loop runs about 90 seconds. The station-to-service source-strength hand-off is by contract between harnesses, not a shipped pipeline.

Harness maturity: tap line, station, duct bank and service gear: draft, unvalidated harness (the tap line scene is a composite of bulletin worked examples; duct-bank grouping factors are secondary-sourced, and treating separate banks as thermally independent is a demo assumption; the service check does not gate on X/R). Hall: v0.1 draft, unvalidated harness. Cooling: v0.1 draft, unreviewed harness (velocity limits are ASHRAE guidance via secondary sources).

Illustrative mockup — not a live session

Why the shared graph matters*

A 600 kW solar unit asks to connect at one point on a feeder, and no single harness can screen it: the existing generation lives in one place, the fault current belongs to the circuit harness, the device rating to the feeder protection, the upstream breaker to the substation harness. Watch the same question twice: first with every fact asked back to you, then with the shared entity graph switched on, so the facts a screen needs can be looked up instead of asked for. Click the switch, hover the options, approve or dismiss the proposals yourself. It replays on its own until you touch it.

Shared entity graph — one interconnection requestIllustrative values
POI-7 · Feeder 120 approvals

Without the graph the harness has to ask for every fact; the screens themselves take those numbers as inputs today.

The shared entity graph is a graph of poles, vaults, breakers, service points and findings that harnesses read from and write to. Today one harness writes findings into it; the DER-at-a-POI aggregation and path queries shown here are real queries; the fault-current and device-rating joins are the planned next write-back, drawn dashed.

Scripted, not live. Every id (POI-7, R-12, F-12, BKR-3, DER-5, DER-7), value and the sequence of steps are made up to show the interaction; the feeder is generic. DER fault contributions use an illustrative pairing of 0.4 A per kW, a convention of this mockup and not an engineering estimate. The three screens are the FERC pro forma SGIP 2.2.1.2, 2.2.1.4 and 2.2.1.5; the harness docs record that section numbering from a FERC-hosted copy of the pro forma dated August 2018, and later FERC orders are not reflected. The pro forma is a template: what binds a real interconnection is the governing tariff or state procedure. The interconnection and substation harnesses are each a draft, unvalidated harness, and the breaker rating screen can only come back incomplete or failed, never as a pass. There is no overall verdict here and nothing is a Fast Track eligibility decision. The export formats shown (.pdf, .json, .csv) are illustrative; no file is produced.

One toolset, either path

This isn't a separate product from the API — it's the same domain, the same key, the same SDK. The only choice is how much of the front end you want to build yourself versus have us build for you.

Pick a domainTalk to us about an assisted build