Everything it does, and how to set it up

What Jig is

A browser built for QA: the page you are testing opens inside the window, and the panels around it do the work you would otherwise do in five applications.

Jig is a desktop browser. You open the application under test in it exactly as you would in Chrome (your logins, your SSO, your cookies), and everything a tester reaches for lives in the same window: the form map, the fill, the network log with real response bodies, the accessibility audit, the recorder, the findings.

There is nothing to connect. No port, no token, no extension to install into another browser, and no “not connected” state to debug. Open it and it works.

What it is not

It is not an editor with a preview pane, and it is not a test-automation framework. It does not ask you to write scripts, and it does not run in CI. It is the window a tester works in for the day.

Installing Jig

macOS: download the disk image, drag Jig into Applications, open it. The build is signed with a Developer ID and notarised by Apple, so it opens with a double-click: no right-click-Open dance, no Gatekeeper warning.

Windows: download the installer and run it. Everything in this documentation works there: the same browser, the same panels, the same reports.

Updates

Jig checks for a new version by itself and tells you what changed. Nothing is applied until you press update, and never in the middle of a session. Where the build can replace itself it does so on the next quit; where it cannot (an unsigned build, which today means Windows), pressing update opens the download instead. Installing something fetched over the network without a signature to check against is the one thing an update channel must not do.

Projects, tabs and sessions

A project is a whole context; a tab is a session inside it.

Every application you test gets a project: its own folder and documentation, its own Jira, its own allowed addresses, its own saved logins, its own conversations, and its own colour, so five open at once are told apart before a word is read. The colour belongs to the project, not to the machine: open the project elsewhere and it looks the same.

Inside a project you get up to ten tabs, and each keeps its own cookie jar. That is what lets an administrator and a customer be signed in at the same time, side by side, without incognito windows or a second browser. Name a tab for what it is: double-click it, or press F2.

Starting over

“Forget this session” empties that tab’s cookies and storage and reloads: the page as a first-time visitor meets it. Other tabs and saved logins are untouched.

Reading and filling forms

Open the Form map panel and press “Read the form”. Jig walks the whole form in one pass and lists every field: what kind it is, whether it is required, which widget library it came from, and how that widget has to be driven. No clicking, and no guessing from the DOM.

Four sets of values

• Valid · plausible values a form should accept. The fast way past a form you are not testing.
• Limits · exactly the boundaries the fields declare: the longest allowed, the highest allowed.
• Invalid · shapes the validation should refuse. The point is the error message.
• Empty · everything blank, to see which fields the form actually admits are required.

When a control refuses

The reason is printed rather than swallowed: the value is not in the list (and here is what is), the field did not keep what was typed, something is lying on top of it, it sits inside a disabled fieldset, it is inside an aria-hidden region. A refusal that names itself is already a bug report.

Checking the page against the design

The Design panel compares what the browser renders with what the design says. Paste a Figma link and you get a table: element, property, the design value, the page value, and the token the page value came from. “The button is painted --accent-press instead of --accent” is a one-line fix; “the colour is 2% darker” is an argument.

Press Overlay for the other half: the two pictures on top of each other with a slider between them. That is the thing a table can never show: a block that has moved. You can also drop an image of the design into the panel instead of a link, for the projects where nobody has Figma access and the mock-up arrived in a chat.

Connect Figma once in Settings → Connections: a personal access token (Figma → Settings → Security → Personal access tokens, scope “File content: read”). Jig uses the REST API rather than the Dev Mode plugin on purpose. The plugin only works while the Figma app is running, and this has to work when it is not.

Two things worth knowing before you read the results. Sizes are only compared when the window width equals the frame width. A design drawn at 1440 read in a 1600 window differs in everything, so set the width in the toolbar first; the panel says which case it is. And the overlay compares blocks, not pixels: Figma and the browser antialias text differently, so a raw pixel diff would light up every letter of a perfectly correct heading.

The design check is part of Pro. It works through the trial month and then asks for a key. Reading the page’s own styles stays free.

