Skip to content
Buy Now

AI Agents

AI agents like Claude and Codex can work in Rayscaper for you. An agent is an AI assistant that uses Rayscaper by itself, from your instructions. Tell one what you want in your own words:

  • “Turn my model into a dusk shot for the client.”
  • “Make this look like a magazine shot.”
  • “Light this room for the evening.”

The agent plants the garden, sets the sky, the lights and the materials, and frames the camera. Then it adjusts the brightness and the colors of your render. It looks at the render after every change, the way you would, and keeps going until the result is right.

Claude Code sets up a villa straight from SketchUp for a dusk render, from one prompt. Turn on the sound for the narration. Left: the conversation and every tool it calls. Top right: the render in Rayscaper. Bottom right: the model in SketchUp, with the preview of the plants it scatters, and the steps of the setup. Fast-forwarded: the whole run took eight minutes.

Agents reach Rayscaper through MCP (Model Context Protocol), the standard way for AI apps to use other programs. Rayscaper runs an MCP server while its render window is open, in SketchUp and in the standalone app. It works with any agent app that speaks MCP: Claude Code, Codex, Claude Desktop, Cursor, VS Code and others.

You need an agent app, Rayscaper 0.9.99 or newer and a few minutes. The quickest way is to let the agent set itself up: copy this prompt into Claude Code, Codex or another agent app.

Paste this into your agent
Set yourself up to use Rayscaper, the renderer for SketchUp, through its MCP server.
1. Register Rayscaper's MCP server for all my projects under the name "rayscaper". It's a Streamable HTTP server at http://127.0.0.1:47390/mcp, without authentication.
- Claude Code: run `claude mcp add --scope user --transport http rayscaper http://127.0.0.1:47390/mcp`
- Codex: add this to ~/.codex/config.toml and keep what's already there:
[mcp_servers.rayscaper]
url = "http://127.0.0.1:47390/mcp"
- Another app: add it the way that app adds a remote MCP server.
2. Install the Rayscaper skill: download https://rayscaper.com/agents/rayscaper/SKILL.md and save it as rayscaper/SKILL.md in my personal skills folder (~/.claude/skills for Claude Code, ~/.codex/skills for Codex). If you have no skills, keep its advice in mind when you use the rayscaper tools.
3. Tell me what you changed. The tools show up in a new session, while Rayscaper's render window is open.

The agent registers Rayscaper’s MCP server and installs the Rayscaper skill, which teaches it how to work with renders. Then:

  1. Open the render window: in SketchUp click Start Render in the Rayscaper toolbar, or open a scene in the standalone app. The agent can only reach Rayscaper while the window is open.

  2. Start a new session in your agent app, so it loads the Rayscaper tools.

  3. Ask it something: “What’s in my Rayscaper scene?” A badge in the corner of the render shows that the agent is connected.

Tools > Connect AI Agent… in the render window shows the settings for the most common apps, with a Copy button. They point to the address of your Rayscaper.

The Connect an AI Agent dialog with the settings for Claude Code, Codex and Claude Desktop

Run in a terminal:

Terminal window
claude mcp add --scope user --transport http rayscaper http://127.0.0.1:47390/mcp

--scope user makes Rayscaper available in all your projects.

The skill tells the agent how to work in Rayscaper:

  • Look at the scene and the render before it changes anything.
  • Change one thing at a time and check the result.
  • Keep the previous settings, so changes can be undone.
  • Practical advice for light, exposure, cameras and materials.

The setup prompt installs it. To install it yourself, save SKILL.md as rayscaper/SKILL.md in the skills folder of your agent app: ~/.claude/skills for Claude Code and ~/.codex/skills for Codex. Other apps can use it as instructions.

