ParamRigMenuOpen the app

Make it a bit softer.
Three rounds later, it still isn’t.

A sentence has no resolution. The agent picks a number, you rebuild, you say less, it picks another one. ParamRig puts that decision on a control instead, and hands the agent the value you stopped at.

Connect your project Open the editors

Start here

npm install --save-dev @paramrig/webA development dependency. It installs nothing into a page no workbench is framing, and leaves the production bundle with the branch that guards it.

Sent as a sentence

You
The accent is too warm on the hero.
Agent
Cooled it down.--accent  #bc593d → #b8654a
You
Cooler.
Agent
Adjusted.--accent  #b8654a → #9c6b58
You
Not browner. Cooler.

Sent as a value

Accent#336b72
warmcool

Writes

--accent · global · css-variable
#bc593d → #336b72

Prose is a controller with one bit of precision.

You can see it. You cannot name it.

Your eye settles on the right hue in under a second. Writing it down as #336b72 is a different job. “Warmer” has no units, no bounds and no midpoint.

Every round trip costs a build.

Nothing in between survives it. The value that was nearly right is gone by the next round, and so is the reason you turned down the one before it.

The agent has never seen the screen.

It writes code against a description of a picture, and your description is all it has to go on. Two people would read it two ways.

Ask for the instrument, not the result.

The agent wrote the code, so it already knows which values decide how the thing looks. Let it expose those as controls, around the thing while it is running.

Turning them is the part you are better at. The number you land on is what it needs back.

And it has the editors to make the thing in.

A vector editor with layers, a pen, boolean geometry and node editing. A 3D editor with an outliner, edit mode, a modifier stack, UVs and materials. Both keep the keyboard you already use.

Everything they hold
The ParamRig vector editor with a poster open: twenty-one named layers, a grouped toolbar, a selected shape with its node handles, and an inspector holding position, rotation, sides, blend mode, fill, stroke, effects and the path's node count
Vector. A poster of twenty-one layers. The blade is selected, down to the six-node path under it, and the ◆ beside Rotation and Sides says a control drives them.
The ParamRig 3D editor with a desk study open: an outliner naming ten objects, a lamp built from a base, a stem and an inverted cone shade, a ring and a bead on the ground, and a status bar counting 1,111 vertices
3D. Ten objects and 1,111 vertices. The shade is a cone turned over with Solidify and Bevel on it, and three of its transform fields carry the same ◆.

Three ways to put controls on something.

A page inside the workbench with its hero title outlined and labelled ‘Hero title · 2 controls’

A project you already run

Point the workbench at your development server. Your design tokens become controls. Your components become things you can click on, comment on and draw over.

How the loop closes A layered contour drawing built from lobes, amplitude and twist

Something your code draws

An SVG, a composed page, a bounded Three.js scene. The rig travels with the document, so the controls are the ones this drawing needs.

See what is bundled Controller cards: exact value, stepper, bar, logarithmic scale, stepped scale, rotary knob and a minimum/maximum range

The controls themselves

Sixty-six controls in eleven families, an animation timeline, seven ways for a number to get its value, snapshots and a reference to compare against.

Open the catalogue

What the agent reads.

One immutable file in your repository. It lists every value that differs from your source, the bindings each one writes, and every comment you attached to an element, with the page, the viewport and the capture it was made on.

Then the agent answers in a file of its own, naming the revision it produced, so a batch is never applied twice or applied to code that has moved.

.paramrig/batches/b-4f21.json (ParamRig writes this)
{
  "sourceRevision": "study-1",
  "changes": [
    { "paramId": "accent",
      "before": "#bc593d", "after": "#336b72",
      "bindings": [
        { "kind": "css-variable", "property": "--accent", "scope": "global" }
      ] }
  ],
  "tickets": [
    { "number": 1, "target": "story-card", "instance": "coast",
      "message": "Too much air under the title.",
      "captures": ["c-9a1e.png"] }
  ]
}
.paramrig/responses/response-001.json (your agent writes this)
{
  "batchId": "b-4f21",
  "sourceRevision": "study-1",
  "resultRevision": "study-2",
  "summary": "Applied the accent and tightened the card.",
  "tickets": [
    { "id": "t-1", "status": "implemented",
      "message": "Card padding is now 20px. Check it at 390px." }
  ]
}

What it does not do.

It runs on your machine.

The workbench is a Docker Compose project on localhost. There is no account, no telemetry, and no project leaves the computer it is on.

Silent unless a workbench is framing the page.

Opened normally, connectWeb installs nothing: no listener, no observer, no overlay, nothing in the console. It never throws either, so a bad manifest cannot take your app off the screen.

It writes inside .paramrig/, and nowhere else.

ParamRig does not start your application, install anything into it, or edit your source. Your agent does that, from a file you approved, and you read the diff.

MIT, and installed from npm.

The workbench and the SDK are open source. @paramrig/web is published from the repository by a tagged release, with provenance.

Put the knobs on your own project.

One dev dependency, one manifest, and the page you are already running.

Read the setup