The first agent thatbuilds working CAD.builds real products.

Not meshes. Not disposable geometry. Impulse builds real CAD parts and assemblies, held as one product model — the dimensions, the dependencies between them, and the manufacturing intent meant to become real products. Not just faster CAD. Engineering output that can be made and trusted.

Text, images, CAD & constraints — add or change them anytime
OCCT B-Rep kernelEvery commit measuredWhole assembliesDFM · STEP out

Why this matters

Generating CAD is only part of the process.

A usable design still has to satisfy requirements, fit the parts around it, move correctly, and survive how it will be made. Impulse keeps that as a product model: the parts, and the dependencies that tie them. Today most of that still sits with the engineer. Carrying it is the real work.

◇ Carrying context is the real work

Requirements, constraints, sketches, and references. Impulse works from all of it, authors real CAD, and measures what it created against the conditions that matter — before the work is committed.

▣ Parts that can be made. Products that go together.

Molding, forming, machining, stamping. Assemblies that fit, move, use the parts you already buy, and can actually be put together. A file of shapes is not that.

↻ Today the check is still a person

Design intent goes in, CAD comes out, someone verifies it, and the cycle repeats. Impulse keeps the build and the check in one loop, and only brings you the decisions that are actually yours.

Meet the system

The capabilities that make the engineering delegable.

You bring the intent. Impulse carries the context, checks the physics and how the product is made and assembled, and commits real B-rep — accurate enough to manufacture, without hand modelling the path there.

01 · Intent

Drives the engineering

An agent that takes your intent and does the work.

Describe the product, or one change to it. Impulse plans the parts, authors the geometry, and keeps going through the fits and the construction that used to be hand modelling. Mundane engineering stays in the loop. When a choice is actually a design decision, it comes back to you — with the reason — and waits.

✓ Intent in, engineering out✓ Whole products or a single change✓ No click-by-click modelling✓ Design decisions elected back to you
02 · Context

Carries the context

Every part, feature, and reason stays addressable.

The product is held as one product model: requirements, references, mates, clearances, and why a dimension exists. Semantic addressability means you can point at a hinge, a wall, or a clearance and the system knows what it is and what depends on it. Add or alter information and it stays attached — session after session.

✓ Semantic addressability of parts and features✓ The why stays on the dimension✓ Context survives the next session✓ A change knows what it touches
03 · Proof

Proves it will work

Physics, DFM, DFA, and the assembly — before it commits.

Fit, motion, and load are measured on the live product. Design for manufacture and design for assembly run on the same model: draft, walls, tool access, fastener reach, and whether the parts go together in an order a person can actually follow. A change that breaks a neighbor is caught before it lands.

✓ Physics on the assembly, not a guess✓ DFM and DFA in the loop✓ Assembly-level fit, motion, and order✓ Refused when the measurement doesn't hold
04 · Geometry

Real B-rep. High accuracy.

Industrial solids. Nothing disposable standing in for a part.

The geometry is true boundary representation on an industrial kernel — faces, edges, and features with manufacturing accuracy, not a mesh that only looks like a part. When a construction fails, the same intent is re-expressed until the solid is real. What comes out is clean STEP you can take into the tools you already use.

✓ Real B-rep solids, not meshes✓ High-accuracy features and dimensions✓ No hand modelling to get a valid solid✓ Clean STEP out

Context, proof, and geometry stay in one loop. A change is a change to the product — not a new file you have to reconcile by hand.

Why Impulse

An engineering loop you can hand work to.

When the system can carry more of that loop reliably, the value moves beyond faster CAD toward engineering work that can actually be delegated.

01

Bring the context

Intent, photos, sketches, references, CAD, constraints. Add them at the start or alter them later. The plan stays tied to what you gave it.

02

It decides the engineering

Fits, clearances, and construction stay in the loop. When a choice is a design decision, Impulse elects it back to you — and waits.

03

Watch it, stop it, ask again

The reasoning stays visible. Interrupt whenever you want; the loop resumes. A credited build is constrained and open to questions — and a change goes back in.

See it work

Agent-first design, driven by intent.

You bring the context and the decisions that are actually yours. Impulse does the engineering in between — a plan you can read before it builds, a build you can stop and inspect, and a product you can keep questioning. A change goes back through the same loop.

Context in

Give it the brief. Change the brief. It keeps both.

Text, images, sketches, existing CAD. Add them up front or alter them once the work has started — a dimension, a reference, a constraint. Impulse treats that context as the product, not as a prompt it discards after the first shape.

  • Text, images, and CAD in the same brief
  • Add or revise context without starting over
  • The plan stays tied to what you actually gave it
impulse — context live

Your intent, its engineering

It does the mundane work. It brings you the decision.

Impulse reasons from the brief and feeds the design back before it builds. Fits, clearances, and construction stay in the loop. When the choice is actually a design decision, it elects that back to you — with the plan attached — and waits.

  • A plan you can read before anything is built
  • Design elections, not a checklist of every dimension
  • Approve it, or send it back with a change
impulse — intent live

