DCENT_Konduit — D-Central Technologies
DCENT_Konduit: An Agentic Harness for Electrical Engineering
Every AI coding harness ever built assumes the artifact is software. DCENT_Konduit assumes it is hardware. It is an open-source Model Context Protocol engine that gives an AI agent real hands inside KiCad — 570+ tools spanning schematic capture, component selection, placement, routing, ERC/DRC and the full fabrication export pipeline. Beta, AGPL-3.0, and free for anyone who is not a corporation.
The Models Already Know Electronics. They Have No Hands.
Ask a frontier model about decoupling strategy, return paths, LDO dropout, or why your buck converter is singing at 12 kHz, and you will get a genuinely good answer. Ask it to place the capacitor, and it can only describe where you should put it. The knowledge is there. The tooling is not — because every agentic harness on the market was optimized for one artifact: source code.
Software Got the Whole Toolbox
A coding agent can read a file, edit it, run the test suite, read the failure, and try again. That loop — act, measure, correct — is the entire reason AI coding works at all. It exists because someone built the tools for it.
Hardware Got a Chat Window
The hardware equivalent of that loop barely exists. The model cannot place a footprint, pull a net, refill a zone, or read back its own DRC report. So it advises, a human transcribes, and the feedback loop that makes agents useful never closes.
Konduit Closes the Loop
Act: place, wire, route, pour. Measure: run ERC and DRC through stock kicad-cli, the same binary a fab-bound engineer trusts. Correct: read the violations back and fix them. Same loop as code, aimed at copper.
Beta. Here Is Exactly Where It Stands.
This project keeps an internal blocker ledger and a release policy that forbids anyone — including us — from calling a generated package “fabrication-ready” until it survives every gate. We would rather publish the ledger than the press release.
What Works Today
The toolchain is real and exercised: schematic authoring, netlist sync, placement, routing including a bounded push-and-shove, zone fills, ERC and DRC through kicad-cli, and a complete fab package — Gerbers, drill, BOM, pick-and-place. Two independent harnesses have each taken a stated goal all the way to a DRC-clean package with zero unconnected items.
What Does Not Work Yet
Autonomous design of a complex board is not solved. Manufacturer-grade component qualification, impedance and mixed-signal closure, thermal reasoning, and repeatable results across dense multi-layer work are open problems on our ledger. A small regulator board is a demonstration, not a hashboard.
The Rule We Hold
kicad-cli is the sole authority on ERC and DRC. Not our tools, not the model’s self-report. If Konduit says a board is clean and stock KiCad disagrees, KiCad is right and we have a bug. That rule is what makes any number on this page checkable by a stranger.
What the Agent Can Actually Touch
570+ tools across 80+ loadable toolsets, covering the path from an objective to a folder a fab house will accept. Not a chat plugin that writes netlists into a text box — a working surface on your actual project files.
Schematic
Place symbols, wire them pin-to-pin by reference and pin name, drop power symbols and net labels, resolve junctions, run connectivity analysis, annotate, and export. Files are edited through a native S-expression engine with atomic writes and UUID preservation — the agent does not text-munge your schematic and hope.
PCB
Board outline, stackup, design rules and net classes, footprint placement, trace and arc routing, differential pairs, vias, stitching, copper pours and zone refill — driven live through KiCad 10’s IPC API, so every edit lands in the running editor and in its undo history.
Verify & Ship
ERC, DRC, courtyard and clearance checks, decoupling and power-rail audits, then the fabrication package: Gerbers, drill files, BOM, pick-and-place, 3D export, PDF. Plus offline part search against a local JLCPCB catalog, so component selection does not need a browser or an API key.
It ships as a single self-contained binary — no Node, no Python, no wxWidgets, nothing to version-match — and it is a plain stdio MCP server, so it is harness-agnostic and model-agnostic by construction. Six workflow skills and two review agents ship with it, so the model arrives already knowing KiCad conventions instead of guessing them.
Benchmarks, Because Nobody Else Is Measuring the Board
The public benchmarks for AI in electronics score whether a model can talk about a PCB — multiple-choice questions, free-form answers, image captions. None of them score a DRC violation, a via count, or whether the output survives a fab gate. A model can top that leaderboard while being categorically unable to emit a board anyone could build. Every AI-EDA vendor markets into that vacuum, because no instrument exists to contradict them. We are building the instrument.
KonduitBench — the public one
A tiered set of plain-English design goals, scored only on physical artifacts: DRC violations by severity, unconnected items, routing completion, via count, copper length, and whether the fab package survives its own gate. Every metric is computed by stock kicad-cli, so anyone can reproduce or refute our numbers without installing a single line of our code. It is designed from the first commit to be able to make us look bad in public — a benchmark that cannot embarrass its author is marketing.
KiCadBench — the internal gate
The regression harness that answers a narrower question: did Konduit break? Deterministic replays of fixed tool-call plans with no model in the loop, tiered task definitions, and a named check registry — run before anything ships. Boring, unglamorous, and the reason a release can be trusted at all.
The harness scoreboard
Same goal, same MCP, different drivers — so the score reflects the model, not our plumbing. Two commercial harnesses have each carried a goal to a DRC-clean fab package. A local open-source model has driven the full tool loop on a CPU-only box; a complete board build by an open model is bounded by that machine’s compute, not by Konduit. Anyone with a GPU can close that gap and publish the result.
There is a harder problem underneath all of this, and we would rather name it than hide it: a schematic can be ERC-clean, DRC-clean, fully routed — and still wrong. It routes the wrong thing, correctly. Wire SDA to a pin the model merely remembered was SDA, and if that pin happens to be bidirectional, every automated check passes and the board does not work. ERC validates graph legality, not design intent. The next layer of Konduit is a set of fail-closed guards aimed squarely at that class of failure, and it is being specified in public before it is written.
Standing on the Shoulders of Giants
Konduit is not a first idea. It is what we built after learning from the people who tried first, and none of it would run without decades of work we did not do.
The KiCad MCP Servers Before Us
Several people wired KiCad to the Model Context Protocol before we did, and they proved the core premise: an AI can drive an EDA tool. We learned from all of them. What we kept running into was the same wall — those servers could inspect and assist, but none of them could carry an agentic workflow all the way to buildable hardware. That gap is the entire reason Konduit exists, and we owe the people who found the edge of the map.
KiCad Itself
Konduit is a passenger. KiCad’s developers built a professional-grade EDA suite, gave it away, and then went further — an official IPC API and a scriptable kicad-cli that make an outside agent possible at all. Support them at kicad.org; the whole open-hardware world is running on their unpaid weekends.
MCP, Freerouting, and the Catalogs
The Model Context Protocol gave every tool-builder one common socket instead of a bespoke integration per model. Freerouting carries decades of autorouting research nobody should have to rewrite. And the open parts catalogs make offline component selection possible. We wrote the connector. Others wrote the hard parts.
Open Source — and We Mean the Boards Too
DCENT_Konduit is released under the GNU AGPL-3.0. Not source-available, not a trial, not an open core with the useful half behind a login — the whole engine, readable and forkable. That choice costs us money and we made it on purpose.
Free for the Little Guys
Hobbyist, student, freelancer, open-source contributor, one person with a soldering iron and an idea: use it, no strings. Design boards. Build them. Sell them. Hardware design has been gated behind five-figure seats and NDA’d part libraries for forty years. That gate is the thing we are trying to remove.
Our Ask, Not Our Terms
We hope the hardware built with Konduit gets open-sourced too. The licence does not require it and we are not going to pretend it does — this is a request, from people who have shipped open hardware and know what it costs. Publish the schematic. Publish the Gerbers. Someone will improve your board and hand it back.
Information Wants to Be Free
Right now, as capability concentrates into a handful of closed models owned by a handful of companies, is precisely the wrong moment to start hoarding knowledge. Decentralization is not a slogan we bolt onto a product page — it is why DCENT_OS, the Toolbox, the axe and now Konduit are all public. Release the knowledge.
Who Pays for This
D-Central is a build-to-order hardware shop in Montreal, Quebec. Konduit is funded out of that work and out of what the community contributes. There is no venture round behind it, which is exactly why it can stay AGPL and why the benchmark is allowed to make us look bad.
Fund the Work
If Konduit saves you an afternoon, or if you just want an open EE harness to exist in the world, fund the sovereign stack. Contributions go to development time on Konduit and the rest of the DCENT suite. Every dollar buys hours that go back out under a free licence.
Commercial Users: Subscribe
If you are designing hardware commercially with Konduit, a support subscription is the right way to use it. You get direct support, priority on issues and blockers that affect your boards, and input on the roadmap — and the project stays funded and free for everyone else. Talk to us about what your team needs.
Or Just Break It
Funding is not the only currency. Run it against a board we never anticipated, find where it falls over, and open an issue with the project files. Bug reports from people doing real work are worth more to a beta than money is. So are pull requests.
Frequently Asked Questions
Will it design my board for me while I sleep?
Not yet, and anyone telling you their tool does is selling something. Konduit can carry a simple, well-specified board from an objective to a DRC-clean fabrication package without a human touching the mouse — that has been done, with stock kicad-cli as the judge. A dense multi-layer design with impedance control and thermal constraints is a different problem, and it is still open on our ledger. Review the output. Always.
Which AI models does it work with?
Any of them that speak MCP. Konduit is a plain stdio MCP server, so it is agnostic to both the harness and the model by construction — commercial frontier models and locally-hosted open-source models alike. We test across several deliberately, because a tool that only works with one vendor’s model is just that vendor’s product with extra steps.
Do I need to send my design to a cloud service?
No. Konduit runs entirely on your machine, against your files, with a local parts catalog. Whatever model you point at it is your choice — including a local open-weights model, in which case your design never leaves the building. That is the whole point of the sovereignty stack.
What do I need to run it?
KiCad 10 and its bundled kicad-cli, plus an MCP-capable AI client. Konduit itself is one self-contained binary with nothing to install alongside it. PCB tools talk to a running KiCad through its IPC API, so the board editor needs to be open; schematic editing works without KiCad running at all. Windows today, with Linux and macOS packaging on the roadmap.
Is my company allowed to use it?
Yes. Running Konduit in-house to design your own hardware does not trigger the AGPL’s sharing obligations — those attach to distributing the software itself, including offering a modified version over a network. If you are building Konduit into a product or a hosted service, read the licence properly and talk to us first. And if you are using it commercially, please subscribe; that is what keeps it free for the person in a garage.
Why is a Bitcoin mining company writing EDA tooling?
Because we needed it. D-Central repairs and builds mining hardware, and hashboard work is exactly the kind of dense, repetitive, well-constrained design where an agent should help and could not. Konduit is a tool we built for our own bench and then decided not to keep. The same reason DCENT_OS and DCENT_Toolbox are public.
Related products, repair, and setup paths
- how D-Central diagnoses ASIC repairs
- ASIC troubleshooting library
- ASIC manuals and repair guides
- replacement hashboards
- ASIC control boards
- ASIC power supplies
- S19 family replacement hashboard
- C52 replacement control board
- APW12 S19 power supply
- immersion cooling hub
- home immersion cooling guide
- ASIC miners for immersion planning
- ASIC cooling parts
- airflow shroud before immersion
- compare miner specs in the database
- ASIC repair support
- Antminer S21 specs
- Bitmain Antminer S21
- Antminer S21 maintenance guide
- BM1370BC S21 Pro chip
- Antminer S9 specs
- Bitmain Antminer S9
- Antminer S9 maintenance guide
- S9 hashboard repair parts bundle
Last reviewed July 31, 2026.