CircuitRescue

CircuitRescue is a skill-governed engineering agent that helps teams safely evaluate component substitutions, execute approved validation workflows, and generate traceable, reproducible evidence.

Comment

Inspiration

Electronic and industrial automation products often depend on specific components that may suddenly become unavailable because of supply-chain disruptions, long lead times, discontinuation, or regional sourcing restrictions. When this happens, engineers must compare replacement components, verify electrical compatibility, modify the design if necessary, and repeat validation procedures.

This process is time-consuming and difficult to audit. Although general-purpose AI models can quickly suggest alternatives, their answers may contain unsupported assumptions, invented specifications, or recommendations that have not been verified with engineering tools.

CircuitRescue was created to address this problem. Instead of allowing AI to freely invent a repair or replacement solution, we designed a skill-governed engineering agent that can only select and execute human-approved procedures, trusted references, and controlled validation tools.

Our goal is not to replace engineers. Our goal is to help engineering teams safely reuse approved knowledge, reduce repetitive work, and generate evidence that can be reviewed, reproduced, and audited.

What it does

CircuitRescue helps engineering teams evaluate component substitutions through a controlled and traceable workflow.

The system can:

  • Understand an engineering request and convert it into a structured problem specification.
  • Search for an applicable approved Skill.
  • Check whether the required component data, circuit files, references, and tool environments are available.
  • Classify a candidate component as drop-in compatible, requiring a circuit change, requiring a PCB change, incompatible, or inconclusive.
  • Apply only pre-approved component or circuit variants.
  • Request human approval before applying a patch or performing a sensitive operation.
  • Execute deterministic engineering tools such as ERC or SPICE through restricted Tool Adapters.
  • Evaluate results using predefined Acceptance Tests.
  • Record the Skill version, Reference version, tool version, scenario seed, logs, hashes, approvals, and artifacts.
  • Generate a traceable engineering evidence report.
  • Stop safely with NO_APPLICABLE_SKILL, BLOCKED, or INCONCLUSIVE when reliable information is unavailable.

The first domain profile focuses on an industrial 24 V sensor input interface with isolation and a 3.3 V microcontroller output. This narrow scope allows us to demonstrate a realistic component-substitution workflow without claiming support for every type of electronic system.

How we built it

CircuitRescue uses a Single Agent + Multi-Skill architecture.

The Agent Runtime manages policy, routing, session state, workflow execution, approvals, and failure handling. It does not contain the engineering solution itself.

Engineering knowledge is stored in small, versioned Skills. Each Skill defines:

  • When it is applicable
  • What inputs are required
  • Which references are allowed
  • Which tools may be called
  • Which procedures may be executed
  • When human approval is required
  • How PASS, FAIL, BLOCKED, and INCONCLUSIVE are determined

Complex workflows are created by combining several single-responsibility Skills into a SkillPlan.

The first SkillPlan contains:

  1. collect-reference-detail
  2. classify-component-compatibility
  3. apply-approved-input-interface-variant
  4. run-industrial-input-acceptance
  5. generate-evidence-report

The current implementation is built with:

  • Bun and TypeScript
  • A strict workflow state machine
  • JSON Schema contracts
  • A replaceable Model Gateway
  • Event-based Session storage
  • Server-Sent Events for live progress updates
  • A Skill lifecycle and routing layer
  • A browser-based interaction interface
  • Automated unit and contract validation tests

The architecture also separates formal engineering execution from sandbox demonstrations. Sandbox data can be used to test the software, but it cannot be presented as an approved engineering conclusion.

Challenges we ran into

One of the largest challenges was defining the correct role of AI in an engineering workflow.

A language model is useful for understanding natural-language requests, extracting fields, assisting with Skill matching, and summarizing results. However, it should not become the source of electrical specifications, safety limits, or validation conclusions.

We therefore had to separate four different concepts:

  • Model output
  • Tool execution
  • Acceptance evaluation
  • Engineering approval

A tool may execute successfully while the tested design still fails its engineering requirements. For this reason, CircuitRescue does not treat a successful tool process as a PASS. Tool results must be evaluated against predefined acceptance rules.

Another challenge was maintaining traceability. A result is not useful if the team cannot identify which Skill version, datasheet revision, tool version, scenario seed, or circuit revision produced it.

We also had to prevent development fixtures from bypassing governance. Demo Skills and demo tools are useful for software testing, but they must remain separated from formal engineering sessions.

Additional challenges included:

  • Designing resumable sessions when required information is missing
  • Preventing draft or revoked Skills from being executed
  • Binding approvals to a specific patch and content hash
  • Restricting Tool Adapters with allowlists, timeouts, and sandbox rules
  • Designing reproducible random scenarios without generating fake engineering answers
  • Keeping Skills small, testable, and independently versioned

Accomplishments that we're proud of

We are proud that CircuitRescue has moved beyond a conceptual design and now includes a working software foundation.

The current prototype includes:

  • A functioning Single Agent Runtime
  • A multi-step SkillPlan
  • A structured workflow state machine
  • Fail-closed behavior
  • Skill routing and lifecycle controls
  • A replaceable Model Gateway
  • Session event recording
  • Human approval handling
  • A live web interface using Server-Sent Events
  • Versioned JSON Schema contracts
  • Automated TypeScript and schema validation tests
  • Five initial CircuitRescue Skill definitions

The existing test suite validates core runtime behavior, routing, state transitions, model fallback restrictions, draft Skill rejection, and contract correctness.

Most importantly, the architecture prevents the Agent from silently replacing missing engineering knowledge with an apparently reasonable AI-generated answer.

What we learned

We learned that building a trustworthy engineering AI system is less about making the model more creative and more about defining clear operational boundaries.

Reliable engineering automation requires:

  • Explicit data contracts
  • Versioned procedures
  • Trusted references
  • Deterministic tools
  • Restricted permissions
  • Human approval points
  • Reproducible scenarios
  • Immutable evidence
  • Clear failure states

We also learned that an engineering Agent should not be treated as a single intelligent black box. The Model, Agent Runtime, Session, Skill, Reference Registry, Tool Adapter, and Acceptance Engine must have separate responsibilities.

This separation makes the system easier to test, audit, maintain, and extend.

What's next for CircuitRescue

The next stage is to complete the first formal end-to-end engineering workflow.

Our planned work includes:

  • Integrating a real KiCad ERC Tool Adapter
  • Adding a versioned Reference Registry
  • Building a complete official Reference Pack
  • Supporting real circuit provenance and revision tracking
  • Completing the Skill Authoring Wizard
  • Implementing seeded scenario generation and replay
  • Adding a deterministic Acceptance Engine
  • Building an immutable Evidence Store
  • Binding approvals to specific Patch Proposals
  • Expanding automated evaluation and CI
  • Completing the formal and sandbox user interfaces

After the first industrial 24 V input workflow is validated, CircuitRescue can be extended to additional engineering domains, such as RS-485 interfaces, 4–20 mA inputs, DC/DC converters, and other controlled component-substitution scenarios.

In the long term, the same architecture could connect with enterprise PLM, ERP, EDA, and internal engineering knowledge systems.

CircuitRescue is not designed to be an AI that claims it can repair everything. It is designed to be an engineering execution platform that knows what it is allowed to do, knows when it must stop, and can prove exactly how every result was produced.

Built With

Share this project:

Updates