Network, rules and findings

The Network panel lists requests with their real response bodies: not “500”, the sentence the server actually wrote. Copy any of them as curl, or send the same request again without touching the page.

Making the server misbehave

In the “By hand” panel, put part of an address in the field (say /api/orders) and press one of: fails with 500, answers empty, answers in five seconds, connection dies. The rule belongs to that tab and dies with it. No back end to talk into, no branch to deploy.

A finding is a ticket

Keep anything as a finding and it arrives with the steps, the environment, the request and the response already written out. Connect Jira and it files as a ticket; point the project at its repository and every finding carries the branch and commit under test.

Pictures, the window, and the last seconds

A ticket nobody can reproduce is a ticket nobody fixes.

Jig takes three different pictures, and they answer three different questions. Which one you want depends on what you are trying to prove.

The clip is a ring, not a recording

You remember to record after something breaks, so recording forward is the wrong shape: what you need is the twenty seconds before. Jig keeps that window and writes it out when you ask. The frames are replayed at their own pace, so a pause where the page was slow stays a pause. A clip that lies about timing is worse than none, because timing is often the thing under dispute.

The clip comes with a track you can read

A recording of a bug runs twenty seconds and the part that matters is four of them. The receiver has to watch all of it to find them, so mostly they do not watch at all. Beside the video Jig writes a list of moments on the same clock: what you clicked, by the name of the control; every request that failed, with the server’s own answer; every console error; and everything the page announced out loud. Click a moment and the video jumps there. It is one self-contained file: the video is inside it, and it makes no request to anything.

One moment on that track is evidence of something that did not happen: the page changed right after you acted and said nothing at all: no announcement, no focus move. A screen reader user got silence there. It is worded as “review this”, never as a failure, because WCAG does not require every change to be announced.

A picture that knows what is on it

Ask for the map and Jig writes one beside the picture: every control with its name, its role, a selector that finds it again, and its box in the pixels of that image. A flat screenshot throws all of that away. With the map, findings draw their own boxes on the page (labelled and coloured by severity) and two shots of the same screen compare by control instead of by pixel.

Ask for the text layer and the screenshot becomes searchable: Ctrl+F, select and copy all work on it. Nothing is recognised out of the pixels: the text is written back over its own image from the page it came off, so an eight-pixel caption and a Chinese heading are exactly as right as the page was. The file says what is not in the layer: text inside canvas, and inside frames.

States nobody ever photographs

Empty list, a 500 with the server’s own words, an endless spinner, 403, a dropped connection. Every other capture tool can only photograph a failure that happened by itself; Jig causes it, because the network rules and the camera are the same product here. It shoots each state, puts them side by side on one page, and clears the rules after itself. A screen whose text did not change by a single word has no such state at all, and that is the finding.

Getting it into a chat

Every finding copies two ways: as a ticket in words, and as the picture itself. Two buttons rather than one, because the receiving application decides which half of a mixed clipboard it takes, and you would find out which from somebody else’s message. Each one says what it put there.

Recording a flow

Press Record, click the flow through by hand, press Stop. What is written down is the name of what you touched and the value it ended up with, never coordinates, so a redesign does not silently break the recording. A password is recorded as “a password was typed”, never as the letters.

Runs, and the difference between two

Every run is kept. Compare the last two and you get the three answers a regression is about: what broke since last time, what got fixed, and what is still failing.

Handing over a task

Optional, and off until you connect it.

Type what to check and Jig plans it and carries it out, filing findings as it goes. Point the project at its repository and it reads the documentation and the Jira with it; give it a checklist and it works through yours rather than improvising.

Two ways to power it

• Your own Claude subscription: connect it once from Settings and nothing is billed by us, with no cap from our side.
• Our cloud: 200 calls a month are included with Pro. Enough for real work; the heavy agent is where your own subscription pays off.

A claim is not a measurement

The checklist prints how many items were ticked on the agent’s word alone, separately from the ones the executor observed. A lead signing off a release is signing under the word “verified”, and the difference has to be visible.

