AI agents for electronics teams

The harness for
electronics engineering.

Electronics is unforgiving — the harness is what makes AI safe for it. Circuitly connects your schematics, revisions, firmware, requirements, datasheets, and supply data into one loop where agents work and engineers decide. Start today with AI schematic review, grounded in that full context.

Start a schematic review Talk to us about your AI strategy
Native ECAD files  ·  Full auditability & traceability  ·  Built for regulated, IP-sensitive environments  ·  Self-hosted for enterprise
File Review View Tools sensor_gateway_revC.kicad_sch rev-c-review Share
Review agent active
rev C pushed · sensor_gateway @ a41c9e2
2 files changed · schematic + firmware
Context assembled
schematic Δ rev B→C requirements.md firmware/adc_cal.c TPS54331 datasheet stock & EOL feed team-checks.md
POTENTIAL ISSUE · HIGH
Feedback divider changed — VOUT drifts out of spec
R7 22 kΩ → 27 kΩ in rev C sets VOUT to 3.42 V. REQ-PWR-04 requires 3.30 V ± 2%, and firmware ADC scaling still assumes 3.30 V.
sch diffREQ-PWR-04datasheet §8.2adc_cal.c:118
Confirmed by J. Park — revert R7, recalibrate ADC in rev D
Review report — rev C (PDF)12 findings · share it with anyone — no account needed Download
Sheet: sensor_gateway_revC
Rev: C  ·  Size: A4  ·  Circuitly — KiCad 9
U3 TPS54331 R6 10k R7 27k VIN_12V VOUT_3V3 FB L1 10 µH
VOUT 3.42 V — REQ-PWR-04 expects 3.30 V ± 2%
Reviewing rev C with full design context
One review, connected revision pushed → context assembled → agent reviews → engineer decides → PDF shared

Three ways to start

One harness. Clear engineering outcomes.

Start with a concrete review or generation workflow, or connect a broader ECAD team around agent orchestration. Each path keeps engineers in control and the design record traceable.

AVAILABLE NOW

AI schematic review

Review revisions with your full design context — requirements, firmware, parts, and your own standards — and share a polished PDF report.

Explore schematic review
EARLY ACCESS

AI schematic generation

Generate reviewable native schematics from requirements, approved libraries, datasheets, and team standards.

Explore schematic generation
ENTERPRISE

AI harness for ECAD teams

Orchestrate agents across the tools, context, checks, and human approvals already inside your engineering system.

Explore the ECAD harness

Use cases

Begin with work your team already recognizes.

Each use case explains the engineering problem, connected workflow, useful output, and the decision that remains with the team.

BEFORE LAYOUT

New schematic review

Architecture, requirements coverage, potential issues, and open questions.

Open use case
EXISTING DESIGN

Legacy design understanding

Reconstruct intent and dependencies before a respin or ownership change.

Open use case
CROSS-TEAM

Design handoff

Carry constraints, decisions, and open questions into the next workstream.

Open use case
See all hardware use cases
The substrate

Every tool contributes. One loop ties them together.

A finished PCB is thousands of trade-offs across the whole product. The harness is the connective tissue: one loop agents can act on, constraints checked where they live, full traceability — so rapid iteration is safe and nothing is lost between tools.

Circuitly

one loop through the electronics lifecycle

AGENT waiting for the next revision…
one revision, reviewed with full context — plays automatically
A browser-based harness, multiplayer, optionally self-hosted for regulated and FedRAMP environments — so teams iterate faster while accounting for more trade-offs and design decisions.
Why AI hasn't been solved for PCB design

Getting value from LLMs is its own discipline.

Context, experiments, model choice, orchestration, guardrails — and none of it is electronics engineering. The harness absorbs that burden, so your team designs hardware instead of operating AI.

Engineering-grade precision

Electronics doesn't forgive "almost right." Every agent edit runs against your design rules, gets checked before merge, and lands as a reviewable diff. Precision is enforced by the harness — not hoped for from the model.

Model ops, out of the box

Which LLM reasons best over datasheets? When does a deterministic solver beat a model at routing? The harness runs that experimentation continuously — benchmarking LLMs and deterministic tools per electronics use case, re-tuning as they evolve. You never touch a model picker.

Un-siloed by design

Schematic, layout, sourcing, supply risk, PLM, fab — each lives in its own tool, and context dies at every handoff. The harness is the connective layer: one workspace where context carries across the whole chain.

Why not just an LLM + MCP?

One model isn’t enough. Value takes specialized agents with domain-expert tools.

A chat window with MCP tools is still one loop — and one loop can’t hold a board. Circuitly’s agents run on tools that know electronics: what that sense resistor is doing in this circuit, what the datasheet allows, what industry standards expect — and merge their work into one reviewable change.

FileEditToolsView INA226-PowerMonitor
LED sunglasses that use PCBs as the frame, with cross-hatched cutout…
Conversation Plans Skills Memory
Agent Activity
Terminology

The vocabulary — and why we say harness.

01Agent

An LLM with tools and its own loop: it opens your files, runs a check, reads the result, and adjusts until the job is done. Without tools, a model can only talk about your design. With them, it can act on it — and verify what it did.

02Sub-agent

A focused agent spawned for one bounded piece of the job — verify this footprint against its datasheet, source this part, check this net. Small scope is the point: bounded work produces output you can actually check.

03Orchestrator

Splits a board-level change into parallel, bounded tasks, decides which agents run and in what order, and merges their work into one coherent change. One model doing everything at once is how context gets lost mid-schematic.

04Harness