Show the skill
rayscaper/SKILL.md
---
name: rayscaper
description: Render, light and art-direct SketchUp models in Rayscaper through its MCP server (the rayscaper tools). Use when the user asks to change or judge a Rayscaper render, its materials, lights, sky, camera, scatters (grass, plants, trees) or look, to set up a model for rendering, to make render variations, or to set up the Rayscaper MCP server.
---
# Rayscaper
Rayscaper is a path tracer for SketchUp, with a standalone app for other scene files. While its render window is open
it runs an MCP server, and the `rayscaper` tools change the scene the user is looking at. The user watches the render
window while you work: a badge in its corner shows what you're doing, and they can stop your access there at any time.
## Connecting
The server is Streamable HTTP at `http://127.0.0.1:47390/mcp`, without a token. It only runs while Rayscaper's render
window is open (SketchUp: **Extensions > Rayscaper > Start Render**, or the standalone app). When that port was taken,
Rayscaper uses the next free one: every running Rayscaper writes its url to `mcp/instances/<pid>.json` in its profile
(`%APPDATA%\Rayscaper` on Windows, `~/Library/Application Support/Rayscaper` on a Mac, `~/.config/Rayscaper` on
Linux).
If the `rayscaper` tools are missing, register the server once for all projects and start a new session:
- Claude Code: `claude mcp add --scope user --transport http rayscaper http://127.0.0.1:47390/mcp`
- Codex: add to `~/.codex/config.toml`:
```toml
[mcp_servers.rayscaper]
url = "http://127.0.0.1:47390/mcp"
```
- Other apps: add a remote (Streamable HTTP) MCP server with that url and no authentication. Apps that only start
local servers as a command use `npx -y mcp-remote http://127.0.0.1:47390/mcp`.
If the tools are there but every call fails, check these with the user:
- The render window is open.
- Agent access is allowed: the user can stop it with the badge in the corner of the render, and allow it there again.
- The url you use is the one that **Tools > Connect AI Agent...** in the render window shows. A second Rayscaper, for
example the standalone app next to SketchUp, uses another port.
## How to work
1. **Look before you change.** Call `get_scene` first: it lists the camera, environment, post processing, render
settings, materials and lights with their names. Call `get_selection` when the user says "this" or "the selected
...". Then look at the render with `get_render_image` and `wait_for_samples: 32`. `render_control` starts, pauses
and resumes the render, and tells its state and samples.
2. **Find things in space with `pick_point`.** It tells what is at a point of the image (x and y from 0 to 1, from the
top left): the material, the position in meters (Z is up), the normal and the bounds of the object. Use it to find
the table to hang a light above, the floor height or the wall to aim at.
3. **Change one thing, then look again.** After a change call `get_render_image` with `wait_for_samples` (about 32
for a quick look, 128 or more to judge noise and fine detail) and judge the image yourself: exposure, contrast,
color, composition. Repeat until it looks right. Post processing doesn't restart the render, so its changes show at
once; the environment, materials, lights and camera restart it.
4. **Keep the way back.** Every set tool returns the previous settings. Materials, the environment, scatters and post
processing can't be undone by the user, so remember the previous values and offer to put them back.
`set_material` with `restore` puts a material back as it was before your first change, image textures included.
Lights placed or moved in SketchUp and SketchUp camera moves are steps the user can undo in SketchUp.
5. **Save what the user asked for** with `save_render` and an absolute path ending in `.png`, with
`wait_for_samples` (256 to 1024 for a final image). `.exr` needs a Rayscaper license. A wait returns after about
45 seconds, before agent apps give up on a tool call: when the result says `timed_out`, call again with the same
`wait_for_samples` until the samples are in.
6. **Compare with the render history.** `render_history` with `save` keeps the live render (wait for a clean one
first), `list` lists the saved renders and `show` shows one in the render window and returns it as an image.
`set_post_processing` applies to a shown render too, to try another look without rendering again;
`apply_post_processing` restores the look a render had when it was saved. A wait for samples shows the live render
again. Use it to keep the versions you try, for example two skies or three lighting moods, and to show the user the
best.
7. **Use the tools, not the UI.** Every change above has its own tool. `get_window_image` and `send_ui_input` show and
click the application's UI itself: use them only when the user asks for something in the UI. A wrong click can
open another scene and lose the user's work (the File menu of the standalone app loads a sample scene without
asking), and a menu you open stays open in front of the user. Close what you open with Escape.
## Setting up a whole scene
A model straight from SketchUp renders with a sky, AI denoising and SketchUp's materials, and a model saved with
Rayscaper has its own settings: read `get_scene` before you change them. To set it up, work from the big picture to
the details and look at the render after every step:
1. **Sky and exposure** (`set_environment`, `set_post_processing` with `denoise`): the light decides everything else.
2. **Materials**: glass that is real glass, water that is water, and finishes from the asset library for the large
surfaces (`find_materials`).
3. **Grass and scatters**: lawns that grow real grass, and plants and trees from the components of the model (see
Craft).
4. **Lights**: lamps, fixtures and accents, mostly for evening and interior shots.
5. **Camera**: the view, focal length and the resolution of the image.
6. **Render settings and post processing**: samples for the final image, then the look (contrast, white balance,
vignette, bloom).
7. **Final render** with `save_render`.
## Craft
- **Light:** the sky sets the mood. `set_environment` takes a sky preset (Clear, Hazy, Overcast, SoftLight,
GoldenHour, Sunset, BlueHour) and the sun's elevation and rotation; a low sun gives long shadows and warm light, but
nearby walls can block it, so check where it falls. For night, put the sun below the horizon or use a dark
environment, and light the scene with lamps. `find_hdris` finds HDRIs in the asset library for real-world light.
- **Lamps:** turn a lamp shade into a light source by making its material emissive (warm white is about 2700 K), or
`place_light` a point, spot or area light inside or below it. Give a light a `preset` (for example `Bulb 60 W`,
`LED Downlight`, `Window`) to make it as bright as the real one instead of guessing an intensity, or set its
`brightness` in lumen (cd/m² for an area light without normalize, lux for a directional light); it keeps when the
temperature or a spot's cone changes. Real lamps need auto exposure at night. Spotlights take IES profiles for
realistic beams. Warm interior light against a cool blue-hour sky is a classic evening look.
- **Changing lights:** `get_light` returns the settings of a light as `set_light` takes them, with its position and
direction. `set_light` changes, moves, turns or resizes a light; `remove_light` removes it and returns its
settings, so `place_light` can bring it back.
- **Exposure:** adjust it with `set_post_processing` before adding lights. Interiors lit only through windows usually
need +1 to +2 EV. Avoid clipped windows and crushed shadows.
- **Camera:** `set_camera` moves and aims the camera and sets the focal length (24 to 35 mm for interiors), the
resolution and depth of field. Keep verticals straight by keeping the camera level (target at the same height as
the position) for architecture. In SketchUp it moves SketchUp's camera, and fails while Lock Camera is on. While a
SketchUp section plane cuts the model, `get_scene` reports its `section_cut` under the camera, and
`section_cut_light` sets whether daylight comes in through the cut (`LetIn`) or the room keeps its shadows
(`KeepShadows`, for a cutaway of an interior).
- **Materials:** `get_material` and `set_material` change a material by name; colors are linear RGB from 0 to 1, so
a mid grey is about 0.2, not 0.5. `find_materials` searches the asset library, and `set_material` with `asset`
replaces a material with one from there. A change is Rayscaper's own, the SketchUp material stays as it is.
Glass takes a `glass_preset` (`Clear`, `Window Pane`, `Lightly Frosted`, `Frosted`, `Crystal`, `Acrylic`, `Water`,
`Diamond`, `Anti-Reflective`) that sets its IOR, roughness and `thin` and keeps the color: `Window Pane` for a window
modelled as a single face, `Water` for water in a glass or a vase.
Curtains, lampshades and leaves that are lit from behind need `translucency` (0.4 to 0.7 for sheers, or the
`Sheer Fabric` finish), not a low opacity: translucency lets the light through softly, opacity makes a hole.
- **Grass:** `set_material` with `type: Grass` turns the material of a lawn into grass that grows on every face
painted with it, in the render only. Start from a `grass_preset` (`Mowed Lawn`, `Garden Lawn`, `Meadow`,
`Dry Grass`, `Artificial Turf`). The lawns and the meadow keep the color, a medium to dark green, about
(0.06, 0.14, 0.035), looks natural; `Dry Grass` and `Artificial Turf` set a straw and a turf green. Then tune
`grass_height` (meters), `density` (relative to the preset), `mowing_stripes` (meters, 0 is off), `dryness`,
`patchiness`, `flattened`, `seed_heads`, `wind` and `wind_direction` (degrees, 0 is +X), `tip_color` and the others that `set_material` lists. `get_material`
reports what grew in `grass_grown`: clumps, blades and `capped`, which says an object holds too much grass and
grows it less densely. The grass grows again a second or two after a change, so render after it. A lawn of the Grass
material looks better than a scatter of grass components; Rayscapers before the Grass material don't list `Grass`
among the types of `set_material`, scatter grass there.
- **Fur:** `set_material` with `type: Fur` grows real strands on every face painted with the material, in the
render only: shag and short pile rugs, sheepskin, faux fur throws, plush cushions, the coat of an animal. Start
from a `fur_preset` (`Shag Rug`, `Short Pile Rug`, `Sheepskin`, `Faux Fur`, `Plush`, `Animal Fur`, `Long Hair`);
they keep the color, except `Animal Fur` and `Long Hair`, which color the strands by `melanin` and
`melanin_redness`. Then tune `fur_length`
(meters), `fur_density` (strands per cm²), `strand_thickness` (mm), `curl`, `fur_direction`, `shine`, `clumping`,
`comb_random` and `comb_direction` and the others that `set_material` lists. Give it the color the rug has; Rayscaper
compensates for the light that bounces between the strands, a cream rug is about (0.55, 0.46, 0.33). An image texture in UV
mapping colors every strand by the texture at its root, so a patterned rug keeps its pattern. `get_material`
reports `fur_grown`: the strands and `capped`. Fur takes longer to render than a plain material; for velvet,
felt or a fabric seen from afar, the `sheen` of PBR is enough.
- **Scatters:** `get_scatters` lists the surfaces (groups and components, with the materials of their faces) and the
components that can be scattered, with their size. `set_scatter` spreads components over a surface, limited to the
faces of `surface_materials`: the beds of a garden group get plants, its border shrubs. The plants to scatter often
stand once in the model or on a hidden tag. Typical densities per m²: grass components 100 to 300, ground cover 5
to 20, shrubs 0.5 to 2, trees 0.01 to 0.05. Mix several plants with weights, vary their scale (0.8 to 1.3), sink
grass and shrubs a little with `offset` (-0.01 to -0.03 m), and start with a low density: many instances slow the
render down. `remove_scatter` removes a scatter and returns its settings, so `set_scatter` can make it again.
- **Look:** tone mapping, contrast, white balance, vignette, bloom and glare are post processing, so try them freely.
- **Speed:** for quick comparisons lower the samples with `set_render_settings` and put them back afterwards.
## Ideas to offer
- Setting up a model from scratch for a client presentation: plants, materials, sky, lights, camera and look.
- Art direction: "make this look like a magazine shot", judged and improved step by step.
- The same view at several times of day, each saved as its own image.
- Evening lighting: find the lamps and place lights where a lighting designer would.
- Material options from a design brief, rendered side by side, then the original materials back.
- Troubleshooting: why a render is dark, noisy or flat, and the fix.
- Finding the best viewpoints of a model with quick low-sample renders.