Connecting MCP servers

The tools the chat can reach beyond the page under test: your tracker, your designs, your database.

Jig reads the .mcp.json in the project’s folder: the same file Claude Code uses, so a project already set up for your editor needs nothing new. Point the project at its repository in the Files panel and the servers appear in the MCP sheet.

Turning one on

• Open the MCP sheet from the composer, or type /mcp in the chat.
• Each row shows where the server came from: this folder only (the repository’s file, which travels with the team) or every project on this machine (your own).
• Tick the ones this project may use. The choice is per project: the same server can be on here and off in the next one.
• A change takes effect on the next question, not mid-answer.

What the rows tell you

• Connected · answered the handshake and its tools are attached to the chat.
• Needs auth · reachable, but it wants a token this machine does not have.
• No answer · declared, not responding. Fix it outside and press Reconnect; there is no need to restart Jig.
• This machine has no value for… · the file references an environment variable that is not set here. Jig names the variable rather than failing silently.

Credentials are never copied into the project record. Importing a repository reads its Jira, its documentation, its addresses and its server declarations, and leaves the secrets where they are, saying so in the import result.

Jig’s own tools are not MCP

The page verbs (read the form, fill it, click, press, force a network rule) are built in and always available to the chat. MCP is for everything that is not this page: the tracker you file to, the spec you check against, the database you look a record up in. The section below is the same door in the opposite direction: your editor reaching in here.

Driving Jig from your editor

The agent that writes the code has never seen the application run. Connect your editor and it can open the page, sign in as a role, fill the form and read what the server actually answered.

Everything Jig’s own chat can do (read the page, fill a form in one pass, click, press, upload, open a role, force a network rule, run the accessibility audit, read the network and the console) is available to any editor with an MCP client. Cursor, VS Code, Claude Code, whatever you already use. It does not replace your editor and it does not want to: you keep writing code where you write it, and the running application lives here.

Switching it on

1. 1In Jig: Settings → Your editor (Cursor, VS Code), tick the box. It is off in a fresh install, because it keeps a local door open for as long as Jig is running.
2. 2Copy the three lines Jig shows you and paste them into your editor’s MCP settings.
3. 3That is all. There is no token to paste and no port to remember.

{ "mcpServers": { "jig": { "command": "npx", "args": ["-y", "jig-mcp"] } } }

While the door is open, Jig writes its address and a key to ~/.jig/connection.json (readable only by you) and the client reads it there. That is why nothing secret goes into your editor’s configuration file, and why a Jig that restarts on a different port needs nothing re-pasted.

Which project the editor lands in

The folder your editor is open in decides it. A project in Jig knows its folders, so a client standing in that repository is placed in that project by itself: nothing to configure, and no paragraph in a prompt that goes stale next week.

• Several editors can be connected at once, and each keeps its own project. Neither moves the other.
• Neither moves the window under your hands either: an editor switching project moves only its own pointer, and the strip in front of you stays where you left it.
• A folder that belongs to no project is refused, with the list of projects, never aimed at whatever tab you happened to leave open. Say which one to work in (project_switch) and the client stays there.

What it may do

Exactly what the chat in this window may do, and it is refused for exactly the same reasons. Reading (the page, the form map, the network, the console, the audit) is always available. Acting in the application passes the project’s consent switch, its allow-listed addresses, tab isolation, the destructive-name check and the action budget. See Permission to act below: connecting an editor grants nothing that was not already granted.

When it does not answer

• jig-not-running · the window is closed, or the box in Settings is unticked. Both look the same from outside, and both are fixed in the same place.
• no-project · the folder matches no project. The answer lists the projects; name one.
• refused with a reason · the project’s own answer (consent, address, isolation, a destructive name, the budget). It is not a fault to retry around; it is the setting you have not made.

Permission to act

Off in a fresh install, and it stays off until you say otherwise.

Read-only, Jig looks and measures: it never types, clicks or submits on your page. Turn acting on for a project and it may type and press, and only on the addresses ticked in that project’s settings.

