> ## Documentation Index
> Fetch the complete documentation index at: https://docs.buildwithtrace.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Frequently Asked Questions

> Common questions about Trace — the AI-native PCB design platform. What it does, how it works, how the AI understands circuits, pricing, system requirements, and more.

## General

<AccordionGroup>
  <Accordion title="What is Trace?" icon="microchip">
    Trace is an AI-native desktop application for designing printed circuit boards (PCBs). It combines professional schematic capture and PCB layout tools with AI-native design assistance. You can describe circuits in plain language, and Trace helps with component selection, schematic generation, PCB layout, and manufacturing file export. Trace is built on [KiCad 10](https://www.kicad.org/blog/2026/03/Version-10.0.0-Released/), the open-source EDA suite.

    Trace AI is also available as a web chat from your [dashboard](https://buildwithtrace.com/dashboard) — you can quickly ask questions, look up components, research circuit topologies, upload datasheets, and get answers to design questions directly from your browser, even when you're away from your workstation.
  </Accordion>

  <Accordion title="What platforms does Trace support?" icon="laptop">
    Trace runs on **macOS** (12.0 Monterey or later, Apple Silicon), **Windows** (10 64-bit or later), and **Linux** (Ubuntu 20.04+, Fedora 36+, x86\_64 via AppImage). Minimum 4 GB RAM (8 GB recommended), 8 GB free disk space.
  </Accordion>

  <Accordion title="Can I import existing KiCad projects?" icon="file-import">
    Yes. Trace is built on KiCad, so it natively opens and edits KiCad schematic (`.kicad_sch`) and PCB (`.kicad_pcb`) files. You can import existing designs, have the AI review them, get explanations of how circuits work, and make modifications.
  </Accordion>

  <Accordion title="What file formats does Trace support?" icon="file-code">
    Trace uses KiCad's native file formats for schematics and PCB layouts. It also supports ODB++, IPC-2581, and Gerber for manufacturing handoff. For 3D models, it exports STEP files. BOMs are exported as spreadsheets with supplier links.
  </Accordion>

  <Accordion title="Is Trace open source?" icon="code-branch">
    Trace is built on KiCad, which is open-source (GPL). The Trace application adds proprietary AI and cloud features on top of the KiCad foundation. The source code is available on [GitHub](https://github.com/buildwithtrace/trace).
  </Accordion>

  <Accordion title="Is my design data secure?" icon="shield">
    Your IP is yours. Designs are encrypted at rest and in transit. Trace never trains on your proprietary data without explicit consent. Enterprise plans include on-premise deployment, SSO, and audit logs for compliance requirements.
  </Accordion>

  <Accordion title="Am I locked into Trace?" icon="lock-open">
    No. Trace stores your designs in standard KiCad formats (`.kicad_sch`, `.kicad_pcb`). You can open any Trace project in vanilla KiCad at any time, and import any existing KiCad project into Trace. There's no proprietary format you can't escape. If you stop using Trace, your designs are still yours in a format the entire EDA industry understands.
  </Accordion>
</AccordionGroup>

## AI & Technology

<AccordionGroup>
  <Accordion title="How is Trace different from other AI-powered EDA tools?" icon="bolt">
    Most attempts to apply AI to PCB design take one of four approaches: requiring engineers to write code to describe circuits (adding cognitive load instead of removing it), running entirely in the browser (requiring teams to upload proprietary designs to a third-party server), focusing only on autorouting (one step in a much larger pipeline), or trying to automate clicks in existing EDA tools through screen-scraping (fragile and limited to what the GUI exposes).

    PCB design isn't a single-step problem — it's multi-domain spatial reasoning across electronics, geometry, physics, and manufacturing constraints. Tools that only solve one slice of it don't make the overall workflow meaningfully faster.

    Trace takes a fundamentally different approach:

    * **Custom circuit representation** — We created a purpose-built text syntax for circuit files that language models can read and edit directly, instead of trying to make AI click through a GUI
    * **Dual interface** — The AI edits text while you work in the visual editor. Same design, two natural interfaces, real-time sync
    * **No vendor lock-in** — Built on KiCad with standard file formats. Open any Trace project in vanilla KiCad, and vice versa
    * **Desktop-first, privacy-first** — Your designs live on your machine, not on someone else's server
    * **Real-time supply chain** — Component selection is grounded in live distributor inventory, not theoretical parts
    * **Version control on every edit** — Roll back any AI change instantly. Plan mode lets you review and approve before execution

    Learn more on the [How Trace Works](/concepts/how-trace-works) page.
  </Accordion>

  <Accordion title="How does the AI actually work?" icon="brain">
    Trace's AI architecture combines multiple specialized systems:

    * **Vision Transformer (ViT)** — Claude's native multimodal vision encoder processes schematic screenshots, PCB layout images, hand-drawn circuits, and datasheets for visual understanding
    * **Language Model** — Claude Sonnet 4 (via AWS Bedrock) handles natural language circuit descriptions, design reasoning, and code generation in Trace's custom file formats
    * **Graph Neural Network (GNN)** — A 4-layer bipartite GraphSAGE encoder (256-dim) provides topology-aware component embeddings for the placement engine
    * **RL Placement Agent** — A Soft Actor-Critic (SAC) agent trained on synthetic PCB data optimizes component placement via sequential decision-making

    The placement pipeline combines classical simulated annealing (production, live today) with the learned RL policy (in active training). Claude's vision capabilities handle schematic/layout image understanding, and the language model handles all design reasoning and file manipulation. This architecture lets Trace understand circuits at a structural level — not just as text, but as interconnected graphs of components and their relationships.
  </Accordion>

  <Accordion title="What is Trace's custom circuit syntax?" icon="code">
    Trace uses two proprietary domain-specific formats — `trace_sch` for schematics and `trace_pcb` for PCB layouts. These are line-oriented formats simpler than KiCad's S-expression format, designed specifically for AI-assisted generation and editing. They support statements for components, nets, wires, footprints, traces, vias, zones, and more. The AI agents read and write these formats natively, allowing precise control over every element in your design.
  </Accordion>

  <Accordion title="How does Trace handle complex multi-layer designs?" icon="layer-group">
    Trace supports up to 32-layer PCBs with intelligent layer stackup recommendations. The AI understands impedance requirements, power plane placement, and signal integrity constraints. It automatically routes high-speed differential pairs, manages via stitching, and optimizes copper pours for thermal and EMI performance.
  </Accordion>

  <Accordion title="How does Trace handle impedance, thermal, and manufacturing constraints?" icon="ruler-combined">
    Trace uses a stackup-first approach for controlled-impedance designs:

    1. **Define the stackup** — Layer count, copper weight, dielectric thickness
    2. **Derive trace widths** — Controlled-impedance widths are calculated from the stackup parameters
    3. **Lock before routing** — Widths are locked into net classes so traces maintain correct geometry throughout layout

    For specific constraint categories:

    * **Impedance** — Differential pairs (USB, DDR, PCIe) are routed together with spacing and length matching enforced during routing. Reference planes are tracked to keep return paths continuous
    * **Thermal** — Power components are flagged for thermal considerations, with copper pour optimization and thermal via placement
    * **Manufacturing** — DRC validates minimum trace width/spacing, via drill sizes, annular rings, courtyard clearances, and board edge clearances against your chosen fab house's capabilities
    * **Signal integrity** — High-speed nets are prioritized, via stitching near layer transitions, and length matching for timing-critical buses

    <Note>
      The stackup and impedance control features are experimental and under active iteration.
    </Note>
  </Accordion>

  <Accordion title="Can Trace generate circuit block diagrams from descriptions?" icon="diagram-project">
    Yes. Describe what you want to build — components, connections, constraints — and the model's language + graphical reasoning pipeline converts your description into a circuit block diagram. From there, Trace generates the schematic, suggests components, and handles the full design flow.
  </Accordion>

  <Accordion title="How does the AI help with routing?" icon="route">
    The AI analyzes your schematic intent, identifies critical nets, and routes them first with proper clearances. It handles escape routing from BGAs, length matching for DDR/USB/PCIe, and automatically adds test points. Trace also includes Freerouting for full autorouting. You stay in control — accept suggestions, modify them, or route manually.
  </Accordion>

  <Accordion title="What is extended thinking?" icon="lightbulb">
    When working on complex tasks, Trace shows its reasoning process in real-time via collapsible thinking blocks. The AI has a 10,000-token budget per reasoning step, allowing deep analysis of tradeoffs, constraint evaluation, and design decisions. Thinking blocks appear inline in the chat activity feed and auto-collapse when the AI moves to the next step. Click any block to expand and read the full reasoning.

    Extended thinking is active in all modes (Ask, Agent, Plan) but is most visible during Plan mode research and complex Agent tasks.
  </Accordion>

  <Accordion title="Can Trace import designs from other EDA tools?" icon="file-import">
    Yes. Trace can import from:

    * **gEDA / Lepton EDA** — Schematic files with 39 built-in symbol mappings
    * **Cadence Allegro** — PCB binary files including the v18+ format
    * **Mentor PADS** — ASCII format for PCB and schematic files
    * **Altium Designer** — Schematics, PCBs, libraries, and project variants

    See the [Importing from Other EDA Tools](/guides/importing-formats) guide for details.
  </Accordion>

  <Accordion title="What manufacturing export formats does Trace support?" icon="file-export">
    Trace generates Gerber, Excellon drill files, pick-and-place CSVs, BOM spreadsheets, assembly drawings, and 3D STEP models. It also supports **IPC-2581** and **ODB++** for advanced manufacturing handoff. All export commands support the `--variant` flag for [design variant](/concepts/design-variants) filtering, so you can generate manufacturing files for specific board configurations.
  </Accordion>

  <Accordion title="What is GNN-guided PCB placement?" icon="microchip">
    Trace's auto-placement system has two components:

    **Production (live today):** LLM-guided simulated annealing — Claude analyzes your board's constraints (signal flow, thermal, mechanical), generates a floorplan, then simulated annealing optimizes component positions within those zones. Claude evaluates candidate placements and the best result is applied.

    **In training (transitioning to production):** A Graph Neural Network (GNN) encodes your schematic netlist as a bipartite component-net graph using a 4-layer GraphSAGE encoder (256-dim). A Soft Actor-Critic (SAC) reinforcement learning agent, guided by frozen GNN embeddings, learns to place components sequentially with curriculum learning on synthetic PCB data.

    The research prototype was validated on 15 real-world KiCad PCBs (5 to 681 components) with measurable HPWL improvements. The RL agent is being trained to handle deeper constraint awareness — decoupling capacitor proximity, functional group clustering, EMI/EMC separation, thermal management — and will progressively replace the SA engine as training matures.
  </Accordion>

  <Accordion title="Can I delete my account?" icon="trash">
    Yes. Go to **Dashboard → Settings → Delete Account**. Account deletion is a soft-delete:

    * Your profile is marked as deleted and login is blocked immediately
    * Cancel any active subscription via Stripe before deleting (the deletion process does not automatically cancel subscriptions)
    * Your local design files are not affected — they remain on your machine in standard KiCad format
    * Cloud data (conversation history, cloud-synced versions) is retained for 30 days before permanent deletion

    To fully remove your account and all associated data, email [hello@buildwithtrace.com](mailto:hello@buildwithtrace.com) after deleting from the dashboard.
  </Accordion>

  <Accordion title="What happens when I run out of quota?" icon="gauge-high">
    When your monthly AI budget is exhausted, Agent and Plan modes are disabled until your next billing cycle. Ask mode (read-only Q\&A) remains available regardless of budget status. You'll see warnings at 80% and 95% usage so you can pace your remaining budget.

    If you need more usage immediately, you can purchase On-Demand credit packs ($20 or $40) from the [billing page](https://buildwithtrace.com/dashboard/billing). Credits are consumed per-request and don't expire.
  </Accordion>

  <Accordion title="What about component libraries and sourcing?" icon="warehouse">
    Trace integrates with Nexar for real-time stock availability and pricing across JLCPCB, LCSC, DigiKey, Mouser, Texas Instruments, and Amazon. The library combines KiCad's extensive component database with live inventory, verified footprints, and 3D models. The AI suggests pin-compatible alternatives when parts go EOL or face supply constraints, and can optimize for cost across distributors. Amazon sourcing is available for hobbyists and DIY projects.

    You can also ask Trace directly to check availability of any specific component — "Is the STM32F103C8T6 available on LCSC?" or "Check pricing for the TPS563200 across all suppliers for 100 units." Trace queries all supported distributors and returns stock levels, unit pricing, and alternatives if needed.
  </Accordion>

  <Accordion title="Can I use Trace in my language?" icon="globe">
    Yes. Trace understands and responds in any language. You can describe your circuit in Spanish, Japanese, French, German, Portuguese, Arabic, Chinese, Korean, or any other language — Trace will understand your design intent and respond in the same language. Component names, part numbers, and technical standards remain in their universal form, but all explanations, suggestions, and interactions happen in your language.
  </Accordion>

  <Accordion title="Can I attach files like datasheets and images?" icon="paperclip">
    Yes. You can attach images, PDFs, datasheets, schematics, and other documents directly in the chat. Trace parses and understands:

    * **Images** — Screenshots of circuits, hand-drawn schematics, board photos, oscilloscope captures, reference designs
    * **PDFs & Datasheets** — Component datasheets, application notes, reference manuals. Trace extracts pin assignments, recommended circuits, and operating parameters
    * **Documents** — Design specifications, requirements documents, BOM spreadsheets

    This is especially useful for replicating reference designs from datasheets — attach the datasheet, tell Trace what section to implement, and it builds the schematic from the manufacturer's recommendations.
  </Accordion>

  <Accordion title="Can I undo or roll back AI changes?" icon="clock-rotate-left">
    Yes. Every AI edit is versioned automatically. You can roll back to any previous state — before a specific AI change, before an entire conversation, or to any point in your design's history. Version history works both locally (offline, git-based) and remotely (cloud-synced). For complex tasks, use Plan mode: the AI presents a detailed plan for your review before executing anything, so you approve changes before they happen.
  </Accordion>

  <Accordion title="How does the context window work?" icon="window-maximize">
    Trace uses a sliding context window to maintain awareness of your full design while staying within model limits. Here's how it works:

    * **Active context** — Your current schematic or PCB file, recent conversation history, and any attached files are always in context
    * **Sliding window** — As conversations grow, older messages are summarized and compressed while keeping the most relevant design decisions and constraints accessible
    * **Agentic retrieval** — When Trace needs information from earlier in the conversation or from your project files, it automatically retrieves the relevant context rather than relying on what fits in the window
    * **Project-aware** — Trace maintains a persistent understanding of your project structure, component choices, and design constraints across the entire session, even as the raw context window slides forward

    In practice, this means you can have long design sessions without losing context. Trace remembers that you chose a specific LDO three hours ago and won't contradict that decision later.
  </Accordion>
</AccordionGroup>

## Pricing & Plans

<AccordionGroup>
  <Accordion title="Is Trace free?" icon="credit-card">
    Trace has a **Free plan** with unlimited Ask mode — read-only Q\&A and AI analysis of your designs. New accounts also get **starter agent credits** (about \$5 of Agent/Plan usage that never expires, plus a small monthly top-up) so you can try AI-driven editing for free. Once your free credits run out, upgrade to a paid plan to keep using Agent and Plan modes (AI-driven editing, routing, manufacturing output).

    <Tip>
      If a paid plan isn't in your budget right now, you can [join the Trace Beta Program](https://buildwithtrace.com/dashboard) for free. Beta members get full access to Trace in exchange for feedback and bug reports as we build.
    </Tip>
  </Accordion>

  <Accordion title="What do paid plans unlock?" icon="wand-magic-sparkles">
    Paid plans unlock progressively more powerful features:

    * **Pro** ($29.99/mo or ~$24/mo billed annually) — Full AI workflow with Agent and Plan modes, multi-layer boards up to 8 layers, specialized ERC/DRC agents, Gerber/BOM/assembly doc export, email support
    * **Ultra** ($169.99/mo or ~$135.99/mo billed annually) — Everything in Pro plus priority design queue, advanced simulation suite, component sourcing assistance, multi-board projects
    * **Pro Team** (per seat) — Everything in Pro plus shared workspaces and team collaboration
    * **Ultra Team** (per seat) — Everything in Ultra plus team features
    * **On-Demand** — Pay-as-you-go credit packs ($20 or $40) for users who don't need a monthly subscription. Credits are consumed per request based on actual token usage
    * **Enterprise** (custom) — Private backend instances, private database, SSO, no data retraining, dedicated account manager, custom SLA

    Visit [buildwithtrace.com/pricing](https://buildwithtrace.com/pricing) for current pricing.

    <Note>
      New subscribers get double their monthly usage allowance for the first 30 days, giving you room to explore Trace's full capabilities.
    </Note>
  </Accordion>

  <Accordion title="What are the AI interaction modes?" icon="table-columns">
    Trace has three AI modes:

    | Mode      | What it does                                                                                                              |
    | --------- | ------------------------------------------------------------------------------------------------------------------------- |
    | **Ask**   | Query and analyze your design without making changes. Get explanations, suggestions, and answers. Available on all plans. |
    | **Agent** | AI makes direct edits — adding components, routing traces, generating files. For quick tasks and immediate changes.       |
    | **Plan**  | Multi-step design planning. AI creates a detailed plan you review and approve before execution. Best for complex designs. |
  </Accordion>

  <Accordion title="Is there a student or education discount?" icon="graduation-cap">
    Yes. Trace offers free access to students and university programs through the [Education Program](https://buildwithtrace.com/education). Apply with your university email and expected graduation year to get full Pro-level capabilities at no cost for qualifying academic use.
  </Accordion>
</AccordionGroup>

## Manufacturing & Export

<AccordionGroup>
  <Accordion title="What manufacturing outputs does Trace generate?" icon="industry">
    Complete fabrication packages: Gerber files, Excellon drill files, pick-and-place CSVs, BOM spreadsheets with supplier links, assembly drawings, and 3D STEP models. Trace validates DFM rules against your chosen fab house and flags issues before you order. Supported formats include Gerber, ODB++, and IPC-2581.
  </Accordion>

  <Accordion title="How do I export files for manufacturing?" icon="download">
    Use the export tools or ask the AI to generate manufacturing files. Trace produces Gerbers, drill files, and BOMs packaged into a fab-ready ZIP. You can also export STEP files for mechanical CAD integration. See the [Exporting guide](/guides/exporting) for details.
  </Accordion>

  <Accordion title="Can I order PCBs directly from Trace?" icon="truck">
    Yes. Trace's [One-Click Manufacturing](/guides/one-click-manufacturing) lets you submit your design directly to PCB fabs and assembly houses without leaving the editor. Supported manufacturers:

    * **PCBWay** — Fabrication and assembly (Turnkey, Kitted, Combo) up to 14 layers, international shipping
    * **Pikkolo Assembly** — US-based assembly + fabrication (beta), Denver CO, ships in as little as 24 hours

    Trace autofills the order form from your board file, validates DFM against the manufacturer's capabilities, calculates freight, and tracks fabrication progress. Available on Pro, Ultra, Team, and On-Demand plans.
  </Accordion>
</AccordionGroup>

## Technical Details

<AccordionGroup>
  <Accordion title="What are the technical specs of the AI model?" icon="microchip">
    | Spec               | Value                                           |
    | ------------------ | ----------------------------------------------- |
    | Architecture       | ViT (multimodal) + LLM + GNN + RL               |
    | GNN Encoder        | 4-layer GraphSAGE, 256-dim, bipartite           |
    | RL Agent           | SAC with curriculum learning                    |
    | Training data      | Synthetic PCB boards (parameterized generation) |
    | Training objective | Self-supervised (4 heads) + RL reward shaping   |
    | Placement method   | SA (production) + RL (in training)              |
    | Layer support      | Up to 32 layers                                 |
    | Min trace/space    | 3mil / 3mil                                     |
  </Accordion>

  <Accordion title="Does Trace have a CLI?" icon="terminal">
    Yes — `buildwithtrace` is a command-line interface for Trace's EDA tools. On macOS and Windows, it requires the desktop app to be installed (the CLI uses its local engine). On Linux, the CLI downloads a standalone engine automatically. Local validation and conversion (`erc`, `drc`, `gerbers`, `export`, `convert`) and read-only `ask` work on any plan; the agentic AI commands (`agent`, `plan`) require a paid plan, free agent credits, or an active legacy trial. See the [CLI documentation](/resources/cli) and [CLI commands reference](/resources/cli-commands) for details.

    You can also launch Trace from the terminal — `open -a Trace .` on macOS, `trace .` on Windows, or pass any `.kicad_pro` / `.kicad_sch` / `.kicad_pcb` file path to open it directly. See the [Installation guide](/installation#open-from-the-command-line) for setup instructions.
  </Accordion>

  <Accordion title="Does Trace support keyboard shortcuts?" icon="keyboard">
    Yes. Trace inherits KiCad's extensive keyboard shortcut system and adds its own. See the [Keyboard Shortcuts](/resources/keyboard-shortcuts) reference for the full list.
  </Accordion>
</AccordionGroup>

## About

<AccordionGroup>
  <Accordion title="Who built Trace?" icon="users">
    Trace was founded by Ayomide Caleb Adekoya, Jeff Mofor Allo, and Olu Afolabi. You can reach the team at [hello@buildwithtrace.com](mailto:hello@buildwithtrace.com).
  </Accordion>

  <Accordion title="What's the difference between Ask, Chat, Agent, and Plan mode?" icon="wand-magic-sparkles">
    * **Ask** — Read-only. The AI answers questions about your design, explains circuits, and suggests improvements — but doesn't edit files. Available on the free plan.
    * **Chat** — Interactive editing. The AI can read and write your schematic/PCB files with your approval. You stay in control.
    * **Agent** — Autonomous editing. The AI makes changes without asking for approval on each step. Best for well-defined tasks ("add decoupling caps to all ICs").
    * **Plan** — Research-first. The AI researches your request, asks clarifying questions, presents a plan, and only executes after you approve. Best for complex or ambiguous tasks.

    All modes except Ask require a paid plan (Pro or Ultra).
  </Accordion>

  <Accordion title="Can I use Trace without an internet connection?" icon="wifi-slash">
    **Partially.** The schematic and PCB editors work fully offline — you can draw, route, and edit without network. However, AI features (chat, agent, plan) require an internet connection to reach the backend.

    Local commands in the CLI (`buildwithtrace erc`, `drc`, `gerbers`, `convert`) also work fully offline once the engine is installed.
  </Accordion>

  <Accordion title="Does the AI see my files?" icon="eye">
    When you use AI features, the relevant file content (your `.kicad_sch` or `.kicad_pcb`) is streamed to our backend so the AI can reason about it. Tool execution (file reads/writes) happens **locally on your machine** — your files never leave your computer for storage.

    For local-only commands (`erc`, `drc`, `gerbers`, `export`, `convert`), no data is sent anywhere. Your design files stay on your machine entirely.
  </Accordion>

  <Accordion title="How do I export my design to a manufacturer?" icon="industry">
    1. **Generate Gerbers:** In the PCB editor, go to **File > Plot** or use `buildwithtrace gerbers my-board.kicad_pcb`
    2. **Generate Drill files:** Same dialog, or `buildwithtrace gerbers --drill`
    3. **One-click ordering:** Trace integrates with PCBWay and Pikkolo — click **Manufacture** in the PCB editor to submit directly

    See the [Manufacturing guide](/guides/one-click-manufacturing) for detailed instructions.
  </Accordion>

  <Accordion title="Can I import my existing KiCad or Altium project?" icon="file-import">
    **KiCad:** Yes — Trace is built on KiCad. Open any `.kicad_pro`, `.kicad_sch`, or `.kicad_pcb` file directly. No conversion needed.

    **Altium:** Yes — use the CLI converter: `buildwithtrace convert schematic my-design.SchDoc`. Supports `.SchDoc`, `.PcbDoc`, `.SchLib`, `.PcbLib`, and `.PrjPcb` files. See [Altium conversion limitations](/resources/known-limitations#conversion-altium-import) for edge cases.

    **Eagle:** Not yet directly supported. Convert Eagle files to KiCad format first using KiCad's built-in importer, then open in Trace.
  </Accordion>

  <Accordion title="What is Trace's roadmap?" icon="map">
    Trace is actively building:

    * **Trace width optimization** — Intelligent trace width calculation based on current requirements, impedance targets, and manufacturing constraints
    * **Next-gen auto placer** — The current SA-based placer is available now; we're building toward full constraint-aware placement with signal flow analysis, thermal management, and mechanical constraints
    * **Advanced routing** — Smarter autorouting with length matching, differential pairs, and constraint-aware trace routing
    * **ASIC design** — RTL synthesis, floorplanning, place-and-route. The same AI-assisted workflow applied to custom silicon, from behavioral description to GDSII
    * **Marketplace** — Share, discover, and remix PCB designs from engineers worldwide
    * **Real-time collaboration** — Like Figma for hardware. Collaborative editing with shared workspaces
    * **Supply chain intelligence** — Deeper integration with component distributors and one-click ordering
    * **Enterprise** — SSO, audit logs, on-premise deployment

    Email [hello@buildwithtrace.com](mailto:hello@buildwithtrace.com) to request early access to upcoming features.
  </Accordion>

  <Accordion title="Where can I get help?" icon="life-ring">
    * **Documentation** — You're here! Browse the guides and references
    * **Discord** — Join the [Trace community](https://discord.gg/UNUvQxneCr)
    * **Email** — [hello@buildwithtrace.com](mailto:hello@buildwithtrace.com)
    * **Enterprise** — [Book a call](https://cal.com/buildwithtrace/enterprise) with the team
    * **Troubleshooting** — See the [Troubleshooting guide](/resources/troubleshooting)
  </Accordion>
</AccordionGroup>

<Warning>
  **Important — Do Not Trust AI 100%:** Trace is an AI-powered tool designed to assist your PCB design workflow, not replace your engineering judgment. AI can and will make mistakes. Always review and verify all designs, schematics, component selections, routing, and manufacturing outputs before fabrication. You are responsible for your designs.
</Warning>