JumperFree

Describe the nets.
Skip the jumpers.

Tell an agent which pins belong together. A deterministic router turns that into a connection plan you can read, down to what opens and what closes, before anything on the board moves.

The host software is open source today. The board is still in development and not for sale.

“Put the sensor’s SDA and SCL on the dev board’s I²C pins.”

SDA  Clip1  Clip12
SCL  Clip2  Clip13
Sixteen-Clip board diagram. SDA joins Clip1 and Clip12; SCL joins Clip2 and Clip13.0123456789101112131415
Plan
dry run · nothing moves
Nets
SDA, SCL
Routes
2 candidates
Opens first
none
Touches
no other nets
Verified
false
An illustrative, simplified plan. The open-source host software plans like this today against a mock device; the drawing is a diagram, not a photo of hardware.

The code is done.
The wiring isn’t.

Every bench build ends the same way: look up the pinout, push in the jumpers, trace each one twice, and start over when a lead sits one row off.

JumperFree moves that work into software you can read. You say what should be connected. The software decides how, shows you, and only then would the board act.

Four lanes.
One request.

Language is fuzzy; wiring can’t be. Each layer does one job and hands a checkable artifact to the next, so you can always see where a decision was made.

  1. Agent

    Reads your ask and writes nets: a name and the Clips it joins. It never picks a path or touches a switch.

    SDA: Clip1, Clip12

    Runs today as seven MCP tools

  2. Router

    Finds paths through the crosspoint. The same nets in always give the same plan out. No guessing.

    plan: breaks, makes

    Runs today in the host software

  3. Controller

    Takes a checked plan over USB and applies it, opening paths before it closes new ones.

    switch states

    Protocol core tested on a host; not yet on the STM32

  4. Board

    Sixteen Clips of five holes, each one electrical node. LEDs are meant to show where each part goes.

    connection

    In design; not built yet

Read the plan
before it runs.

Planning is a dry run. You see which switches would close, which would open, and which other nets they would touch. Nothing moves until you decide.

plan_net_change(action="create", name="SDA", nodes=["Clip1", "Clip12"])

Ask for a plan using the same arguments that would carry it out.

router

Candidate routes through the crosspoint. A software result, not the current wiring.

plan.makes

Switches that would close.

plan.breaks

Switches that would have to open first.

plan.disturbed_nets

Existing nets the change would touch. Empty means nothing else moves.

verified: false

Always false for now. A plan is never proof of a connection.

Field names come from the open-source agent tools: create_net, modify_net, delete_net, get_state, plan_net_change, guide_leds and all_open, served to any MCP-capable agent over stdio.

What’s real today.

JumperFree is early. Here is the line between what runs and what is still on the drawing board.

Working in software

  • Nets to a deterministic route to a switch plan, in the Python host software.
  • Seven agent tools over an MCP server, including dry-run planning.
  • LED guidance and all-open commands, exercised against a mock device.
  • A portable C protocol core for the controller, tested on a host machine.

Not built yet

  • Controller firmware running on the STM32, switching through the CH446Q.
  • A physical sixteen-Clip board with LEDs under your hands.
  • An end-to-end loop proven on real hardware.
  • A price, a ship date, or a way to buy one. None exist yet.

Follow the build.

Leave an email for occasional updates as the board takes shape. If you like, tell us what you would wire first.

Read the code on GitHub

Your email is used only for JumperFree updates.