The store model already works when the owner asks for one more display near the entrance. From the perspective view, there seems to be enough space. Move the fixture into position, however, and the gap between displays may narrow or the entrance sightline may disappear. A convincing image is not the same as a verified layout.

Using SketchUp with Codex can help you test that change systematically. Through a community-built SketchUp MCP connector, Codex can inspect a running desktop model and call supported tools to modify components or export views. Reviewed Ruby code can handle tasks beyond those tools. Separately, Computer Use lets Codex interact with the interface to check selections, visibility, and presentation settings when configured and approved. Neither connection is a native SketchUp feature.

This guide follows an existing store model through two layout alternatives. You will connect Codex, identify the correct fixtures, move one instance at a time, and measure defined clearances rather than estimating them from screenshots. The final deliverable is a comparison set with matching views and recorded checks, while the original model remains intact.

Source: SketchUp Help

Decide What Codex Can Change Before Connecting It

Before giving Codex access to SketchUp, separate the proposed layout change from the approved design. Adding a display does not authorize moving the entrance, resizing furniture, or removing objects that appear inconvenient.

For this walkthrough, establish a boundary:

Save a working copy and identify the fixtures that can move. If their names are ambiguous, select them in SketchUp and ask Codex to report the selection before proposing changes. A matching name is not sufficient evidence that it found the intended instance.

Use MCP for structured model queries and repeatable operations. Use Computer Use to inspect the interface when selection context, visibility, or framing needs a visual check. Neither method replaces a saved baseline or guarantees correct edits.

Define the measurement task as well. Specify which gaps matter and what design target you want to compare against. Codex should report how it measured each gap rather than declaring the entire store layout “clear” from one view. A project target is not automatically a regulatory requirement.

A useful starting instruction is:

Inspect the active store model and the selected display fixtures. Report their identities, dimensions, and positions. Propose one reversible layout change without applying it. Preserve walls, doors, fixture geometry, and materials. Do not save over the original file or export anything yet.

The connector used here requires desktop SketchUp and its Ruby extension. Do not apply these installation instructions to SketchUp Web.

Connect Codex to the SketchUp Bridge

The connection has two parts: a Ruby extension runs inside SketchUp, and a Python MCP server makes its operations available to Codex. Keep SketchUp open with a copy of your store model loaded while you configure and test the connection.

This walkthrough uses the community sketchup-mcp2 connector. Follow its instructions for both components. An extension from another SketchUp MCP project is not necessarily compatible with its Python server.

1. Install and Start the SketchUp Extension

Obtain the project’s .rbz package from its releases, or follow the documented packaging instructions. In SketchUp’s Extension Manager, select Install Extension, choose the package, and restart SketchUp as instructed.

Source: SketchUp Help

Open Plugins → MCP Server → Settings and check the connection settings. The documented default is 127.0.0.1:9876. Keep this loopback address for a same-computer setup.

The extension includes an Enable Ruby evaluation option. Disable it for the initial test. Model inspection through dedicated tools does not require unrestricted Ruby execution.

Start the bridge through Plugins → MCP Server → Start Server.

2. Register the Python Server With Codex

Install uv if needed, then register the server using the Codex MCP command format:

Check the registration:

If Codex cannot locate uvx, replace it with its actual absolute executable path. Start a fresh Codex session after registration so the tools can load.

Registration confirms the configuration, not a successful connection to SketchUp. The extension and Python package must also be compatible.

3. Run a Read-Only Connection Test

Ask Codex:

Read the SketchUp version, active model information, and current selection. Identify the loaded model where possible. Do not create, move, rotate, delete, save, or export anything.

Compare the response with the application. Confirm that Codex reached your working copy rather than another open model. Resolve connection or version errors before attempting edits.

4. Configure Visual Access Separately

Computer Use requires its own plugin setup and permissions. Connecting the SketchUp server does not grant screen control.

The connector also documents a viewport screenshot tool requiring SketchUp 2026 or later. That tool returns an image; it does not provide mouse-and-keyboard interaction. Use structured queries for the initial verification and enable visual access when the task needs it.

Read the Store as a Hierarchy, Not a Flat Object List

A display fixture may look like one object while containing shelves, product components, signage, and nested groups. Moving an internal shelf instead of the complete fixture can leave the model partially rearranged. Before editing, Codex needs to identify both the target instance and its place in the hierarchy.

Source: SketchUp Help

Select one movable display and ask Codex to inspect it using the connector’s selection and component-information tools. Record a small baseline:

