Skip to main content
Glama

program_device

Destructive

Program Efinix FPGAs by loading bitstreams into SRAM over JTAG or writing configuration data to SPI flash using active, passive, or JTAG bridge modes.

Instructions

Program an Efinix FPGA through the Efinity command-line programmer.

mode: jtag / jtag_chain - load a .bit into the FPGA's SRAM over JTAG (lost at power-off) active / passive - write a .hex to SPI configuration flash (or SPI passive load) jtag_bridge(_x8) - write a .hex to configuration flash through the FPGA's JTAG bridge Flash modes overwrite what the board boots from, so confirm with the user first. Give either project (uses its outflow .bit/.hex) or an explicit file. url / board_profile select a cable when several are attached (see list_programmer_cables). chain_device_number picks the device for jtag_chain.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
urlNo
fileNo
modeNojtag
projectNo
wait_secondsNo
board_profileNo
jtag_clock_hzNo
verify_methodNo
chain_device_numberNo

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A4.6/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description goes beyond destructiveHint/openWorldHint by explaining exactly which modes are volatile ('lost at power-off') versus persistent and destructive ('overwrite what the board boots from'). This is concrete, decision-relevant behavior that annotations alone do not convey.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Bullet-style mode lines front-load the core semantics, and every sentence adds operational value. No filler or repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 9-parameter, destructive, no-output-schema tool, the description covers the important decision points and warnings. The only notable gap is not describing what the call returns or how wait_seconds/verify_method affect execution, but the core usage is complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema coverage, the description compensates well by explaining all mode variants, the project/file mutual exclusion, cable-selection parameters, and chain_device_number. It does not fully explain wait_seconds, jtag_clock_hz, or verify_method, so it is helpful but not exhaustive.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The first line names a specific verb ('Program'), resource ('Efinix FPGA'), and mechanism ('Efinity command-line programmer'). The mode breakdown further differentiates it from sibling management/query tools such as list_programmer_cables or run_flow.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives clear mode-selection guidance (JTAG vs flash vs bridge), instructs when to confirm with the user, and points to list_programmer_cables for cable selection. It stops short of explicitly stating which sibling tools should be used instead for non-programming workflow steps, but the context is strong.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.