Mortise

WebMCP

Design woodworking projects with an AI agent in Mortise.

The Mortise editor offers its tools to AI agents in the browser through WebMCP. An agent adds real lumber, cuts joinery, fastens boards, looks at its work and produces the cut list, with the same actions and the same checks as a person using the app.

Open MortiseSee example workflows
Tools
48
Cut and shape operations
20
Skills an agent can load
8

How it works

Tools on the page, not a server.

When the editor opens, it registers each tool with the browser’s model context (document.modelContext, or the older navigator.modelContext). Each tool has a name, a description and a JSON Schema for its input. An agent in the browser lists them and calls them; nothing is installed and nothing runs outside the page.

Where the browser has no WebMCP, the same tools are on the page at window.mortiseSiteTools: list() returns them and await call(name, input) runs one, for any agent that can run JavaScript in the tab.

  • The editor’s own actions

    A tool call runs the action the app runs, so a refused cut is refused with the same reason, and every change is a step on the undo history.

  • One call at a time

    Calls run in order on the open project. An agent can cancel a call, and closing the editor cancels any still waiting.

  • Pictures it can read

    Results come back as text with structured data, and as images where a tool takes a picture, rendered whether or not the tab is on screen.

  • Saved as it goes

    A project an agent starts is in the person’s Mortise account, saved as it changes. There is nothing to export at the end.

Getting started

Start a design in Claude or ChatGPT.

In the editor, New design in Claude opens Claude with a prompt ready to send, and New design in ChatGPT opens the editor in ChatGPT’s browser with the prompt copied to paste. You add what you want to build. The prompt tells the agent to:

  1. use Mortise’s WebMCP tools rather than clicking, or window.mortiseSiteTools where the browser has no WebMCP;
  2. read get_workflow and get_catalog first;
  3. ask you what to build, its size and the wood;
  4. build in the new, empty project the link opens, name it, and leave every other project alone.

Any other agent with a browser can open /projects/new and do the same.

The tools

48 tools, grouped by what they do.

Each tool carries WebMCP annotations. Tools marked Reads only never change the project. Tools marked Asks first replace the open project or delete work, so an agent should confirm with you before calling them.

Learn the app

How Mortise measures and which way a board lies, the stock it sells, and the design knowledge an agent loads before it sizes anything.

get_workflowReads only
How to design in Mortise. Read this first. How Mortise thinks: units, the world and board axes, stock, every operation and its parameters, joins and hardware, how to see your work close up, and the order of work.
get_capabilitiesReads only
Capabilities and limits. The available tools, operation families, editable feature fields and remaining limits.
get_catalogReads only
Lumber, sheets and hardware. The stock Mortise sells: dimensional lumber keys and their real sizes, sheet goods, species, fasteners and hardware families.
list_skillsReads only
What a good woodworker knows. The skills you can load: furniture ergonomics, cabinet and casework standards, joinery and strength, wood movement and materials, proportion and taste, furniture styles, joinery recipes in Mortise, and design review.
get_skillReads only
Load a skill. One skill as Markdown: concrete numbers, rules of thumb, how to do it in Mortise, and checks before you finish.

Project

Start a project in the account, read it back, rename it, or open a project document as a new one.

new_projectAsks first
Start a new project. Start an empty project in the account. The one open now is saved and kept.
get_projectReads only
Read the project. Every board in the project (id, name, stock, species, size, centre, which way it lies, its cuts with their ids), the joins, hardware, groups, any boards sharing space, and the selection.
rename_project
Rename the project. Give the project a new name.
export_project
Read the whole project. The whole project as Mortise JSON, to read or to open again with load_project.
load_projectAsks first
Open a project file. Open a Mortise project JSON (as export_project returns it) as a new project in the account; the one open now is kept.

Boards

Real stock at its real size, placed and turned in inches. A placement that pushes one board into another is refused.