The build, in the open

Watch it engineer. Stop it whenever you want.

Part by part, the reasoning stays on screen — what it is authoring, and why. Interrupt at any point; the loop resumes from where it stopped. What lands is a verified, credited build: every part and the assembly constrained, and open to inspection.

  • Reasoning you can read while it builds
  • Stop anytime — the loop resumes
  • Credited parts and assemblies you can interrogate
impulse — build live

Stay in the loop

Ask a physical question. Change the design. It goes back in.

A credited build is the start of the next turn. Ask whether a lid opens under its own weight, or whether a deeper pocket still fits the parts around it. Impulse answers against the live product, and a change re-enters the same loop — with every prior decision still accessible.

  • Physical questions against the built assembly
  • Edits go back through the loop
  • Prior decisions and context stay addressable
impulse — interrogate live

The product model

One change is never one part.

Impulse holds the product as one model. Parts, features, and requirements are the nodes. A dependency is what has to stay true between two of them: the gear is located by the shoulder, the wall keeps 4 mm of clearance, the joint holds 7 bar, the stroke reaches depth. On the diagram, those dependencies are the lines.

Change a node and dependency propagation follows the lines out from it. The gear moves with the shaft, because of the shoulder. Raise the line pressure and the load on the joint is calculated again. Propagation stops at the boundary, the first node that cannot move. The mount pattern is already in the plate. The cartridge length is the supplier's. The needle still has to reach depth. Impulse reports the shortfall and the choices, and waits. Anything past the boundary is left alone.

Product model

Parts, features, and requirements, and the dependency that has to stay true between them.

Dependency propagation

A change runs along those dependencies and updates every node that can move.

Propagation boundary

It stops at the first node that cannot move, and leaves everything past it alone.

Each example below is one edit: the nodes that move, and the node where propagation stops.

The edit

Extend the shaft 6 mm.

Gear and bearing sit on the shoulder. The end wall has 4 mm of clearance. The plate pattern is already decided.

Shaft, gear, wall

shoulderseatboreclearancedatum
FeatureShaft endoutput end
ShoulderGearon the shoulder
SeatBearing seaton the shaft
BoreBosscoaxial to the seat
ClearanceEnd wall4 mm to the gear
DatumParent platehole pattern set
Changed Updated Held

Your decision

2 mm of interference. The mount cannot move.

The gear sits on the shoulder, so the full 6 mm carries it into the end wall. Clearance was 4 mm. The bearing and the boss have already followed. That wall is the face bolted to the parent plate. Keeping 1 mm of clearance means finding 3 mm somewhere else.

01

Move the mount

The housing grows 3 mm and the plate pattern moves with the wall. The shaft keeps the full 6 mm. Clearance comes back to 1 mm.

02

Keep the mount

The shaft extends 3 mm, not 6. The gear keeps 1 mm to the wall. The plate pattern stays.

03

Relieve the wall

A 3 mm pocket behind the gear. The mount face does not move, the shaft keeps 6 mm, and 1 mm of clearance comes back.

No compromises

Built for how engineers actually work

⌁ Real-time progress

Plan, reasoning, and measurement stay on screen. Stop the run whenever you want. It resumes from where it stopped.

⇄ Your formats, your tools

STEP in, STEP out. Start from your existing parts and finish in SolidWorks, Onshape, or Fusion — or go straight to your printer or shop. No lock-in.

▧ Nothing to install

Browser-native. The kernel, the model, and the verification run server-side — a session is one link, shareable with your whole team.

▣ Your IP stays yours

Private projects, full export at any time, and a record of every decision and measurement — the audit trail your design reviews always wanted.

What you walk away with

Don't sweat the small stuff.

80%

of the work.

The boring engineering. Clearances, draft, mates, wall thickness, how the parts go together, rev N+1. A whole product, a mechanism, a fixture, a client variant — Impulse does that work. You don't draw it.

100%

checked before it commits.

High-confidence output. Fit, physics, manufacture, and assembly are measured before anything lands. You stand behind a product, not a shape you have to babysit.

Pricing

Pay for the work, not the seat.

Credits power agentic engineering — planning, building, editing, and verifying real geometry. Spend them on the best model for the job, from fast drafts to deep reasoning.

Builder

$39

per month

  • 5,000 credits / month
  • All frontier + reasoning models
  • Private projects
  • Photo & sketch references
Most popular

Pro

$199

per month

  • 30,000 credits / month
  • Top Ultra reasoning model
  • Multi-part assemblies
  • Persistent project memory
  • Priority builds · commercial use

Studio

$999

per month

  • 150,000 credits / month
  • Everything in Pro
  • Team seats & shared projects
  • Highest-priority compute
  • Bring your own model keys

Impulse for teams that build serious systems

Large assemblies, your component catalog as a design space, proposals with every assumption stated, private deployment. For automation builders, integrators, and engineering organizations.

Talk to us

Everyone else is prompting for shapes. You'll be shipping products.

We're onboarding in waves — early seats get the agent first.

Seats from $39/mo · engineering & hardware teams first