An agent sees and changes what you see in the render window:

LookThe scene: camera, environment, materials, lights and settings. The render itself, at the number of samples it asks for. What you selected in SketchUp. What is at any point of the render, with its position in the model.
LightSky presets and the sun, HDRIs from the Asset Manager, a plain color. Place, move, change and remove point lights, spotlights (with IES profiles), area lights and directional lights.
MaterialsChange any material like the material editor does, or replace it with one from the Asset Manager. Turn a lawn into real grass with the Grass material, a rug or a throw into real strands with the Fur material. Put a material back as it was before the agent changed it, textures included.
PlantsScatter grass, plants, trees or any other component of the model over the faces of a group, limited to the faces of a material: the lawn, the beds, a hillside. In SketchUp, with Rayscaper 0.9.100 or newer.
CameraMove and aim the camera, the focal length, resolution and depth of field. Whether a section cut lets light in.
Look and outputExposure, tone mapping, white balance, contrast, vignette, bloom and glare. The samples and render method. Save the render as PNG, or EXR with a license.
CompareKeep renders in the render history, show them again, compare them and try another post processing on them.
WindowStart, pause and resume the render. When you ask for it, see the whole render window and click in it.

These were recorded with the prompts as shown and the Rayscaper skill installed: the first two in SketchUp, the others in the living room of the Quick Start scene, opened in the standalone app. Every run is different: the agent judges the render each time, so you get its own take on your prompt.