add_boards
Add boards. Put boards of real stock into the project.
place_boards
Place boards. Set where boards are and which way they lie, or rename them.
move_boards
Move or turn boards together. Move a set of boards as one, keeping how they sit to each other: slide by a vector and/or turn about a world axis.
drop_boards
Rest boards on the wood below. Let each board settle onto the floor or wood below, as when the move gizmo is released.
duplicate_boards
Duplicate boards. Copy boards with their cuts and the joins among them.
delete_boardsAsks first
Delete boards. Remove boards from the project, with the joins and hardware that hold them.
resize_board
Resize uncut stock. Change a board blank length or an uncut sheet width, where the size inspector permits it.
resize_bent_leg
Change the length of a bent leg. Grow or shorten one straight run of a bent board at its free end, using the size inspector action.
set_board_state
Visibility and reference boards. Show or hide boards, and mark existing boards as reference (excluded from purchases and cut lists).
select
Select boards. Select boards in the app (the inspector shows them and their dimensions are drawn), or clear the selection with an empty list.

Assemblies

Named groups that nest, as the parts list keeps them.

group_boards
Group boards. Gather boards into a named group (an assembly: "Base", "Drawer 1").
manage_group
Edit assemblies and their hierarchy. Rename, nest, reorder, lift, ungroup, show, hide or select an existing group.
arrange_boards
Move boards within the parts list. Move individual boards into a group or out to the top level, and reorder them before a board or at the end.

Cut and shape

One operation on one board, exactly as the tool in the app makes it: 20 operation families, each editable and removable afterwards.

apply_operation
Cut or shape a board. Make one cut, joint or shaping operation on one board, exactly as the tool in the app does: crosscut, rip, resaw, taper, outline, template, dado, rabbet, groove, tongue, mortise, hole, dog_holes, tenon, box_joint, bridle, dovetail, roundover, chamfer, bend.
edit_operation
Change a cut. g. a tenon's length or a mortise's position.
remove_operation
Take a cut off. Remove a cut from a board, giving the wood back.

Join and hardware

9 fasteners from glue to bolts, and 7 hardware families drilled into the wood and counted in the shopping list.

join
Join two boards. Fasten two boards that touch: glue, screws, pocket screws, nails, dowels, biscuits or Domino loose tenons, bolts, a cleat or clips.
edit_join
Adjust an existing join. Reopen a join in the editor, change its parameters and apply in one undo step, preserving its id.
remove_join
Take a join apart. Remove a join by its id (get_project).
add_hardware
Add hardware between two boards. Hinges, drawer slides, lid stays, catches, brackets, knock-down connectors or shelf supports between two boards.
edit_hardware
Adjust existing hardware. Reopen and apply existing hardware, preserving its id.
swing_hardware
Open or close a fitted hinge. Swing a fitted hinge/pivot or other swingable fitting by a relative angle in degrees.
remove_hardware
Remove hardware. Remove a piece of hardware by its id (get_project).

Look and check

Pictures rendered the way the app draws the model, close-ups of every joint, real measurements, and the problems a woodworker would catch.

screenshotReads only
See the design. A picture of the model, rendered as the app draws it.
inspect_detailsReads only
Close-ups of the details. The details that matter most in this piece, ranked (interlocking joinery first, then hardware and fasteners, then shaping), each with what to look for, and close-up pictures of the top few: each joint on its own, and pulled apart when the joint hides its work.
inspect_boardReads only
Read wood and connection details. The inspector information for a board: material, dimensions, shape, joinery, hardware, touching wood, fabrication notes and attention flags.
measureReads only
Measure actual wood. Measure gaps, overlap, penetration, edge insets and meeting angles between actual board shapes.
check_designReads only
Check the design. What a woodworker would catch: boards sharing space, floating boards, protruding or overlapping fasteners, and contacts between separate assemblies.
set_view
Turn the view. Point the camera: fit everything, isometric, or a side.

Cut list and cut sheet

The parts to cut, the stock to buy, the hardware and tools, and the same dimensioned PDF as Export.

cut_listReads only
Cut list and shopping list. Parts to cut grouped by size, stock to buy, hardware and tools.
export_cut_sheet
Generate the PDF cut sheet. Generate the same dimensioned PDF as Export > Cut sheet and open its viewer.

Settings and history

Units, display settings, and the same undo history the person sees.

get_settingsReads only
Read editor settings. Units, theme preference, grid, dimensions, studio rendering, snapping, keeping offcuts, input device and camera direction.
set_settings
Change editor settings. Set display and tool preferences explicitly.
set_units
Units. Show readings in inches or millimetres. Every tool still takes inches.
undo
Undo. Step back through the history.
redo
Redo. Step forward again through undone history.
get_historyReads only
Read the project timeline. All retained steps including undone steps, their index, current cursor and number of older steps trimmed from memory.
go_to_history
Return to a timeline step. Restore the project after index steps, using get_history indices.