Everything around the agents that makes them usable and safe: the workspace they act in, tools, memory, guardrails, review, rollback. The layer you actually work at. This is Circuitly.

Harness workspace · tools · memory · guardrails · review · rollback
Orchestrator
Agent its own loop
Agent its own loop
Sub-agents spawned · bounded
Git-native substrate — every agent action is a commit you can review and roll back.

Why the layers matter: pin 4 either connects to pin 7 or it doesn't — but ten engineers will give you three defensible footprints for the same part. Electronics is precision and judgment side by side, so the harness runs two kinds of machinery.

Deterministic — one right answer

Netlist connectivity, ERC/DRC, pin-to-datasheet checks, BOM math. These run as code — same input, same result, every time. If a check can be written as a rule, it is never left to a model.

Agentic — judgment calls

Footprint variants, symbol style, layout tradeoffs, end-of-life substitutions. Engineers legitimately disagree here — so agents propose with their reasoning attached, learn your conventions, and leave the call to you.

The harness knows which is which. Every agentic proposal must pass the deterministic checks — ERC, DRC, datasheet match — and land as a reviewable diff. Judgment where it belongs, proof everywhere else.

How it works

Prompt, plan, build, merge.

You express intent in hardware terms. The harness runs the AI underneath.

1

Prompt

Say it in hardware terms — "add gigabit Ethernet: PHY, magnetics, and length-matched RGMII." No prompt engineering, no context wrangling. That's the harness's job.

2

Plan

Agents propose before they touch anything. Datasheets, supply data, library rules, and your existing files come in as context — you approve the plan.

3

Build

Agents place, wire, route, and check in your real files — in parallel, server-side. Close the tab; they keep working while you sleep.

4

Merge

Come back to finished branches. Review visual diffs, roll back anything, merge what's right. Git underneath — you in the loop.

Circuitly workspace: an AI agent generates an engineering change order for net label additions on a differential probe schematic, with the plan and Git branch shown alongside the native ECAD file
The harness at work — an agent plans an ECO, documents what changed and why, and waits for your sign-off.
The substrate

Real files. Real tools. No lock-in.

An agent is only as useful as the place it can act. So we built the substrate: a real PCB design tool, in the browser, git-native — where agents read and write the actual files.

Native ECAD files

Agents read and write real KiCad, Altium, Cadence, and Siemens files. No proprietary intermediate format.

Git-native

Every agent edit is a commit on a branch. Full traceability, visual diffs, one-click rollback across the whole tree.

Guardrails built in

Plan-then-edit review, bounded sub-agents, and design-rule checks on every change. Nothing merges without you.

Self-hosted for enterprise

Deploy the harness inside your own infrastructure. Your designs never leave your network.

Circuitly workspace on an Altium PCB layout: an agent researches the schematic and returns a prioritized breakdown of manufacturing risks — missing MPNs, BOM purchasability, CM substitution risk — with actions to reduce them
Ask "what's my biggest manufacturing risk?" — agents research the design and answer with actions, right on the board.
The reframe

Not another tool. The layer above them.

Getting value from LLMs is its own discipline — context, experiments, orchestration, guardrails — and none of it is electronics engineering. The harness absorbs it.

The old framing — a tool

"AI that helps you draw PCBs"

One more app in an already-fragmented toolchain
You drive the agents, write the prompts, babysit the session
Context lost at every handoff between tools
Sells features — someone on your team becomes the AI operator
A new model ships and you're re-benchmarking, rewriting prompts
Circuitly — the harness

The workspace agents work in

The connective layer above your tools — context carries across the chain
Agents act on real files and keep working after you close the tab
Absorbs the AI burden — you express intent in hardware terms
Coordinated, governed, reviewable — your other tools become things the harness can call
Model choice and configuration handled underneath — re-tuned as models evolve

Frequently asked questions

What is Circuitly?

Circuitly is a harness for AI PCB design: a browser-based workspace where AI agents place, wire, route, and check electronics designs directly in your real ECAD files. Agents run asynchronously on the server, and every change lands as a reviewable Git commit.

How is Circuitly different from using ChatGPT or an AI copilot for circuit design?

A chatbot gives advice; you still do the work. Circuitly's agents act — this is agentic circuit design, inside a PCB design tool we built, on your actual files. The harness carries context across schematic, layout, sourcing, and review, so nobody on your team has to become an AI operator.

Which ECAD tools does Circuitly support?

Agents work natively in KiCad, Altium, Cadence, and Siemens files today — full interoperability for enterprise contracts. Designs stay in standard formats under Git — no proprietary intermediate format, no lock-in.

What can the agents actually do?

Place and wire components, route connections, run design rule checks, research parts, generate symbols and footprints, check BOMs against sourcing data, and run AI design review on every change before merge — each agent running its own loop, in parallel.

Do the agents really keep working when I close the tab?

Yes. The workspace is server-side and asynchronous, so agents keep placing, routing, and checking after you leave. You come back to finished branches to review — nothing merges without you.

Which AI models does Circuitly use?

The right one for each action. The harness benchmarks frontier models against real PCB tasks — placement, routing, datasheet reasoning, part research — and assigns each action the model that performs best. As models evolve, the harness re-benchmarks and re-routes; your workflow doesn't change.

Can we self-host Circuitly? Is our design data safe?

Enterprises can deploy the harness inside their own infrastructure, so designs never leave your network. Every agent action is a Git commit — full traceability, visual diffs, and one-click rollback.

Build an AI strategy around the engineering system.

Bring us the workflow, toolchain, and controls your hardware team needs. We’ll help define where AI belongs and how to connect it safely.

Talk to us about your AI strategy Explore use cases