MCP tool reference

These are the tools Claude, ChatGPT, Claude Code or an AI on your own key is given, word for word: each one's words are the ones the assistant reads. Every tool has its own doc in Brickworks' source (docs-site/tools/), with the example call shown here, and the check that holds every release fails when a tool changes and its doc has not been read against it. How an assistant puts them together is in How a design session works.

Brickworks has 68 tools, and the connector adds 2 of its own for choosing a tab. This page is made from the same tables the app and the connector serve, so it is always the current list. Through the connector every tool also takes target: the tab to do that one call in, by its id or its model's name.

Look and read

Change nothing: safe to allow always.

Search the parts

search_parts Read-only

Find real parts by description. Returns part numbers with their footprint, height and the colours they were really made in. Use this instead of guessing a part number. Printed parts are found by what is on them with the word print: "porsche print", "control panel print", "3623 print" (3623's prints); a part with a sticker on, with sticker.

For example:

{"query": "slope 45 2 x 2", "limit": 5}

Explained in The parts bin.

Check a design

check_design Read-only

Check a list of parts for overlaps, floating parts and whether it is one connected model, and weigh it: whether it stands (its centre of mass against the edge of what it stands on, in every pose its hinges and turntables reach), the counterweight that would hold it, and its most loaded stud joints. Safe to call on a partial design while you work. Or edit= instead of bricks: the model as it stands with that change made to a copy, to ask what if.

For example:

{
  "bricks": [
    {
      "part": "3001",
      "color": 4,
      "x": 0,
      "y": 0,
      "z": 0
    },
    {
      "part": "3001",
      "color": 4,
      "x": 2,
      "y": 3,
      "z": 0
    }
  ]
}

Explained in Placing and moving parts.

Read the design guide

read_guide Read-only

A section of how to design in this app, in full: "work" (the process: silhouette, features, detail), "rules", "shapes" (the patterns that lay a wall, a dome, a tower, a hull or a car body), "figures" (a figure, a creature or a character: its head and limbs on joints), "outline" (the parts a rounded body's outline is made of, by role), "subject" (what each kind of subject needs), "angle", "pins", "colour", "creative" and more. Read "shapes" before saying a shape, "figures" before building a figure or a creature, "outline" before laying a rounded or organic body.

For example:

{"section": "shapes"}

Explained in How a design session works.

Show a technique

show_technique Read-only

How a construction is actually made, in part numbers and coordinates, most of them as the LEGO Group built them in real sets. By what they are for — basics: half stud offset, porthole or lamp, smooth diagonal, smooth top, taper; walls and stone: staggered wall, rough stone wall, weathered stone wall, corbelled wall walk, oversail on inverted slopes, stone corbel, balustrade, embossed brick wall; towers and columns: round tower, wide round tower, columns with capitals, stone column, turned wooden pillar; round bodies: hinged panels, sideways skins, round body, dome and cone cap, smooth dome, ring of cones under a round plate, spokes with tiles, curved skin panel, studs-out core, grille band, cone bell on round plates, round tip; faces and features: eye with a highlight, round face, beak or snout, ears or tufts, talons, headlamps and grille; figures and joints: posed minifigure, limb on a clip, ball shoulder, head on a neck, tail on a bar, hinged wing, jointed figure, jointed animal; machines and joints: struts pinned to a Technic course, fin root on a Technic pin, towball hitch, magnet coupling; angles: corner on a turntable, leaning on a hinge; roofs and spires: chimney, turret spire, roof ridge, striped awning; windows and doors: window in a wall, door in a wall, arched window, window with shutters, postern arch, raked screen and falling roof; rock and ground: fence, rock outcrop, rocky ground with plants, stone with ivy, cobbled path, staircase; plants: tree, planter, hedge with flowers, clipped hedge, leafy plant, flower bed; furniture and interiors: bed, bench, armchair, table, bookcase, fireplace, hearth, anvil, chest, potion shelf, dresser, sofa, four-poster bed; lights: lamp post, hanging lamp, bedside lamp, campfire; creative touches: small creature, display stand with a nameplate. Ask before building one of these for the first time — a bracket's sideways stud is not at a whole number of plates, and the arithmetic is the part that goes wrong. Every one of them is checked against the same lattice your design is.

For example:

{"name": "posed minifigure"}

Explained in Designing with AI.

Find how real sets built it

find_techniques Read-only

How real LEGO® sets built a feature, found by what it is: the sub-assemblies of thousands of real sets (an owl's eye, a car's nose, a dragon's wing, a turret roof, a grille, a beak, a tree), each with a picture, its parts and colours, its size in studs, the set and modeller it is from, and an id for place_technique. Ask before inventing any feature of a face, a creature or a machine: a real designer's answer is better than a first guess. Name the subject too — "owl eye", "car nose" — and pieces from sets about it come first.

For example:

{"query": "castle turret roof", "max_studs": 6}

Explained in Designing with AI.

Find parts by their look

find_parts_like Read-only

Parts by what they look like in a model, not by their catalogue name: "feather", "claw", "exhaust", "eyelid", "scales", "leaf". Each family of parts comes with what builders use it for and its commonest part numbers. search_parts finds a part you can name; this finds the one you can only describe.

For example:

{"query": "a curved car bonnet"}

Explained in The parts bin.

Plan the scale

plan_scale Read-only

How big the model should be, worked out before anything is placed. Give the real thing's longest dimension in metres and this answers with what it comes to in studs at each scale builders use, and which one is worth building at. Settle this first: everything after it depends on the proportions, and changing it later means moving the whole model.

For example:

{"subject": "fire engine", "longest_metres": 10}

Explained in Designing with AI.

Find pictures of the real thing

find_reference Read-only Reaches the web

Pictures of a real thing, so you can build to what it looks like rather than to what you recall of it. Ask for this first for any subject that exists — a lighthouse, a tractor, a kingfisher, a particular building — and judge the proportions off the picture before you place a brick. The pictures come from Wikimedia Commons, which carries what is free to use: each is named and credited, and a famous ship from a film will not be there, so check what came back is the thing before building to it.

For example:

{"subject": "Fresnel lighthouse lantern room"}

Explained in Designing with AI.

What real sets of its kind use

how_real_sets_build_this Read-only

What real LEGO® sets of this kind are actually built from — the parts they reach for far more often than sets in general, and the colours they use. Measured over fifteen thousand real sets, so it is what the LEGO Group's own designers did and not advice.

Call it for any subject that is a kind of set: a castle, a fire station, a spaceship, a train, a house, a tractor, a police car. A castle set is arch doors and lattice windows in tan and pearl gold; a fire station is trans-blue lights, taps and red; a spaceship is brackets, antennas, cones and inverted dishes in white and grey. That is the difference between a model of the thing and a model of bricks, and you cannot get it from the shape alone.

Give the plain word for the thing. Nothing matches a specific name.

With it comes our own best design of the nearest subject, as the design bench&#x27;s judge scored it: how it was built, what it did best, and the faults to design out before you build.</p>

For example:

{"subject": "fire station"}

Explained in Designing with AI.

Where a part attaches

attachment_points Read-only

Where a part's studs are and the exact coordinates something sitting on each one would take, and its joints: holes, pins, axles, the bars (a handle is one) and clips a clip-on-bar joint is made of, and a rim's barrel and a tyre's hole, each by its middle and the way it runs, numbered for a placement by axis and joint. Ask about a brick that is already placed by its number, or about one you are considering by giving part and position. Use this rather than working out sideways positions yourself — a stud on the side of a brick is not at a whole number of plates and the arithmetic is easy to get wrong. It also draws the shape of any part that is not a plain box: which way a wedge plate tapers, which way a slope falls, where an arch is open. Ask before using one of those for the first time — a wedge put on backwards looks exactly like a wedge until you look at it. And every connector by the address attach takes ("#41.hinge[0]", "hinge[0]"): its type and number, where it is and the way it points. Several parts in one call: parts=[{...}, {...}].

For example:

{"brick": 12}

Explained in Placing and moving parts.

Find a gear train

search_gear_ratio Read-only

The gear trains of real spur gears (8 to 40 teeth) nearest a ratio, every mesh at a spacing the stud grid gives: an orrery's year, a clock's hour, a reduction for a slow arm. ratio= is output turns per input turn, negative for the other way round; or period= input turns per output turn. With to= [x, z] the output's axle stands that many studs from the input's, and the answer gives every axle between, on a grid point within within= studs of the line; without it, each mesh's spacing. Each train with its fraction, its error, its gears by part. Lay them as it says, and simulate_mechanism shows the ratio the parts give.

For example:

{"ratio": 0.2, "stages": 2}

Explained in Joints and mechanisms.

List what is built

look_at_model Read-only

See what is already on the baseplate, in the same stud and plate coordinates you use. Call this first whenever the request is about what is there — adding to it, changing part of it, matching its colours or its height. You cannot see the model otherwise.

A large model will not fit in one reply. Give where= to list one section, part= to find where a part is, or skip= to carry on from where the last listing stopped. The totals and the overall span are always for the whole model, whatever you ask for.</p>

For example:

{"where": {"y_from": 0, "y_to": 6}, "color": 4}

Explained in Placing and moving parts.

Look at the model

view_model Read-only

Look at what is on the baseplate. This is the only way to see whether the thing you are building looks like the thing you were asked for. check_design tells you a model is legal; this tells you what it is.

For example:

{"from": "corner"}

Explained in The view.

See the chosen picture

look_at_picture Read-only

The picture the person chose to make into Brick Art, as they gave it, with its size in pixels. Look at it before writing a make_art plan from it. When there is none it says so: draw one in make_art's svg.

Takes nothing.

For example:

{}

Explained in Mosaics and brickify.

What is selected

selection Read-only

What the person has selected in Brickworks — the parts they mean by "this", "these" or "the selected": each by number with where it stands, their box, the sub-assembly they are in, the room a change about them may use, how the joints round them stand, and pictures with them picked out, close up and in the whole model. Call it whenever a request is about part of the model, then change that part with edit_selection.

Takes nothing.

For example:

{}

Explained in Selecting and editing.

Where the selection takes a part

where_to_attach Read-only

Where the selected parts can take another part: every open stud, anti-stud (the hollow underneath that takes a stud), side stud, pin hole, bar and clip, grouped by the way it faces, each with the part that carries it and where it is in the coordinates edit_selection takes (a section's own, for parts laid turned), and a picture with the free ones numbered. Give part= (and color=) and it seats that part on them and tries each against the model as it stands: what comes back fits and holds, to put in edit_selection's add as it is. toward= puts first the points facing that way (out: away from the model's middle, for spikes or detail on an outer face); near= {x, y, z} those nearest a place.

For example:

{"part": "49668", "toward": "out", "limit": 4}

Explained in Placing and moving parts.

Read the booklet's pages

booklet_layout Read-only

The booklet's pages as Instructions would print them now, without drawing a picture: each page with the steps on it, and for each step how its designer set it (turned, tilted, zoomed, larger or smaller, a new page or a page alone, its parts list left off), which sub-assemblies are built in a callout box and which on pages of their own, and the most steps a page. Steps the booklet turns round by itself are decided when it is drawn. Changes nothing.

For example:

{}

Explained in Instructions and booklets.

List the model's motions

list_motions Read-only

The model's own motions, kept in its file ("Open the doors", "Steer left and right"): each with its joints as move_part names them, their keys (seconds, and places from where the model was built: degrees turned, or studs slid), its driver, or the motions it plays in order (a sequence), and what it was last found to do: where each joint ended, or where it stopped and on what. A joint whose part is gone, or a sequence's motion that is gone, is said so. Then motions suggested from what moves (doors, steering, a boom, a turntable, gears, a rack), each tried for room, which define_motion keeps. Changes nothing.

For example:

{}

Explained in Joints and mechanisms.

List the parts

parts_list Read-only

The model's parts, as Build, Parts list shows them: by part and colour, with counts and LEGO® element ids. which="need" measures it against the person's collection (My collection): how much they own and what they are short of; which="buildable" is What can I build?: their saved models, the examples and the official models of real sets, ranked by how much of each they own.

For example:

{"which": "need"}

Explained in My collection, Exports and renders.

Suggest sections

suggest_sections Read-only

How a builder would split the model into sections, as Build, Suggest sections does: the way a set splits into numbered bags and sub-builds. Each is connected and one piece, of a sensible size, joined to the rest by few joints, numbered in the order it is built, with the sections it is built onto and the way it comes off. Read from the booklet planner and the build check's joint graph. Changes nothing in the model; the suggestion is shown in the person's model tree. make_sections makes them sub-assemblies.

Takes nothing.

For example:

{}

Explained in Placing and moving parts.

Evaluate a section

evaluate_section Read-only

A section on its own, as Build, Evaluate the section does: its parts and count, its parts list, weight, whether it holds together as a separate build (the build check on it alone), whether it stands on its own base (Balance), what joins it to the rest and whether those joints carry its load, and how many steps it takes alone. section= a sub-assembly's name or path, or suggestion= a suggest_sections number. Changes nothing.

For example:

{"section": "roof"}

Explained in Placing and moving parts.

Weigh the weakest joints

weakest_joints Read-only

What gives first in the model as it stands, as View, Stress weighs it and the status bar's verdict says: every joint that alone holds what is past it (a cantilever's root, a part hung under another, a tower's foot), levered about the edge it would turn on, weakest first, each with the part that would come off, what it hangs from or stands on, its studs, the weight past it and its margin against the studs' working load (1 N a stud: under 1 is past it, under 2 within twice it; it lets go at about three times). A touch, one face resting on another with no stud between, carries only what stands on it, so it never shares a joint's load; a piece standing on touches alone past where it touches is said too. Read this instead of rebuilding the model in check_design to weigh it. part= one part's number (look_at_model) for what holds it; count= how many joints (8). Changes nothing.

For example:

{"count": 5}

Explained in Joints and mechanisms.

Search the gallery

gallery Read-only Reaches the web

Search brickworks.diy/gallery, the models people built in Brickworks and shared, and open one as a reference. With no open: a page of models matching q (words of a name, a builder, a tag or a description), kind, size, technic, instructions, sorted by sort (top: Top builds; owned: Parts I own, signed in with a collection); each with its link id, part count, credit, licence, how many built it and what moves in it (steering, a boom: anybody can move them on its link) and its own motions by name (open_model link= opens a copy, and play_motion plays them). shelves=true: the gallery's front, this week's pick and the small builds, and what the person can build now from their collection. open=<id>: one model compactly — what it is, its size, its sub-assemblies and steps, its parts by kind and the most used, its credit and its licence, how many built it, its comments and photos of real builds, and its picture — to learn how it is built. designer=<handle> (a list's "by Name (@handle)"): a designer's page, what their models earned and their models. library=true: LDraw's models of real sets instead, matching q (a name or a set number), theme, decade ("1990s") and size, sorted newest, oldest, largest, smallest or name; each with its library id, which open_model library= opens, and its maker and licence; with q, sets it has no 3D model of too, each with its parts list. Read-only: nothing on the baseplate changes, and liking, following and commenting are the person's own, on the site. Credit its builder and keep to its licence in anything made from it.

For example:

{"q": "lighthouse", "sort": "top"}

Explained in The gallery.

Measure between connectors

measure Read-only

Measure between two connectors, or two points, as the window's Measure does: the distance in mm, studs across (x), deep (z) and plates up (y), and the angle between the two connectors' axes to a tenth of a degree (with a hole, a bar or a hinge, which go both ways, the angle between the lines, 0 to 90°; between two pins or axles, 0 to 180°). from= and to= each a connector as attach names it, "#12.hole[1]" or "#7.hinge[0]" (attachment_points lists a part's), or a point "x y z" in studs and plates. The two halves of one joint (a hinge, a pin in its hole, a clip on a bar) are said with the turn between them as attach's yaw gives it, so a hinge left at an angle reads back as that angle. Changes nothing.

For example:

{"from": "#4.hinge[0]", "to": "#5.hinge[0]"}

Explained in Placing and moving parts.

What the person sees

in_view Read-only

What the person sees in the window that a session is not told: the step the timeline is at and its parts, the part in their hand (the Place tool's, its colour, which way it points as face and rot, and the span its ghost takes under the pointer; or the parts they are carrying), how many parts they have selected, and the reference picture they laid to build over: its file, size and place in studs, and with picture=true (the default) the picture itself, the model's parts drawn on it where they stand over it. Changes nothing.

For example:

{}

Explained in The view.

Follow a long job

job Read-only

How a long piece of work is going: a call that answered with a job number (a render, a turntable, a booklet, a Studio file, a Brick Art picture, a brickify, a mechanism's recording, or any call still going after 20 s). It waits up to 45 s for the work to end, then says how far it has got; once done it gives the work's answer, picture and all, or why it stopped. cancel=true stops it, as Cancel in the window does. id= the job's number; the latest when omitted.

For example:

{"id": 3}

Explained in How a design session works.

Say what it reads as

fresh_eyes Read-only

Answer the fresh look a new design's first save asks for, from the three pictures it handed you alone: what the model reads as, what reads as a generic box, and the three changes that would most make it read as the subject. Only when a save asks.

For example:

{
  "reads_as": "a red box with a roof; the door and the chimney read as a house",
  "generic": "the side walls are plain stacks of red bricks",
  "changes": [
    "windows with frames in both side walls",
    "a sloped roof with an overhang at the front",
    "a path of tiles to the door"
  ]
}

Explained in Fresh eyes.

Say what it reads as now

fresh_eyes_final Read-only

Answer the final fresh look the first save after the creative pass asks for, from the three pictures it handed you alone: what landed of the changes the first look asked for, what the model reads as, what still reads as a generic box, and done, or the one change that would now most make it read as the subject. Only when a save asks.

For example:

{
  "landed": "the windows show and work; the roof is still flat",
  "reads_as": "a red house with windows",
  "generic": "the flat top reads as a box",
  "done": false,
  "change": "a sloped roof of red slopes over the whole top, with an overhang at the front"
}

Explained in Fresh eyes.

Build and change

Change the model in the open tab. Each change is one undo step.

Place a real set's piece

place_technique Changes the model

Lay one of find_techniques' pieces into the model as the LEGO Group built it, or one of show_technique's by its name (a posed minifigure, a hinged wing: its joints put by their connectors): every part where the set has it, turned a number of quarter turns about the upright and moved so its low corner is at x, y, z, in your colours if you say which of its colours become which. The app finds the hold: laid where you say if the model holds it there, or at the nearest place within 4 studs where it does (a free stud under each part that needs one), and otherwise refused with the nearest place that holds it. Parts cannot be scaled: the answer says the same build at the sizes real sets use it, to pick the one your model's scale wants. Checked like any edit. The answer says where it went and what holds it, and lists the bricks as placed.

For example:

{"id": "posed minifigure", "x": 4, "y": 1, "z": 2, "turn": 1}

Explained in Designing with AI.

Settle a feature's piece

settle_feature Changes the model

Say what a feature is to be, once the app has laid a real set's piece for it where it goes (the whole review, each settle and saving hand the next feature with its piece laid and a picture): accept it — moved, turned or recoloured first if it needs it — ask for the next-best piece instead, reject it with a reason, say you built it yourself, or skip it. Saving waits until every feature listed in submit_design is settled.

For example:

{"feature": "eyes", "verdict": "accept", "turn": 2}

Explained in How a design session works.

Add furnished rooms

add_rooms Changes the model

Floors and furnished rooms inside a building that already stands — a tower, a keep, a house — in one call, as a real set opens at the back onto them (10237 Orthanc: a library, Saruman's chamber, a dungeon, the palantír). Give the building's box (where) or, for a prism, the prism's own at, sides and radius (prism), and the floors bottom up, each a kind of room: library, study, bedchamber, hall, throne room, forge, armoury, dungeon, kitchen, lookout, palantir room, stair. Each floor is laid as plates and tiles held up on columns; each room is furnished from the worked examples real sets built — bookcases, a fireplace, an anvil, a four-poster bed, lamps, chests, barrels — against its walls and facing in, varied by the seed; stair: true climbs to the next floor. The shell is left as it is and the edit is checked like any other, so build it open at the back (a prism's open, or no back wall) for the rooms to be seen. This is where a real set's different pieces and colours are, and a solid shell has none of them.

For example:

{
  "where": {
    "x_from": 0,
    "x_to": 12,
    "y_from": 3,
    "y_to": 60,
    "z_from": 0,
    "z_to": 12
  },
  "floors": [
    {
      "room": "hall"
    },
    {
      "room": "library",
      "stair": true
    },
    {
      "room": "lookout"
    }
  ]
}

Explained in Designing with AI.

Settle the surface pass

settle_surface Changes the model

Settle what the surface pass laid (review_model {"surface": true}, or the app's own turn for it): accept a finding, adjusted if need be; reject it with a reason, which takes the app's pieces off and puts back what they replaced; or keep the studs there for good with a reason — a yard, a mosaic, a studded texture, where a touch will stand. "tile" lays ground the pass only offered.

For example:

{"finding": "S1, S3", "verdict": "accept"}

Explained in How a design session works.

Add a minifigure

add_minifig Changes the model

Stand a minifigure in the model, made from real parts in their real places: who lives in it, guards it, works in it — or the subject itself, where the brief asks for a person at minifigure scale (a pilot, a knight on a horse). Add them once what they stand on is built — submitting a whole new design replaces them. Each slot takes a part number or a few words matched against the names of the parts made for it ("wizard hat", "long beard", "robe", "staff"); leave a slot out for a plain one. It stands on whatever is highest under its feet, two studs side by side, and is refused if something is in the way. Its parts are not counted in the model's variety, as a set's figures are not.

For example:

{
  "name": "Firefighter",
  "x": 4,
  "z": 2,
  "headwear": "fire helmet",
  "torso": "fire uniform",
  "accessory": "hose nozzle"
}

Explained in Minifigures, prints and made parts.

Make a new part

make_part Changes the model

Make a part the LEGO Group has not made, when no real part will do: search_parts first, and use a real one if there is one. Either a new part of a family at any size — a 1 x 7 brick, a bracket with a 3 x 2 upright, a Technic brick 1 x 9, a brick with studs on two sides — or a real part changed: from="3700" with across 6, from="3062b" without its studs, from="3003" with a corner cut out. It is checked as a person's part is (sizes the system has, walls 1.6 mm, studs on the grid) and refused with the reason if it cannot be made. Made, it is a part like any other: put its number in check_design, edit_model or submit_design, and a saved model carries it. Its studs, holes and pins are found as a real part's are, so it clutches and pins as they do.

For example:

{"family": "slope", "angle": 45, "across": 3, "deep": 2}

Explained in Minifigures, prints and made parts.

Review the model

review_model Changes the model

Look a built model over the way Brickworks' own designer does after a design stands: with no assembly, the whole model measured against real LEGO® sets of its size and kind — shapes, colours, the one-off pieces, how coarse — and what to check it for; with an assembly named in submit_design, that one close up, measured, with the parts real sets of the kind use that it has none of; with a feature (eyes, beak, wheel arches, grille), the best real set's piece for it laid by the app where it goes, with a picture, to settle with settle_feature; with surface, the surface pass — the app tiles the open stud fields, slopes the staircases (plate steps two at a time), rounds a body's hard top edges, skins its plain flanks and textures a building's plain walls on the model, to settle each with settle_surface; with creative, the creative pass — three touches proposed for this subject and the best one or two added. Call it after submit_design, then once per feature, then once per assembly, working each before the next, then surface, then creative last.

For example:

{"assembly": "walls"}

Explained in How a design session works.

Save the model

save_model Changes the model

Write what is on the baseplate to an LDraw .ldr file in this app's models, where its Open finds it and other LDraw tools can read it. A name, not a path; it will not write over a model the person saved.

For example:

{"name": "red_house.ldr"}

Explained in Saving, opening and files.

Set what it stands on

set_floor Changes the model Same result twice

Choose what the model stands on, as View, Floor does: a baseplate (studs across and deep, in eights from 8 to 192, in a colour baseplates come in), a grid floor with no plate, or none — a vehicle stands on a table, a scene on a baseplate in its ground's colour. part_of_model=true makes the baseplate a part of the model: counted, saved, step 1 of the booklet. Nothing built moves. With nothing given it says what it is now.

For example:

{"kind": "baseplate", "across": 32, "colour": 2}

Explained in The view.

Edit the build steps

edit_steps Changes the model

The model's build steps, the order the booklet and the timeline follow, as Edit, Build steps changes them. op "list" (the default) gives them with the part numbers in each; "to" puts bricks= in step=, however far, as the person drags them onto a step; "next" or "prev" moves bricks= a step later or earlier; "new" makes a new step of bricks=; "earlier", "later", "merge" (with the next) and "delete" act on step=, a number from the list. A model with no steps of its own is given the worked-out ones first, in the same undo step.

For example:

{"op": "list"}

Explained in Instructions and booklets.

Set how a booklet step is printed

edit_booklet Changes the model

Set how the booklet prints a step, as the timeline's Booklet row and Build, Booklet page do; one undo step, saved with the model (a turn as LDraw's 0 ROTSTEP, which LPub, LDCad and Studio read). step= a number from booklet_layout or edit_steps. turn= degrees round from the usual angle and tilt= degrees higher, held for the steps after it until turned again, or turn="usual"; zoom= 0.5 to 3 (in on what the step adds); size= 0.6 to 2 on the page; page= "new", "alone" or "auto"; parts= false leaves its parts list off; sign= false leaves off the turn sign a step turned more than 60 degrees round or 45 up or down gets; callout= false builds the sub-assembly the step puts on on pages of its own; per_page= 1, 2, 4 or 0 (as they fit) for the whole booklet; highlight= false leaves the new parts unoutlined in the whole booklet. callout_step= with step= is a step inside the callout that step puts on, from 1: turn= and tilt= pose it apart, from the way the callout faces. The page by hand, one undo step each and alone in a call: place= moves an item of the step's page to x, y (and w, h) in mm on the 269 x 199 page, as dragging it on Lay out the page does (item picture, parts, callout or number; note with index= for words or a picture added, turn= degrees clockwise and opacity= percent turning and fading it; remove=true takes a note off, back=true puts an item back where the booklet lays it); text= puts words on the step's page; arrow= draws an arrow on it, from x1, y1 to x2, y2, bent through bends= [[x, y], ...] if given, red (where a part goes in) or black, 0.45, 0.9 or 1.4 mm wide, or with index= changes, bends or removes one; guide= {axis x (upright) or y (across), at mm} lays a guide on every page, which what is dragged snaps to, never printed (was= moves one, remove=true takes it off). What is placed goes with its step when the pages change. booklet_layout says where each is, and what was moved off what it overlapped. follow=true lays out every later page with as many steps as the page step= is on, as that page is laid out (Apply to later pages), one undo step. Studio's extras: pull= studs (2 when true, 0 or false to put back) draws the step's parts, or {studs, parts: [part ids]} those, pulled out along the way each goes in with a red arrow in; colours= true lists the step's colours under its number (colours_all= true every step's); actual_size= false leaves off the 1:1 guide the booklet gives the first Technic axle or straight beam of each length, true gives every axle and beam of the step one, [part ids] those parts, "auto" as the booklet does it; preview= false leaves the finished sub-assembly off the first of its own pages. A model with no steps of its own is given the worked-out ones first, in the same undo step.

For example:

{"step": 4, "turn": 90, "zoom": 1.5}

Explained in Instructions and booklets.

Lay a hose, tube or chain

lay_flex Changes the model

Lay a hose, tube, string or chain, as Make, Hose, tube or chain does: kind ribbed_hose, pneumatic_tube, flex_hose or flex_axle between two parts' pin holes, axles or pins; string between two studs; chain or tread round sprockets= (two or more gears in one plane). The real length that fits is chosen, and it bends no tighter than the real one can. It goes in as one sub-assembly, named in the answer; item= that name lays it again between new ends. band: a rubber belt round sprockets= (pulleys, wheels, bushes or axles, in order round the loop); spring: between from= and to=, its turns kept when a part it is on moves. part= picks the band, the spring or the shock absorber by number.

For example:

{
  "kind": "pneumatic_tube",
  "from": {
    "brick": 5
  },
  "to": {
    "brick": 9
  },
  "color": 1
}

Explained in Joints and mechanisms.

Pose a joint

pose_model Changes the model Same result twice

Swing a part about its joint, as Build, Pose does: a sub-assembly on a hinge, a turntable or a clip on a bar. With no joint it lists them, numbered, with the angle each is at. joint= (number or name) and degrees= (from where it was built, -180 to 180) swings it as far as it has room; the answer says where it stopped if something is in the way.

For example:

{"joint": "boom", "degrees": 30}

Explained in Joints and mechanisms.

Move a part on its joint

move_part Changes the model Same result twice

Move a part about its joint as the person's drag on it does. With no part= it changes nothing and says what moves in the model: what its link's card says (steering, a boom, doors...) with the part to take hold of, and every part on a joint. With part=, its whole rigid body and everything beyond it turn on the joint between it and what stays (a locked part, what stands on the baseplate, else the body with the most parts, or a heavier one standing on the floor): a hinge, a clip on a bar, a turntable, a pin or an axle in a round hole, a ball, a 1x1 round part on one stud. part= a part's number (look_at_model) or a sub-assembly's name. With nothing else it changes nothing and says what would move, on what, and how the model stands. degrees= turns it that far from where it is (a ball: about axis=), along= slides it that many studs along a bar or an axle; it stops where it meets the model, gears it drives turn by their teeth, a joint without friction swings down under its own weight once let go, and the answer says what moved, where its joint then stands from where it was built (twice 20° stands at 40°), and how the model stands then. A part held at both ends (a four-bar, a crank with its rod and piston, a steering's arms) moves as its loop allows, and says so where it locks. spin= lets it go turning that many degrees a second, as a flick does: a wheel, a gear train or a turntable on free bearings coasts and slows against their friction, and the answer says how far it spun and where it stopped. A model turned past its edge falls over and says how it lies, unless it stands on the baseplate's studs. to= [x, y, z] in studs instead draws the part to that point by its whole chain of joints back to what stays, each within its range. One undo step.

For example:

{"part": "boom", "degrees": 30}

Explained in Joints and mechanisms.

Animate the model

animate_model Changes the model

Animate the model: poses at moments, played smoothly between (an arm raised over two seconds and lowered again, doors opening), the model turned round once as well if asked, and rendered as an animation (a WebP, and an MP4 where ffmpeg is installed) where Render saves. keys: [{"t": seconds, "angles": {joint: degrees}}], joints by number or name from pose_model's list, or a part on its joint as move_part names it ("#14": a steering, a wheel, an arm on its pin), each in degrees from where it was built. Rendering needs the app in a window and is a job (job gives the result). The keys are kept as the model's motion "Animation" (list_motions, play_motion), which the person plays in Build, Motions…; render=false only keeps them.

For example:

{"turntable": true}

Explained in Exports and renders.

Keep a motion in the model

define_motion Changes the model Same result twice

Keep a named motion in the model, as a builder names it ("Open the dome"), played by the real joints as a drag moves them. tracks= each a joint (a part's number "#80" or a sub-assembly's name, as move_part names them) and its keys: t= seconds, place= degrees turned from where the model was built (studs slid, with slide=true), how= ease (the default), linear or hold. Or driver= a joint turned turns= times over seconds=, from where it stands: what it drives through gears, racks and linkages follows. Or sequence= the model's motions by name, in order ("Show it all": ["Open the dome", "Extend the telescope"]): a motion made of motions, each played from where the one before left the model, backwards in reverse order. suggested=true keeps list_motions' suggestion of that name; remove=true takes a motion out. It is saved with the model (its autosave, a save, an export, a shared link), one undo step, and answers by playing it once and putting the model back: where each joint ended, or stopped and on what.

For example:

{
  "name": "Open the doors",
  "tracks": [
    {
      "joint": "left door",
      "keys": [
        {
          "t": 0,
          "place": 0
        },
        {
          "t": 1.5,
          "place": 90
        }
      ]
    }
  ]
}

Explained in Joints and mechanisms.

Play a motion

play_motion Changes the model Same result twice

Play one of the model's motions (list_motions) through its real joints, as a drag moves them: a joint stops where it meets the model, and gears, racks and linkages follow. The model is left where the motion ends, one undo step. reverse=true plays it backwards (closes what it opened; a driver turns back; a sequence plays its motions in reverse order). sequence=true plays the chain an older file's AFTER lines put it in. The answer says where each joint ended or stopped and on what, how the model then stands, and carries a picture of its frames from the view that sees most of what moves (or view=), and says which.

For example:

{"name": "Open the doors", "view": "hero"}

Explained in Joints and mechanisms.

Render a motion

render_motion Changes the model

Render one of the model's motions as an animation, a WebP and an MP4 (where ffmpeg is installed) where Render saves, framed on what it moves, without changing the model. reverse= and sequence= as play_motion; fps= 12 or 24; size= 480x300 or 720p; view= where the camera stands, hero (three-quarter from the front left, the default) or back for what moves at the back. Needs the app in a window, and is a job (job gives the result, with a picture of its frames).

For example:

{"name": "Open the doors", "size": "720p", "fps": 24}

Explained in Exports and renders.

Simulate the mechanism

simulate_mechanism Changes the model

Turn the model's gear train as Tools, Simulate mechanism does, and what it drives in a loop as a drag moves it (a pinion's rack slides, a crank's rod rocks and its slider strokes), without changing the model: from driver= (a part's number or a sub-assembly's name; else the one named Crank, Motor or Handle, else the one that turns most). It says each turning part's turns per driver turn and, with reference= (the part periods are counted in; Earth when one is named so), every other's period in its turns, against the real one for a planet or targets= ({name: period}). It names a locked train's meshes and the free and floating parts by number, and weighs the balance over the whole cycle: the worst frame, the arm furthest past the base's edge, a picture of it there. record=true also renders turns= turns of the reference (1) in frames= frames (24) as a WebP and an MP4 where Render saves, as a job (job gives the result).

For example:

{"driver": "crank", "record": true, "turns": 2}

Explained in Joints and mechanisms.

Render a picture

render_model Changes the model

Render the model as File, Render does: a picture, a turntable (a WebP and, where ffmpeg is installed, an MP4), or build: the model built up as a video, the timeline's steps one after another, each step's parts coming down into place and the camera turning slowly round, over seconds (10 to 60, 20 when omitted), as Render's Building does; on a studio sweep with soft shadows. quality quick, good or best (good for a picture, quick for a turntable or a build when omitted); size 720p, 1080p, 4k or square (720p for a turntable or a build); view hero, front, side, back, low or top. look product is a product shot's: glossy plastic with rounded edges, clear parts that bend the light, a key, fill and rim over a softbox studio (window, the default, is the window's own). backdrop white, gradient, grey, dark or none (as Render last had it when omitted). depth_of_field blurs what is nearer and farther than the model's middle, as a lens at f/4 does, and is drawn at best. Saved where Render saves. It is a job: the answer is a job number at once, and job gives the result, a picture with it. Needs the app in a window.

For example:

{
  "view": "hero",
  "size": "1080p",
  "quality": "good",
  "backdrop": "gradient"
}

Explained in Exports and renders.

Queue renders

render_queue Changes the model

Pictures lined up and drawn one after another while the person goes on working, as File, Render queue… does. action add queues the model and the view as they are now (view current, the window's, unless another is given), with Render's settings changed by quality, size, samples (Best's, 1 to 4096), view, look, backdrop and depth_of_field as render_model takes them; drawing begins at once unless paused, and each is saved where Render saves under a name of its own. list (the default) says what is waiting, being drawn and done, with where each was saved, and changes nothing; number=N with it shows that finished picture. pause holds the rest after the one being drawn, go_on carries on, finish_now keeps the one being drawn as clean as it is (a path-traced picture), cancel number=N takes one out or stops it, clear forgets the finished. Best is path traced where the graphics card traces rays, and frames averaged where it does not, and the answer says which. Needs the app in a window.

For example:

{"action": "add", "quality": "best", "size": "1080p", "samples": 512}

Explained in Exports and renders.

Export the model

export_model Changes the model

Write the model out as File, Export does, where Export writes (the Downloads folder; a download on the web): format ldraw (.ldr, or .mpd with its sub-models, with its build steps), studio (a BrickLink Studio .io), a 3D file at real size — glb (one file: Blender, three.js, AR; any size of model), gltf (the same as text), obj (with an .mtl of its colours) or stl (one mesh in mm, Z up, to 3D print); obj and stl hold every triangle and are capped — picture (.png), bricklink (a wanted list), rebrickable (a parts list .csv), or instructions (the building instructions as a booklet to print); all_models is every model the person saved, as LDraw in one .zip (File, Export, All my models). studio, picture and instructions are jobs: the answer is a job number at once, and job gives the result.

For example:

{"format": "studio"}

Explained in Exports and renders.

Brickify a 3D model

brickify Changes the model Reaches the web

Lay a 3D model in LEGO® bricks, as Make, Brickify a 3D model… does: an OBJ, STL, glTF/GLB, PLY, 3MF, VOX or FBX laid at the size asked (studs along its longest side) in slopes, curves and tiles, or plain bricks and plates, as one sub-assembly named after the file, beside what is built. file= its path on this computer (the desktop app), or url= an http(s) link to the file, fetched by the app (96 MB at most; an OBJ's .mtl and a .gltf's .bin come from beside it). pick=true opens the window's file dialog for the person to choose one on their computer, and says so; once they have, brickify with neither lays what the panel shows. Laying is a job: the answer is a job number, and job gives the result: whether it is one piece and stands (weighed), on what, any stand it was given, what was joined, and anything left out, where and why; its steps, a course a step with every step's build standing; and how to get its booklet and lists. collection=true lays it from the person's collection: their parts and colours first, then stand-ins, the shortfall said.

For example:

{"url": "https://example.com/teapot.stl", "studs": 32, "up": "+Z"}

Explained in Mosaics and brickify.

Print on a part

print_part Changes the model Reaches the web

Print a picture on a part of the model, or stick it on as a sticker, as Make, Print on a part… and Put a sticker on… do. brick= the part's number in look_at_model. A print goes on one of the part's printable areas (area=, the first when omitted; a wrong one is answered with its areas), and the printed part takes the part's place in its colour, a part of its own from then on. sticker=true makes a sticker the size of the part's side= face (up, down, +x, -x, +z, -z), running over the faces in the same plane beside it unless span=false, and sticks it on. The picture: svg= drawn by you (a whole <svg> with a viewBox in the face's proportions; flat colours print best), picture_data= a picture's own bytes as base64 or a data: URI (a PNG or JPEG the person gave you in the conversation; at most 2 MB, smaller is quicker), or picture_url= an http(s) link to a PNG, JPEG, WebP or SVG. Or the LEGO Group's own, as Make, Printed versions… does: version= one of the part's printed or stickered versions from the library (versions="words" lists them) swaps the part for it where it stands; sticker_part= a sticker the library has (search_parts "sticker") sticks it on the side= face, lying on it.

For example:

{
  "brick": 12,
  "sticker": true,
  "side": "+z",
  "svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 40 16\"><rect width=\"40\" height=\"16\" fill=\"#c91a09\"/><text x=\"20\" y=\"11\" font-size=\"8\" text-anchor=\"middle\" fill=\"#fff\">FIRE</text></svg>"
}

Explained in Minifigures, prints and made parts.

Make a copy unique

make_unique Changes the model

Cut one copy of a sub-assembly loose from the others, as Edit, Make this copy unique does: it becomes a sub-assembly of its own, so changing it changes no other copy. assembly= its path or name ("Wheel#2" or "Wheel (copy 2)"), or brick= a part in it.

For example:

{"brick": 14}

Explained in Placing and moving parts.

Colour the hidden parts

colour_hidden_parts Changes the model

Colour the parts nobody sees in the finished model, as big sets are coloured inside so a builder can tell where they are, as Tools, Colour the hidden parts… does. Hidden is measured, never guessed: the model drawn from 128 sides, every part its own colour, and only parts seen from none of them change. mode: sections (the booklet's: the assemblies a design named), stages (the build cut into stages= stages, as bags are), left_right or front_back (the halves of a symmetrical build told apart). Each group gets one colour far from every colour seen, and each part only a colour it is made in. Without apply it changes nothing and shows the inside cut open, coloured. Offer it at the end of a big model built in sections, never by default: apply=true with agreed=true only once the person has said yes; a model from a real set also needs set_agreed=true. One step to undo; the booklet shows each colour where its group starts.

For example:

{"mode": "stages", "stages": 2}

Explained in Joints and mechanisms.

Make the sections

make_sections Changes the model

Make the suggested sections (suggest_sections) sub-assemblies, as one undo step, as the model tree's Accept all does. With no sections= every suggestion as suggested; with sections= one sub-assembly for each entry: its name and the numbers of the suggestions it is made of (two or more merge them). Parts already in a sub-assembly go inside the new one.

For example:

{"sections": [{"name": "roof", "from": [21, 22, 23, 24]}]}

Explained in Placing and moving parts.

Break out a section

break_out_section Changes the model

Pull a section (a sub-assembly) away from the model the way it comes off, as Build, Break out the section does: up off the studs it stands on, or out to the side it is joined on, clear of the rest by two studs, by whole studs and bricks. One undo step. Work on it there with edit_model as anywhere. put_back=true puts it exactly where it was (one undo step); all=true puts every section back. Saved and exported files always have every section in place.

For example:

{"section": "roof"}

Explained in Placing and moving parts.

Replace or take away

Can replace or remove what is on the baseplate. Each is still one undo step.

Restyle the walls

restyle_model Changes the model Can replace or remove

A finishing pass over what is already built, wall by wall: plain bricks one stud wide (1x1 to 1x4) whose long face is open to the air, and the outer row of two-wide ones, are laid again in place as one structure per wall — ribs (a column of round plates on bricks with a stud on the side, every few studs), bands (a course of grille), panels (grille between the ribs, framed by a plain stud at each end and a plain course at each ledge, as 10237 Orthanc textures its black), grid (ribs and bands) or courses (round bricks, a recessed line) — in the wall's own colour, never a part at a time. A dark wall gets panels unasked; a light wall not given a style gets a scatter of dressed bricks (sideways) and masonry. The faces of a prism or a cluster too, in their own sections, and a model opened from a file. Done for you, in one call, checked like any edit.

For example:

{"style": "panels", "texture": "grille"}

Explained in Designing with AI.

Edit the model

edit_model Changes the model Can replace or remove

Change what is already built without describing it again. Takes the numbers look_at_model prints beside each brick. Use this for any change to an existing model — moving a wall, recolouring a roof, taking a chimney off, adding a door — and only use submit_design when starting something new. Everything is checked together before any of it is applied, so a change that would not hold together changes nothing.

For example:

{
  "recolor": [
    {
      "bricks": [
        3,
        4
      ],
      "color": 1
    }
  ],
  "move": [
    {
      "bricks": [
        7
      ],
      "dx": 1
    }
  ]
}

Explained in Placing and moving parts.

Build a design

submit_design Changes the model Can replace or remove

Submit the finished model, with every part. It replaces everything on the baseplate that you put there — including anything you added with edit_model. If you have been building with edit_model, the model is already built: say so and stop, rather than submitting a list that is missing the additions.

For example:

{
  "name": "Red house",
  "description": "A small red house with a door at the front",
  "brief": "build a small red house",
  "bricks": [
    {
      "part": "3001",
      "color": 4,
      "x": 0,
      "y": 0,
      "z": 0
    },
    {
      "part": "3001",
      "color": 4,
      "x": 4,
      "y": 0,
      "z": 0
    }
  ],
  "assemblies": [
    {
      "name": "walls",
      "x_from": 0,
      "x_to": 8,
      "z_from": 0,
      "z_to": 6
    }
  ],
  "features": [
    {
      "name": "front door",
      "x": 3,
      "y": 0,
      "z": 0,
      "facing": "+z"
    }
  ]
}

Explained in Designing with AI.

Lay a picture as Brick Art

make_art Changes the model Can replace or remove

Lay a picture as a LEGO® Art set is laid — 31212 The Milky Way, 31208 The Great Wave, 31213 Mona Lisa — on 16 x 16 panels joined underneath into one piece: square tiles merged where it is flat, 1 x 1 round tiles for texture, quarter circles along curved contours, stars in trans-clear, glow-in-the-dark, pearl and metallic set a plate proud, and the subject raised on stacked plates with cheese slopes. Use this, not submit_design, whenever a mosaic, a picture in bricks, wall art or something like a LEGO® Art set is asked for. It replaces what is on the baseplate.

The picture is the one the person chose (look_at_picture shows it). With none, draw it yourself as svg: one stud is one pixel, so big simple shapes in flat colours, like a poster. You decide what a designer of LEGO® Art sets decides, and the app reads everything you leave out off the picture: the panels and the crop; regions over the picture, each with its texture, its relief (the subject raised, the background flat), whether contours run in it and whether its points of light are stars and in what finish; single stars put exactly where you want them; a palette to keep to. Coordinates are fractions of the picture, 0 to 1 from its top left. Later regions lie over earlier ones and change only what they say, so start with the whole picture and work inward. A plan that cannot be laid is refused with every fault named. The answer is the picture as laid, face on, and what it is made of. Look at it as a person would from across a room, and call make_art again with the plan changed if it does not read as the subject.</p>

For example:

{
  "name": "The Great Wave",
  "panels": [
    3,
    2
  ],
  "palette": [
    15,
    1,
    272,
    71
  ]
}

Explained in Mosaics and brickify.

Change the selection

edit_selection Changes the model Can replace or remove

Change the selected parts as edit_model does — take off, paint, move, put down — keeping to the selection's room: a change that reaches outside it is refused whole, and everything else in the model stays where it is. It is checked as any design is, so a change that would not hold together or leaves a part loose changes nothing, and the refusal says, part by part, what each ran into or why nothing holds it, and the nearest place it fits and holds. check_only=true tries a change without making it. Other copies of the sub-assembly follow the change. One undo takes the request back. For more room, give room= and why=: the person is asked first.

For example:

{"recolor": [{"bricks": [2], "color": 14}]}

Explained in Selecting and editing.

Choose a sketch

choose_sketch Changes the model Can replace or remove

Choose one of the three sketches made with submit_design "sketch": true. It goes on the baseplate as the massing the full design is built from, and the other two are dropped. Then design the whole model from it, and submit_design that without sketch.

For example:

{"sketch": 2}

Explained in Designing with AI.

Clear the baseplate

clear_model Changes the model Can replace or remove Same result twice

Take everything off the baseplate and start from bare ground. Do this before building something new, or the new thing is built into the old one.

Takes nothing.

For example:

{}

Explained in Placing and moving parts.

Undo or redo

undo Changes the model Can replace or remove

Take back the last change to the model, as Edit, Undo does — yours or the person's — or steps= of them. redo=true puts back what was undone. The answer names what was undone and what is next.

For example:

{"steps": 2}

Explained in Placing and moving parts.

Open a model

open_model Changes the model Can replace or remove

The person's saved models and the examples that come with the app, with their part counts; name= opens one in place of what is on the baseplate, as File, Open does. Each save is kept as a version, the last 20, as File, Versions… shows: versions=true lists name='s, newest first, and version=N opens the Nth; versions=true with version=N opens nothing and says what changed in the model open now since that save, as Compare draws it: each part added, removed, moved or turned, and recoloured, by number. link= a gallery model's link id (gallery) opens a copy of it saved in the person's models, as Open in Brickworks on its page does. library= an id from gallery library=true ("omr-10179-1") opens LDraw's model of that real set, credited to whoever made it, as File, Library… does. The person's work is never lost: while the model on the baseplate has changes not saved, opening is refused unless discard_changes=true, and an open is undone like any change (undo brings back the model it replaced).

For example:

{"name": "Castle"}

Explained in Saving, opening and files.

Mirror parts

mirror_parts Changes the model Can replace or remove

Make parts their mirror image, as the window's Mirror does: each put where its reflection is and turned, a part made in a left and a right hand (a wing, a wedge plate, a door) swapped for its other hand. bricks= the parts; axis "x" mirrors left to right (the default), "z" front to back. In place, across the plane through their middle; copy=true leaves them and puts a mirrored copy beside them, across their far side (+x or +z). across= puts the plane where you say, in studs, a whole or half number: copy=true across=0 makes a model's left half its right half too. All or nothing, one undo step; refused where the mirror image runs into a part not named.

For example:

{"bricks": [12, 13, 14], "copy": true, "across": 0}

Explained in Placing and moving parts.

Split parts

split_parts Changes the model Can replace or remove

Split parts into smaller ones of their kind on the same studs, as the window's Split does, by Studio's rules: a plate, a brick or a tile into 1 x 1s of its kind, a 1 x 1 brick into three 1 x 1 plates, a slope into the 1-wide slope of its angle, length and height, a curved slope into the 1-wide curved slope of its length. What was joined to them is joined to the pieces. bricks= the parts. One undo step; a part that does not split, or has no room for its pieces, is said and left as it was.

For example:

{"bricks": [21]}

Explained in Placing and moving parts.

Merge parts

merge_parts Changes the model Can replace or remove

Merge parts into the fewest bigger ones, as the window's Merge does: the plates, bricks and tiles of each colour and sub-assembly covered by the fewest real parts made in that colour, biggest first, three plates high a brick, each where the old ones stood. Six 1 x 1 plates in a 2 x 3 become a 2 x 3 plate; three stacked 1 x 4 plates a 1 x 4 brick. bricks= the parts. One undo step; where no real part would be fewer, they are left as they were.

For example:

{"bricks": [30, 31, 32, 33, 34, 35]}

Explained in Placing and moving parts.

Choose the tab

The connector's own two, for the tab a chat works in. They change no model, and a session on the desktop's own port has no need of them.

List the open tabs

tabs Read-only

The Brickworks tabs open for this account, each with its id, its model's name, whether it is in view, when the person last used it and whether another chat is working in it, and which one this chat's calls go to. Call it when the person has more than one tab open, or when an answer names a tab or model you did not expect.

Takes nothing.

For example:

{}

Explained in The Claude connector.

Work in another tab

select_tab Read-only

Work in this Brickworks tab from now on: its id (such as k7qd) or its model's name (such as castle), as tabs lists them. Call it first when the person names a tab or a model, or opens the chat with one. To do one call elsewhere, pass target on that call instead.

For example:

{"tab": "k7qd"}

Explained in The Claude connector.