“This is my villa design, straight from SketchUp: nothing is set up for rendering yet. Turn it into a dusk shot for a client presentation, the kind that sells the house. Do the whole setup: plant the lawn, the beds and the shrub border with the plants in the model, make the materials look real, set the sky, light the house, the pool and the garden, frame the shot, and finish with the render settings and the post processing. Check the render after each step.”

The model had a few plants, each standing once in a bed, light fixtures without lights, and nothing set up for Rayscaper. Claude found that the sky followed SketchUp’s sun (Use SketchUp Sun for Sky was on). So instead of moving the sun, it chose a dusk HDRI from the Asset Manager. Then it worked through the scene:

  • Materials: it made the windows real glass and tinted the pool water turquoise. It made the lamp shades and the lenses of the fixtures glow at 2700 K. It gave the plain surfaces textures from the library: stucco, concrete, corten and a mosaic in the pool.
  • Plants: it planted the garden with three scatters, each limited to the faces of one material. Grass on the lawn, gazanias, succulents and grasses in the beds, and shrubs along the border.
  • Lights: lights in the rooms so they glow through the glass, lights in the pool, uplights on the oak, IES downlights under the overhangs and uplights in the trees. It dimmed the sky so the lamps stand out. When the pool lights made the water too bright, it turned them down.
  • Camera and colors: it moved the camera to eye height at the end of the pool, so the pool leads into the house. It turned the HDRI to put the sunset glow behind the house. It set the colors with the ACES tone mapping, a cooler white balance, bloom and a vignette, and saved a 1920×1080 render at 1024 samples.