apply_operation takes any of: crosscut, rip, resaw, taper, outline, template, dado, rabbet, groove, tongue, mortise, hole, dog holes, tenon, box joint, bridle, dovetail, roundover, chamfer, bend. join takes glue, screws, pocket, nails, dowels, loose, bolts, cleat, clips. add_hardware takes hinge, slide, stay, catch, bracket, knockdown, shelf.

Skills

What a good woodworker knows, loaded when it is needed.

list_skills and get_skill give an agent design knowledge as Markdown: concrete numbers, rules of thumb, the tool calls to make, and the checks before calling a design done. Only the index travels with the conversation; an agent loads a skill, or one section of it, when the work calls for it.

Furniture ergonomicsfurniture-ergonomics
Sizing anything people sit at or on, sleep on, reach into or walk round: seat, table, desk, counter, bed and shelf heights, depths, drops, knee room, clearances, accessibility, children, tip-over and crib safety.
Casework and cabinetscasework-and-cabinets
Kitchen, bath and built-in cabinets, bookcases, closets, media units: box sizes, toe kicks, face-frame vs 32 mm frameless, doors, hinges, drawers, slides, shelf pins and spans, kitchen planning.
Joinery and strengthjoinery-and-strength
Choosing and sizing joints: mortise and tenon, dovetails, box joints, bridles, dados, dowels, loose tenons, screws, pocket screws, bolts; glue; racking; failure modes.
Wood, movement and materialswood-and-materials
Wood movement and how to allow for it, grain direction, species choice, sheet goods, shelf sag, real stock sizes, moisture content.
Proportion and tasteproportion-and-taste
Making a design look considered: proportion systems, visual weight, tapers, overhangs, reveals, drawer graduation, rhythm, grain, common taste mistakes, and a taste review to run on screenshots.
Furniture stylesfurniture-styles
The vocabulary of a named style: Shaker, Arts & Crafts/Mission, Greene & Greene, mid-century/Danish, Scandinavian, Japanese, modern minimal, farmhouse, industrial, brutalist.
Joinery recipes in Mortisejoinery-recipes
Step-by-step tool calls, with the numbers worked out, for a leg-and-apron mortise and tenon, a pocket-screwed stretcher, a carcase with dadoed shelves and a rabbeted back, and a solid top on clips.
Design reviewdesign-review
How to look at your own work: the check, screenshot and close-up loop, zooming into joints and details, and what to check for structure, use and taste before calling a design done.

Example workflows

How an agent works through a job.

Four jobs, call by call, with the arguments the tools take. Lengths are inches. Ids in angle brackets come back from the call that made the board, cut, joint or hinge.

Design a side table from a description

The agent reads how Mortise works, loads what it needs to know, then builds the table one board and one cut at a time. Every call runs the editor’s own action, so it lands on the undo history and saves to the account as it goes.

The person asks
Design a white oak side table, 24 inches tall, with mortise and tenon aprons.

  1. get_workflowUnits, axes and every operation’s parameters. Lengths are inches, angles degrees.

  2. get_skillHeights and overhangs for a table, one section at a time.

    { "name": "furniture-ergonomics", "section": "Tables" }

  3. get_skillThe tested calls for a leg and apron, with the numbers worked out.

    { "name": "joinery-recipes", "section": "Leg and apron" }

  4. new_projectA fresh project. The one open before is saved and kept.

    { "name": "Oak side table" }

  5. add_boardsReal stock: 8/4 white oak is 1¾″ thick. A leg stands up with a face to the front.

    { "boards": [{ "name": "Front left leg", "stock": "8/4x6", "species": "whiteoak", "length": 23.25,
  "position": [-7.5, 11.625, -7.5], "orient": { "length": "+y", "thickness": "-z" } }, …] }

  6. apply_operationRip the leg square, then put it back with place_boards: a rip moves the wood’s centre.

    { "board": "<front left leg>", "operation": "rip", "params": { "edge": "near", "width": 1.75 } }

  7. add_boards13¼″ between the legs plus a 1″ tenon at each end.

    { "boards": [{ "name": "Front apron", "stock": "1x4", "species": "whiteoak", "length": 15.25,
  "position": [0, 21.5, -7.5], "orient": { "length": "+x", "thickness": "-z" } }] }

  8. apply_operationAnd again on end B.

    { "board": "<front apron>", "operation": "tenon", "params": { "end": "A", "thickness": 0.25, "width": 3, "length": 1 } }

  9. apply_operationOn the face that looks at the apron, 1⁄16″ deeper than the tenon is long.

    { "board": "<front left leg>", "operation": "mortise", "params": { "face": "far", "pos": 21.5, "width": 3, "height": 0.25, "depth": 1.0625 } }

  10. joinGlue covers the whole joint. The boards now move as one.

    { "a": "<front apron>", "b": "<front left leg>", "fastener": "glue" }

  11. inspect_detailsClose-ups of each joint, and the tenon pulled out of its mortise.

  12. cut_listWhat to cut and what to buy.

