canonical: https://jentic.com/apis/electronics-architect.com/electronics-architect

# Electronics Architect API

The Electronics Architect API solves power-architecture designs: you describe a power tree and its server-side solver returns the converged numbers, the input current, efficiency, and dissipation of every stage, with load-dependent converter efficiency, tolerance corners, and thermal estimates in one pass. It runs Monte Carlo tolerance analysis and derating checks against the NASA GSFC and IPC-9592 standards, stores and versions cloud designs, compares two designs, and exports a BOM or the solved result. It can also review a solved design or synthesize one from a plain-English brief, using the same solver behind the editor an engineer opens to edit, export, and share.

## For AI agents

Solve a power tree for the current, efficiency, and dissipation of every stage, run Monte Carlo and derating checks, and store, compare, or export designs through one metered API.

## Scope

Does not handle PCB layout, schematic capture, or component purchasing. Use for solving and analyzing power-architecture designs only.

## Capabilities

- Solve a power tree for input current, efficiency, and dissipation at every stage
- Run Monte Carlo tolerance analysis across a design's corners
- Check a design's derating against the NASA GSFC or IPC-9592 standard
- Store, version, and compare cloud designs
- Export a BOM, the design JSON, or the solved result
- Review a solved design or synthesize one from a plain-English brief

## Use cases

### Agent-run power-design checks

An engineering agent verifies a power design without a desktop tool. Through Jentic the agent validates the design's structure, solves one tolerance corner for the current, efficiency, and dissipation of each stage, and runs a derating check against the NASA GSFC or IPC-9592 standard, returning numbers an engineer can act on. The result carries a fingerprint the agent can later re-verify.

Example prompt: Validate a power-tree design, solve one corner, and run an IPC-9592 derating check, then report the per-stage dissipation

### Tolerance analysis before a board spin

A designer wants the spread, not just the nominal case. The Monte Carlo operation runs a tolerance analysis across the design's corners as a metered job, so a workflow can quantify how converter efficiency and dissipation vary before committing a board. Starting a job runs the first slice immediately and the rest are polled.

Example prompt: Start a Monte Carlo job on a design and poll it until the tolerance analysis across corners is complete

### Design from a plain-English brief

An agent turns a requirement into a starting design. The synthesize operation generates a power design from a plain-English brief, and the solve and review operations then compute the numbers and explain what they mean and what to change. A design can be stored, versioned, and exported as a BOM for sourcing.

Example prompt: Synthesize a power design from a brief, solve it, and export the BOM for the resulting design

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/v1/designs/solve` | Solve one tolerance corner |
| POST | `/v1/designs/monte-carlo` | Run Monte Carlo tolerance analysis |
| POST | `/v1/designs/derating` | Run derating analysis against a standard |
| POST | `/v1/designs` | Create a cloud design |
| POST | `/v1/designs/{id}/exports` | Export a BOM or the solved result |
| POST | `/v1/designs/compare` | Compare two designs |
| POST | `/v1/designs/validate` | Validate a design's structure |
| POST | `/v1/ai/synthesize` | Synthesize a design from a brief |

## Key resources

- **Solve** — Solve a corner, run Monte Carlo, and run derating analysis on a design
- **Designs** — Create, read, version, share, and delete cloud designs
- **Jobs** — Metered Monte Carlo jobs started and polled for results
- **Exports** — BOM, design JSON, and solved-result exports
- **Library and templates** — Curated part models and shipped design templates
- **AI** — Design review and synthesis from a plain-English brief

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 47 / 100
- **Maturity:** Foundational
- **Dimensions:**
  - Foundational Compliance: 45 / 100
  - Developer Experience & Jentic Compatibility: 65 / 100
  - AI-Readiness & Agent Experience: 26 / 100
  - Agent Usability: 94 / 100
  - Security: 60 / 100
  - AI Discoverability: 57 / 100
- **View full report:** https://jentic.com/apis/electronics-architect.com/electronics-architect/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring the Electronics Architect API by hand means handling its bearer API key, managing metered Monte Carlo jobs that you poll for each slice, and parsing the solved power-tree result yourself. Through Jentic you install once, import Electronics Architect from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Electronics Architect puts the design and job id in the URL path (`/designs/{id}/...` and `/jobs/{id}`), so a rule can pin your agent to the solve and analysis operations it needs. Deleting a design or cancelling a job is not included unless you add it.
- **Credential handling:** Your Electronics Architect key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'solve a power tree' or 'run a derating check', and Jentic returns the matching Electronics Architect operation with its input schema so the agent calls the right endpoint without reading the reference docs.

## Related APIs

- **Octopart** — Searches electronic part data, offers, and specs across distributors
- **Digi-Key Product Information** — Returns pricing, availability, and specs for electronic components

## FAQ

### What authentication does the Electronics Architect API use?

The Electronics Architect API authenticates with a bearer API key per its OpenAPI spec: you create a key in the editor's developer settings and send it as `Authorization: Bearer ea_live_...`. The OpenAPI document itself is public. Through Jentic the key is stored encrypted by your own Jentic One instance and injected at call time, so it never enters the agent's context.

### Is there an Electronics Architect MCP server?

You don't need a separate MCP server to give your agent the Electronics Architect API. Jentic connects it directly from the API Directory: import it, store your key once, and your agent calls the solve, derating, and export operations on demand without loading another server's tool definitions into its context.

### Can I run a derating analysis with the Electronics Architect API?

Yes. The derating operation checks a design against the NASA GSFC or IPC-9592 standard, and alongside it you can solve a single tolerance corner or run a full Monte Carlo tolerance analysis as a metered job you poll for results. Each solved result carries a fingerprint you can later re-verify.

### What are the rate limits for the Electronics Architect API?

The OpenAPI spec does not publish specific rate limits, though the account endpoint reports this month's usage against your plan. Check the provider's documentation at https://electronics-architect.com for the current limits on your plan.

### Can I limit what my agent is allowed to do with the Electronics Architect API?

Yes. Write a rule that allows only the solve and analysis operations your agent needs, so it can compute and export results but cannot delete a stored design or cancel a job. Every call it makes is logged.

### How do I solve a power tree with the Electronics Architect API through Jentic?

Search Jentic for 'solve a power tree' and it returns the solve operation with its input schema; your agent passes the design and reads back the per-stage current, efficiency, and dissipation. To run it on your own infrastructure, install Jentic One from its GitHub repo.