The villa before: a daylight render of the bare model, with one plant of each kind in a bed
Before
The villa after: a dusk render with a lit pool, a glowing interior, uplit oak cladding and a planted garden
After

“This is our new restaurant, a modern bistro, modelled in SketchUp: nothing is set up for rendering yet. Make a striking evening render of the dining room for the opening campaign, with the warm, moody atmosphere of a Friday night. Set the sky for dusk, make the materials look real (the glassware, the bottles, the antique mirror, the marble, the brass and the velvet), let the globes, sconces, LED strips and candles glow and add the lights the room needs, frame the shot, and finish with the render settings and the post processing. Check the render after each step.”

Recorded with Claude Code on Opus 5.5 in SketchUp, with narration. It ends with the model as it came out of SketchUp and the render one prompt made of it.

The restaurant was modelled down to the bottles on the shelves, with plain SketchUp materials. Claude chose a dusk HDRI because the sky followed SketchUp’s sun. It turned the glasses, bottles and windows into real glass and the brass into metal. It gave the velvet a fabric sheen and the marble a polished coat. It made the opal globes, the sconces, the LED strips of the back bar, the candles and the windows across the street glow. Then it found the tables with pick_point and hung an IES spotlight above each one. It framed the room level and wide from the corner, and cooled the white balance against the warm lamps. It added contrast, bloom and a vignette, raised the bounces for the mirror and the bottles, and saved a 1920×1080 render at 1024 samples.

The restaurant before: a daylight render of the model straight from SketchUp, with flat materials and no lamps on
Before
The restaurant after: a dark, warm dining room with glowing globe pendants, sconces on a mirror wall, a back bar of bottles lit in front of green zellige and candlelit marble tables
After

“Make this render look like a shot from an interior design magazine. Look at the render, decide what holds it back and fix it step by step: the light, the camera and the look. Check the render after each change.”

Claude found three problems:

  • The sun stood high in the north, so no sunlight came in.
  • The 90° lens stretched the corners, and the tilted camera made the verticals lean.
  • The tone mapping was flat.

It tried a few sun positions. Then it measured the window, the roof overhang and the garden wall with pick_point. It worked out that the sun only reaches the rug between about 25° and 36° high, and set the sun there. It moved the camera back to a level 28 mm view. It added a soft fill light outside the glass, and turned it down to a tenth when the render showed that the rug became too bright. It lit the pendant and adjusted the colors. It tried depth of field too, and dropped it because the room looked like a miniature.

The living room before: dark, lit only by a high sun
Before
The living room after: bright, with sun on the floor and a glowing pendant lamp
After

“Render this view at five times of day: morning, noon, golden hour, blue hour and night. For the night shot switch on the lights of the room so it feels lived in. Get the exposure right for each one and save them.”

Claude set the sun, the exposure and the white balance for each time of day and checked every render before saving it. It found that the garden wall blocks the sun below about 12°, so its golden hour sun sits at 13.5° to get a beam across the rug. For the night shot it put the sun below the horizon, made the pendant lamp glow at 2700 K, and placed two spotlights with IES profiles: a wall wash on the print and a flood over the plant in the corner. They did nothing at first: the render showed it had placed them inside the ceiling, so it lowered them.