• Identity: Entity identifier, name, and object type.

• Context: Parent container and active editing context.

• Placement: Current position, orientation, and available bounding-box information.

• Reuse: Whether other instances share its component definition.

Names help navigation, but they are not reliable unique identifiers. Two fixtures can have the same name. Preserve the returned identifier for the current session, then confirm the target again if an operation replaces entities.

Source: SketchUp Help

Keep Coordinates and Units Explicit

Nested geometry has coordinates relative to its containing context. Measurements or movement targets need a consistent reference frame. When direct Ruby inspection is required, use the relevant component transformations to interpret nested positions correctly. Do not mix a point inside a component with a model-level point and treat the difference as a valid clearance.

Units need the same care. The connector’s documented geometry inputs use millimeters, while direct Ruby operations follow SketchUp’s unit conventions. Changing the model’s displayed units does not redefine every numeric API input.

Ask Codex to summarize the proposed target before moving it:

Identify the complete selected display instance, its parent context, and its current placement. Confirm that the proposed move preserves its dimensions and internal geometry. Report any uncertainty about coordinates or identity before proceeding.

If the fixture is deeply nested, clarify whether you intend to move it within its parent or relocate the complete assembly. Resolve that decision before calculating a new target position.

Move One Fixture and Verify the Result

Start with a single, clearly identified display instance. Moving that instance changes its placement without requiring edits to the geometry inside its definition. That is different from opening the component and moving its internal faces or shelves, which can affect other instances sharing the definition.

For this first test, choose a top-level fixture and apply translation only. Keeping rotation and scale out of the request makes the result easier to verify.

Source: SketchUp Help

Convert the Requested Movement Into the Tool’s Target

The connector’s transform_component tool treats position as an absolute target for the minimum corner of the fixture’s bounding box. It does not interpret that value as a relative movement.

Suppose the inspected bounding-box minimum is:

{
  "min_mm": [2000, 1500, 0]

{
  "min_mm": [2000, 1500, 0]

Moving the fixture 300 mm along the model’s positive X axis gives this target:

{
  "id": "<verified fixture ID>",
  "position": [2300, 1500, 0]

{
  "id": "<verified fixture ID>",
  "position": [2300, 1500, 0]

These are illustrative values. Codex must read your fixture’s actual position and confirm the intended direction before calculating its target. “Right” in a perspective view does not necessarily mean positive model X.

Sending position: [300, 0, 0] would request a different placement, not a 300 mm shift. For nested fixtures, resolve the tool’s coordinate context before using the same calculation.

Approve the Smallest Change

Give Codex a bounded instruction:

Propose a 300 mm translation along model X for the verified display instance. Report its current bounding-box minimum and calculated target. Do not rotate, scale, modify internal geometry, or save the file. Wait for approval before applying the move.

After approval, submit only that operation. Read the resulting position and dimensions, then compare them with the baseline. Confirm that the fixture moved by the intended amount and that its orientation, size, and internal arrangement remain unchanged.

The SketchUp transformation API distinguishes operations that apply transforms from those that replace them. Reviewed Ruby should use deliberate transformation logic rather than treating these methods as interchangeable.

Do Not Repeat an Uncertain Operation Blindly

The connector documents rotation as relative, unlike its absolute position target. Repeating a rotation request can rotate the fixture again. Scale factors are relative too.

If a tool call times out, inspect the model before retrying. The operation may have completed even though Codex did not receive its response. Compare the actual state with the requested state and decide whether another action is necessary.

Once the move is verified, record it and check the affected clearances. Do not expand the change to every display until this first result is understood.

Source: SketchUp Help

Measure Clearances Instead of Guessing From the Viewport

The moved fixture may look comfortably separated from its neighbor, but perspective is not a measuring tool. Check the specific passage affected by the change using model geometry, then use the image to understand how that passage reads visually.

Define the measurement before asking Codex to calculate it. Identify the two boundaries, the direction of measurement, and whether projecting parts such as shelves or signage belong in the clearance check. “Measure the aisle” is too vague if the fixtures are angled or have irregular footprints.

Use Bounding Boxes as an Initial Check

A bounding box provides coordinate extents that can help identify potential conflicts. For two simple, axis-aligned rectangular fixtures, comparing the relevant extents can provide a useful preliminary gap measurement.

However, an axis-aligned box around a rotated fixture includes space outside its actual geometry. A difference between box extents is not automatically the shortest distance between surfaces. An overlapping box also does not necessarily mean the modeled objects intersect.

Label these results as bounding-box checks. Do not report them as exact clear widths without verifying the geometry and measurement direction.

Measure Between Verified Boundaries

For a defined passage, select or identify the relevant model points or surfaces. If the connector’s dedicated tools cannot provide the required measurement, a reviewed Ruby query can calculate it.

Both endpoints must be expressed in the same coordinate system. For nested components, account for the complete chain of parent transformations, not just the immediate container. Record the endpoints and method so another person can reproduce the check.

A measurement report might use this structure:

Measure more than one location where the passage changes width. One generous gap does not establish that the entire route has the same clearance. Measurements also describe the modeled objects, not omitted merchandise or real-world installation differences.

Compare the results with the project target supplied by the user. Keep the conclusion narrow: the measured locations meet or miss that target under the stated method. This is a layout check, not an automatic accessibility, fire-safety, or regulatory approval.

If the result is unclear, confirm the boundaries before moving the fixture again.

Source: SketchUp Help

Use Computer Use for Selection and Presentation Checks

Model queries and measurements establish what changed. Computer Use helps inspect whether the visible result matches the intended task. Use it for specific checks rather than asking Codex to reorganize the store through unrestricted clicking.

Configure Computer Use separately from the SketchUp MCP connection and approve access to SketchUp. On Windows, keep the application visible on the active desktop while the task runs. Screen interaction uses that desktop session, so avoid competing mouse or keyboard input.

Confirm the Target Before Moving It

Ask Codex to inspect the selection highlight, Entity Info, and Outliner where available. It should confirm that the selected object is the complete display fixture, not a shelf or product component inside it.

A bounded instruction could be:

Inspect the selected display and its editing context. Compare it with the fixture identified in the model report. Do not move, repaint, delete, or save anything.

A screenshot can support this check, but it should not replace the entity identifier and hierarchy information. If visual and structured evidence disagree, resolve the target before editing.

Find Visibility Problems Without Unhiding Everything

After a move, an object may appear missing because of tag visibility, a section plane, or the active scene. Do not immediately assume that geometry was deleted.

Have Codex inspect the relevant controls and explain the likely cause. Avoid broad repairs such as showing every tag or disabling every section cut. Those actions can expose construction geometry and make the presentation harder to evaluate.

Apply only an approved, targeted correction, then check the view again.

Source: SketchUp Help

Compare the Layout From a Human Viewpoint

Open the agreed entrance scene and inspect what the new arrangement communicates. Does the added display obscure another fixture? Is the focal area still visible? Does the camera crop out the passage you intend to discuss?

These are visual observations, not clearance measurements. Keep the numerical checks alongside them.

Ask Codex to report specific issues and capture the relevant view where supported. If a camera adjustment is approved, save it deliberately as a separately named comparison scene. A temporary viewport change should not silently replace the baseline presentation angle.

Package Two Layouts for a Fair Comparison

Keep the approved baseline and proposed arrangement in separate .skp files. This makes the geometry state explicit and prevents a presentation scene from being mistaken for a saved layout alternative.

SketchUp scenes preserve selected view properties, including camera position, visibility, styles, and shadows. They do not independently restore furniture positions. Two scene tabs named “Layout A” and “Layout B” will not, by themselves, move the fixtures between arrangements.

Source: SketchUp Help

Use the same two presentation views in both files:

Keep the camera framing consistent. For the plan view, use matching projection and visibility settings. For the entrance view, preserve the camera position and field of view so the layout change remains the main difference.

Source: SketchUp Help

Link Each Image to the Model State

Before exporting, ask Codex to confirm the active file, selected scene, and recorded fixture placement. Then use 2D Graphic export with agreed image dimensions and format.

Create a compact delivery record containing:

• Model filename and revision.

• Scene name and output filename.

• Export dimensions.

• Associated measurement report.

A viewport screenshot can document an inspection, but it is not automatically a final presentation image. Exported files need their own review for framing, resolution, selection highlights, and unintended hidden geometry.

Ask Codex to open or inspect each output where supported rather than accepting an export success message as proof of correctness. Confirm that the proposed images actually show the verified move and that the baseline images remain unchanged.

Finally, review the four images together with the measurement report. If a visual difference suggests another adjustment, treat that as a new revision requiring approval. Do not quietly modify the model while assembling the package.

The finished comparison should show what moved, how the recorded gaps changed, and which model file each image represents.

Keep Automation Recoverable

Save a checkpoint before applying the approved layout change. Record the target fixture and its initial transform so you can distinguish a successful edit from an incomplete or unintended one.

The SketchUp MCP connector documents undoable operations for its mutating handlers. That helps recover individual edits, but undo does not replace separate model files or protect an exported image from being overwritten.

Keep Ruby and Network Access Narrow

Enable eval_ruby only when a reviewed operation requires it. Arbitrary Ruby execution inside SketchUp can reach beyond model editing, so inspect the code and retain approval boundaries.

For this same-computer setup, keep the bridge on loopback. Do not expose it to the network to bypass a connection error. Check the extension, host, port, and version pairing instead.

If Codex reports an uncertain result, stop the editing sequence. Do not compound the uncertainty by moving another fixture or retrying a relative rotation.

Recover the last understood state, repeat the relevant inspection, and propose the smallest correction. Expand the workflow only after the repaired result is verified.

Give Larger SketchUp Projects More Room on Vagon

A store model can become demanding when detailed shelving, product assets, signage, and high-resolution textures accumulate. Navigation and scene changes may slow down, making it harder to inspect alternative layouts before a client review. At that point, computing capacity becomes part of the workflow.

Vagon Cloud Computer gives you access to a cloud workstation from your existing device. You can install SketchUp, bring your project files and extensions, and choose available performance options suited to the model. Instead of replacing your laptop before taking on a larger project, you can move the working environment to a cloud computer.

Keep SketchUp, Codex, and the MCP server on that same workstation. The local bridge then stays within the cloud computer, while you access the environment remotely. Model revisions, measurement reports, and presentation exports can remain together, reducing the need to transfer files between machines during review.

Match the hardware to the workload. SketchUp navigation, Ruby operations, and an optional renderer have different performance requirements. A larger GPU does not automatically accelerate every model query or transformation, and renderer support depends on the software you install.

Test the actual store model before expanding the task. Check viewport responsiveness, run a small inspection, and export a representative view. Those checks give you a practical basis for selecting capacity without relying on unsupported speed claims.

With the environment ready, use Codex to coordinate controlled layout changes and verification, and Vagon to provide the workstation resources behind the project. You can then focus on the proposed arrangement and its presentation while keeping the same checkpoints and approval boundaries.

FAQs

Can Codex Modify an Existing SketchUp Model?

Yes, through a compatible connection and supported tools. The community SketchUp MCP connector used here can inspect components, transform fixtures, and export supported formats. More specialized tasks may require reviewed Ruby execution. Start with a working copy and verify the target instance before applying changes.

Is SketchUp MCP an Official Integration?

The connector in this guide is a third-party community project, not a native SketchUp feature or a Trimble-supported integration. Its maintainers define its capabilities and compatibility requirements. Review the extension and Python package, keep their versions compatible, and test the connection on a non-sensitive model before using client work.

Can I Use This Setup With SketchUp Web?

Not with the extension-based connection described here. This setup requires desktop SketchUp and a Ruby extension running inside it. Browser interaction is a separate approach with different controls and limitations. Do not apply desktop extension installation steps or assume that Ruby API access exists in SketchUp Web.

Does Connecting MCP Also Enable Computer Use?

No. MCP configuration makes the server’s tools available to Codex. Computer Use requires its own setup, operating-system permissions, and app approval where applicable. A connector tool that returns a viewport screenshot does not give Codex mouse-and-keyboard control. Use structured tools for repeatable operations and visual access for interface checks.

Can Codex Measure Aisle Widths Accurately?

It can help calculate defined measurements from model geometry, provided the boundaries, coordinates, and units are correct. Screenshots are not reliable measurement sources, and bounding-box gaps are not always actual surface clearances. Record the method and check multiple locations where needed. Results describe the modeled layout, not omitted objects, construction tolerances, or regulatory approval.

Why Did Repeating a Movement Request Produce a Different Result?

Different transform inputs can have different meanings. In this connector, position is an absolute bounding-box-minimum target, while rotation and scale are relative. Repeating a relative operation can apply another change. If a call times out, inspect the current state before retrying because the first operation may already have completed. Also distinguish model axes from screen directions when requesting a move.

Can Scenes Store Separate Furniture Layouts?

Not as independent geometry-position snapshots. SketchUp scenes save selected presentation properties, including camera and visibility settings, but switching scenes does not automatically restore moved fixtures. This walkthrough uses separate model files for the baseline and proposed layout, with matching presentation scenes in each. Associate every export with its source model revision so the comparison remains traceable.