Review a design before cutting wood

Read-only tools let an agent check a project without changing it. It looks, says what is wrong, fixes it with the same tools, and looks again.

The person asks
Look over this bookcase before I buy the lumber. Is anything off?

  1. get_projectEvery board with its stock, size, place and cuts, and the joins and hardware.

  2. check_designBoards sharing space, floating boards, fasteners that stand proud or run into each other.

  3. get_skillThe look, fix, look again loop, and what to check for structure, use and taste.

    { "name": "design-review" }

  4. inspect_detailsThe details that matter, ranked: interlocking joinery first, then hardware and fasteners, then shaping.

  5. screenshotOne joint on its own, pulled apart to show what it hides.

    { "detail": "<detail id>", "apart": true }

  6. measureThe actual gap, overlap and meeting angle between the two boards.

    { "a": "<shelf>", "b": "<left side>" }

  7. edit_operationFix a cut in place. get_capabilities lists the fields each kind of cut takes.

    { "board": "<left side>", "id": "<dado id>", "changes": { … } }

Hang a door on a cabinet

Hardware is placed by how the boards sit, as it is in the app. The agent picks the family and mode; Mortise picks standard sizes, drills the wood and refuses a hinge that would not swing clear.

The person asks
Add a door to this cabinet on concealed hinges.

  1. add_boardsSheet goods come as panels with a length and a width.

    { "boards": [{ "name": "Door", "stock": "ply-3/4", "length": 30, "width": 15, … }] }

  2. add_hardwarea is the part that moves, b the one that stays.

    { "a": "<door>", "b": "<right side>", "family": "hinge", "mode": "concealed" }

  3. swing_hardwareOpen the door and check it clears its neighbours.

    { "id": "<hinge id>", "degrees": 90 }

  4. screenshotSee it open, then close it with a negative angle.

    { "view": "iso" }

Get a project ready for the shop

The outputs are the app’s own. Readings change units; every tool still takes inches.

The person asks
Give me the cut list in millimetres and a printable cut sheet.

  1. set_unitsReadings in millimetres from here on.

    { "units": "mm" }

  2. cut_listParts grouped by size, stock to buy, hardware and tools.

  3. export_cut_sheetThe dimensioned PDF, every board numbered with each cut where it falls. includeData returns the bytes instead.

    { "download": true }

Questions

Questions people ask.

What is WebMCP?
A proposed web standard that lets a page offer tools to an AI agent working in the browser. The page registers each tool with a name, a description and a JSON Schema for its input; the agent calls the tool instead of clicking through the interface.
Is this an MCP server?
No. Nothing is installed and nothing runs outside the browser. The tools live on the Mortise editor page and act on the project open in it.
Which agents can use it?
Any agent with a browser that supports WebMCP sees the tools natively. An agent that can only run JavaScript in the page reaches the same tools through window.mortiseSiteTools.
Can an agent see my other projects?
The tools act on the editor page they are called in. The hand-off from Mortise asks the agent to start a new project and leave any project already open alone.
Does the agent get the same result as the app?
Yes. Each call runs the editor’s own action, with the same checks: a cut that cannot be made, or a board pushed into another, is refused with the reason, and every change can be undone.