The living room in the morning
Morning
The living room at noon
Noon
The living room at golden hour
Golden hour
The living room at blue hour
Blue hour
The living room at night, lit by its lamps
Night

“It’s 9 pm and the sun is down. Light this room the way a lighting designer would: warm light from the pendant lamp, a few accents, and no dark corners or harsh hotspots. Look at the render to check your lights and adjust them until it looks good. Save the final render.”

Claude set the sky to blue hour with the sun below the horizon and built a lighting plan:

  • the pendant globe, glowing at 2700 K, as the main light,
  • IES spotlights on the print and the plant,
  • two soft downlights, so no corner goes black,
  • lights on the deck and between the plants outside, so the window shows a lit patio instead of a black mirror.

Its first render was much too bright and orange. It cut every light to about a quarter, set the exposure back and cooled the white balance, and checked again before saving. At the end it listed the settings it changed, so they can be put back.

The living room at night, lit by the pendant lamp, accent spots on the print and the plant, and downlights, with a blue dusk outside

In SketchUp, the lights an agent places become Rayscaper light components in your model, and you can undo them like any other change.

“My client can’t choose a style for this room. Make three versions: Scandinavian (light oak, white, pale wool), industrial (concrete, black steel, cognac leather) and warm mid-century (walnut, olive, brass). Use materials from the asset library where it has good ones. Save a render of each, then put the original materials back.”

The living room in Scandinavian style
Scandinavian
The living room in industrial style
Industrial
The living room in mid-century style
Mid-century

Codex read every material of the room, searched the asset library for oak, wool, concrete, steel, walnut and brass, and changed the floor, the feature wall, the walls and the window frames for each style, with an exposure and white balance to match. It left the furniture alone: its materials use the scene’s own image textures, which the tools can’t bring back once they are replaced. Afterwards it put the original materials back and said which one it couldn’t restore exactly.

  • “Make what I selected look like brushed brass.”
  • “Plant the hillside with pines and the meadow with wildflowers, and keep the path clear.”
  • “My render is dark and noisy. Find out why, fix it and tell me what was wrong.”
  • “Find the five best viewpoints of this house with quick renders, and save the best three.”
  • “Here’s a photo of a room I like. Match its mood: the light, the colors and the contrast.”
  • “The client wants the sofa in their brand color, #1F4E79.”
  • “Light the dining table with three pendant spotlights 80 cm above it.”
  • “Compare this view with an HDRI of an overcast sky and with a clear sky, and tell me which reads better.”
  • “Try three moods for this room, keep each one in the render history and show me the best one.”
  • “Save a 4K render of this view for print.”

The badge in the top right corner of the render shows what the agent is doing, for example Claude is looking at the render.

The agent badge in the render window: Claude is waiting for 64 samples
  • Stop Agent Access: click the badge and then Stop Agent Access. This disconnects every agent and refuses new ones until you click Allow Agent Access in the same place.
  • Undo: in SketchUp, lights that an agent places or moves and the camera moves are SketchUp steps, which Edit > Undo takes back. Changes of materials, the environment and post processing are Rayscaper’s own: ask the agent to put them back. It gets the previous settings with every change, and the Rayscaper skill tells it to keep them.
  • SketchUp materials stay as they are: the agent changes the Rayscaper side of a material. The Reload button of the material editor brings back the SketchUp values.

Rayscaper’s MCP server runs on your computer and only accepts connections from it, and web pages can’t reach it. Rayscaper doesn’t send your scene anywhere. Your agent app does: what the agent reads, like the renders it looks at and the names and settings in your scene, goes to the AI provider of that app, under its terms. Close the render window or click Stop Agent Access when you don’t want an agent to see your scene.

The agent has no Rayscaper tools. Agent apps load MCP servers when a session starts: start a new session after setting it up, with the render window open.

The tools fail with a connection error. The render window is closed, or you stopped agent access. Open the window or allow access again from the badge. If the agent still can’t connect, start a new session.

Two Rayscapers are running, for example SketchUp’s render window and the standalone app. Only one can use port 47390. The second one takes 47391 and so on, and its Tools > Connect AI Agent… shows that address. The agent talks to the Rayscaper at the address you set up.

The agent can’t move the camera in SketchUp. Lock Camera is on in the Rayscaper toolbar, so the render doesn’t follow SketchUp’s camera. Turn it off.