Two rails that do not move

• Jig never acts in a tab you are signed into yourself: acting happens in tabs with their own session.
• It never presses a control that deletes, pays or publishes unless you used that word in the task yourself.

A run also has an action budget: how many times it may touch the application before it stops and says so. Both live in the project’s settings, next to the address list.

Accessibility checks

Run the audit and get the machine-detectable WCAG 2.2 violations with the element, the impact and the wording to quote in a ticket. Walk the Tab order and see where focus jumps, where it falls into something hidden, where it never comes back.

A widget Jig cannot drive from the keyboard is reported as a finding rather than swallowed: if a keyboard user cannot operate it, that is a defect in the page, and in the EU it has been a requirement since 2025.

The keyboard route as one picture

Nobody reads a table of forty stop names. The same route drawn on the page, a numbered pin on every stop and a line to the next, makes a jumping tab order obvious to somebody who has never heard of WCAG, and that is usually the person who has to fix it. Stops the walk already flagged come out red: no accessible name, a tabindex that tears the element out of order, a node under aria-hidden.

The whole site, not one page

The audit walks every route it can reach, signed in and signed out, and reports three ways at once: by direction, by route, and page by page. One section says out loud how many directions were not tested at all. See The report for what comes out and how you sign it.

The report you hand over

A document only a machine wrote is a document nobody signs.

At the end of a session (a test run or an accessibility audit) Jig builds one self-contained HTML file. The screenshots are inside it, so it opens on somebody else’s machine with nothing attached. It names what passed, what failed, what was blocked, and how many items nobody opened at all.

Your words, in the same file

1. 1Open the report and write your conclusion into the box at the top. What the numbers mean for this release is known only to the person who looked.
2. 2Press Save what I wrote. The text is kept in a markdown file beside the report, so it survives every rebuild.
3. 3Put your name in the signature line. It is stored in the report file itself.
4. 4Press Save as PDF.

The PDF is printed by Jig rather than by a browser, so headings and tables arrive as headings and tables: a screen reader walks the document instead of meeting a picture of one. It opens in your system’s PDF viewer once it is built.

Adding your own pictures

Write ![what the picture shows](shot.png) in your conclusion and the picture is embedded into the report. The description is required: a report that goes to a client is read aloud by somebody sooner or later, and an unnamed picture is silence in the middle of the argument.

Whether a report gets made at all

For a test session Jig asks before the work starts, not after: a report is built from what was collected along the way, and the honest moment to decide is at the beginning. The accessibility conclusion is part of the paid licence; the audit itself, and everything it measures, is not.

What leaves the machine

The browser, the inspector, the form map, the fill, the network rules, the recorder, the audit and the network log are local. Nothing about them is sent anywhere.

• Hand a task to Claude and the field names of the page travel with the question. What you type stays here.
• A screenshot only ever leaves if you switch that on yourself (Settings → “Send a screenshot with a free question”).
• Saved logins are encrypted by the system keychain. If the system refuses to encrypt, nothing is stored: better forgotten than kept in the clear.

Licence and key

Everything that measures is free forever: the browser, projects, tabs with their own sessions, the inspector, the form map, the accessibility audit, the network log with response bodies, findings and Markdown export.

Pro adds everything that repeats: roles, fill by set, network rules, record and replay, runs and their comparison, Claude, Jira and MCP servers. The trial is a full month. Two weeks is not long enough to meet a regression, and the regression is what Pro is for.

Entering the key

Settings → Licence key, pasted from the purchase letter. One payment for the year; nothing renews itself, because our till does not keep your card.

Keyboard

The shortcut list lives in the app itself, behind the “?” in the toolbar. It is built from the same array the shortcuts are bound to, so it cannot drift from them. The ones worth knowing on day one:

• F6 · move between areas: tools, address bar, tabs, the page under test.
• F2 · rename the tab (or the project) you are on.
• Alt + 1…9 · jump straight to a panel.
• ⌘1…⌘9 · go to that tab; ⌘9 is the last one.