diff --git a/.github/workflows/sdk_protos_map.csv b/.github/workflows/sdk_protos_map.csv
index bc9514a695..f0a3e41abb 100644
--- a/.github/workflows/sdk_protos_map.csv
+++ b/.github/workflows/sdk_protos_map.csv
@@ -83,9 +83,7 @@ button,GetResourceName,No,get_resource_name,Name,getResourceName,name
 button,Close,No,close,Close,,
 
 ## Camera
-camera,GetImage,,get_image,Image,image,getImage
 camera,GetImages,,get_images,Images,getImages,getImages
-camera,RenderFrame,,,,,renderFrame
 camera,GetPointCloud,,get_point_cloud,NextPointCloud,pointCloud,getPointCloud
 camera,GetProperties,,get_properties,Properties,properties,getProperties
 ## TED: Camera in Go SDK doesn't appear to implement (inherit) these:
@@ -173,6 +171,7 @@ motor,IsPowered,No,is_powered,IsPowered,powerState,isPowered
 ## HACK: No proto for these (and/or inherited in Go SDK), manually mapping:
 motor,IsMoving,Yes,is_moving,IsMoving,isMoving,isMoving
 motor,Stop,Yes,stop,Stop,stop,stop
+motor,GetGeometries,No,get_geometries,,,
 motor,Reconfigure,No,,Reconfigure,,
 # NOT implemented in other languages
 motor,DoCommand,,do_command,DoCommand,doCommand,doCommand
@@ -229,6 +228,7 @@ servo,GetPosition,Yes,get_position,Position,position,getPosition
 ## HACK: No proto for these (and/or inherited in Go SDK), manually mapping:
 servo,IsMoving,No,is_moving,IsMoving,isMoving,isMoving
 servo,Stop,Yes,stop,Stop,stop,stop
+servo,GetGeometries,No,get_geometries,,,
 servo,Reconfigure,No,,Reconfigure,,
 # NOT implemented in other languages
 servo,DoCommand,,do_command,DoCommand,doCommand,doCommand
@@ -254,7 +254,6 @@ base_remote_control,Close,,,Close,,
 
 ## Data Manager
 data_manager,Sync,No,,Sync,,sync
-data_manager,UploadImageToDatasets,No,,UploadImageToDatasets,,,
 data_manager,UploadBinaryDataToDatasets,No,,UploadBinaryDataToDatasets,,uploadBinaryDataToDatasets
 ## HACK: No proto for these (and/or inherited in Go SDK), manually mapping:
 data_manager,Reconfigure,No,,Reconfigure,,
@@ -441,6 +440,7 @@ billing,GetOrgBillingInformation,,get_org_billing_information,GetOrgBillingInfor
 billing,GetInvoicesSummary,,get_invoices_summary,GetInvoicesSummary,,getInvoicesSummary
 billing,GetInvoicePDF,,get_invoice_pdf,GetInvoicePDF,,getInvoicePdf
 billing,CreateInvoiceAndChargeImmediately,,create_invoice_and_charge_immediately,,,
+billing,ChargeOrganization,,charge_organization,,,
 
 ## Data
 data,GetLatestTabularData,,get_latest_tabular_data,GetLatestTabularData,getLatestTabularData,getLatestTabularData
@@ -469,6 +469,13 @@ data,CreateDataPipeline,,create_data_pipeline,CreateDataPipeline,,createDataPipe
 data,DeleteDataPipeline,,delete_data_pipeline,DeleteDataPipeline,,deleteDataPipeline
 data,ListDataPipelineRuns,,list_data_pipeline_runs,ListDataPipelineRuns,,listDataPipelineRuns
 data,RenameDataPipeline,,,RenameDataPipeline,,
+data,AddTagsToBinaryDataByFilter,,add_tags_to_binary_data_by_filter,,,
+data,CreateBinaryDataSignedURL,,create_binary_data_signed_url,,,
+data,CreateIndex,,create_index,,,
+data,DeleteIndex,,delete_index,,,
+data,ListIndexes,,list_indexes,,,
+data,RemoveTagsFromBinaryDataByFilter,,remove_tags_from_binary_data_by_filter,,,
+data,UpdateBoundingBox,,update_bounding_box,,,
 
 ## Dataset
 dataset,CreateDataset,,create_dataset,CreateDataset,createDataset,createDataset
diff --git a/.htmltest-local.yml b/.htmltest-local.yml
index 6066d87071..54f0dc7fcc 100644
--- a/.htmltest-local.yml
+++ b/.htmltest-local.yml
@@ -9,6 +9,9 @@ IgnoreURLs:
   - "rtk2go.com"
 IgnoreDirs:
   - "lib"
+  - "operate"
+  - "manage"
+  - "data-ai"
 CacheExpires: "6h"
 # IgnoreDirs: - if we need to ever ignore files
 CheckExternal: false
\ No newline at end of file
diff --git a/assets/scss/_sidebar-tree.scss b/assets/scss/_sidebar-tree.scss
index 6cd2996d26..02bfe1e50b 100644
--- a/assets/scss/_sidebar-tree.scss
+++ b/assets/scss/_sidebar-tree.scss
@@ -187,7 +187,7 @@ li .indent {
     }
 
     .ul-2 > li:not(:last-child) {
-        padding-bottom: 8px;
+        padding-bottom: 2px;
     }
 }
 
diff --git a/assets/scss/_styles_project.scss b/assets/scss/_styles_project.scss
index 39bdc445c2..b06a7ad257 100644
--- a/assets/scss/_styles_project.scss
+++ b/assets/scss/_styles_project.scss
@@ -177,6 +177,20 @@ h7,
 
 .td-content > h3 {
   margin-bottom: 0.667rem;
+  margin-top: 1.5rem;
+}
+
+// The float:left on ol > li::before creates floats that escape the ol's
+// block formatting context. Since h3 has clear:both, it clears past those
+// floats, creating an oversized gap. flow-root contains the floats in
+// the ol's own BFC so they don't affect adjacent elements.
+// Zero the last li's margin-bottom because flow-root prevents it from
+// collapsing with the ol's margin, which would add unwanted extra space.
+.td-content > ol {
+  display: flow-root;
+}
+.td-content > ol > li:last-child {
+  margin-bottom: 0;
 }
 
 /* END Adjust Heading sizes*/
@@ -3191,57 +3205,9 @@ nav {
   background-color: rgb(232, 232, 234);
 }
 
-.second-nav {
-  min-width: 100%;
-  padding: 0.25rem 1rem;
-  border-top: 1px solid #e4e4e6;
-  border-bottom: 1px solid #e4e4e6;
-}
-
-.second-nav > ul {
-  padding: 0;
-  padding-left: 0.25rem;
-  margin: 0;
-}
-
-.second-nav > ul > li {
-  display: inline-block;
-  font-family:
-    "Public Sans",
-    -apple-system,
-    BlinkMacSystemFont,
-    "Segoe UI",
-    Roboto,
-    "Helvetica Neue",
-    Arial,
-    sans-serif,
-    "Apple Color Emoji",
-    "Segoe UI Emoji",
-    "Segoe UI Symbol";
-  font-size: 0.875rem;
-  line-height: 1.25rem;
-  margin: 5px 0px;
-  font-weight: 300;
-}
-
-.second-nav > ul > li > a {
-  color: #333;
-  padding: 5px 0.5rem;
-  margin-right: 0.5rem;
-}
-
-.second-nav > ul > li > a:hover,
-.second-nav > ul > li > a.active-path {
-  text-decoration: none;
-  background-color: rgba(0, 0, 0, 0.03);
-  border-radius: 4px;
-  color: #282829;
-  font-weight: 500;
-}
-
 @media (min-width: 768px) {
   .td-main main {
-    padding-top: 7.5rem;
+    padding-top: 5rem;
   }
 }
 
@@ -3249,11 +3215,6 @@ nav {
   min-height: 3.5rem;
 }
 
-@media (max-width: 767px) {
-  .second-nav {
-    display: none;
-  }
-}
 
 @media (min-width: 992px) {
   .d-lg-block {
@@ -3261,23 +3222,17 @@ nav {
   }
 }
 
-span.section-overview {
-  display: none;
-}
 
 ul > li.nav-fold > span > span.link-and-toggle {
   display: flex !important;
   flex-direction: row;
 }
 
-ul > li.nav-fold:last-child {
+ul.ul-0 > li.nav-fold:last-child {
   padding-bottom: 0.5rem;
 }
 
 @media (min-width: 768px) {
-  .ul-1 > li.nav-fold.hide-if-desktop {
-    display: none;
-  }
 
   #landing-page-sidebar {
     display: none;
@@ -3290,24 +3245,38 @@ ul > li.nav-fold:last-child {
 
   li.nav-fold.header-only > span > span {
     color: #000000;
-    margin-top: 1rem;
+    margin-top: 0.25rem;
   }
 
   li.nav-fold.header-only:first-child > span > a {
-    margin-top: 0.5rem;
+    margin-top: 0.25rem;
   }
 
   li.nav-fold.header-only * li {
     text-transform: unset;
   }
 
-  li > span > ul.ul-2 {
-    padding-left: 0;
+  li.nav-top-section > span > span.link-and-toggle > a,
+  li.nav-top-section > a {
+    text-transform: uppercase;
+    font-size: 0.75rem;
+    letter-spacing: 0.05em;
+    font-weight: 600;
+    color: #666;
+  }
+
+  li.nav-top-section > span > ul.ul-2 {
+    margin-left: 0.5rem;
   }
 
   ul.ul-2 > li > span > span {
     color: #282829;
-    font-weight: 600;
+    font-weight: 400;
+    font-size: 0.833rem;
+  }
+
+  ul.ul-2 > li > a {
+    font-size: 0.833rem;
   }
 
   li.header-only > span > ul.ul-3 {
@@ -3320,21 +3289,26 @@ ul > li.nav-fold:last-child {
     padding-left: 0.5rem;
   }
 
-  span.section-overview-title {
-    display: none;
-  }
 
-  .ul-1 > li.nav-fold > span > span.link-and-toggle {
-    display: none !important;
-  }
 
   .td-sidebar-nav__section .ul-1 ul.ul-2 {
-    padding-left: 0;
+    padding-left: 0.5rem;
+    border-left: 1px solid #e4e4e6;
+    margin-left: 0.5rem;
   }
 
   .td-sidebar-nav__section ul.ul-1 {
     margin-left: 0;
   }
+
+  li.nav-top-section {
+    margin-bottom: 0.5rem;
+    border-bottom: 1px solid #e4e4e6;
+  }
+
+  li.nav-top-section:last-child {
+    border-bottom: none;
+  }
 }
 
 .menu-toggle {
diff --git a/assets/tutorials/first-project/add-plus-button.png b/assets/tutorials/first-project/add-plus-button.png
new file mode 100644
index 0000000000..91f6cf66ed
Binary files /dev/null and b/assets/tutorials/first-project/add-plus-button.png differ
diff --git a/assets/tutorials/first-project/data-manager-search.png b/assets/tutorials/first-project/data-manager-search.png
new file mode 100644
index 0000000000..66a0b14c85
Binary files /dev/null and b/assets/tutorials/first-project/data-manager-search.png differ
diff --git a/assets/tutorials/first-project/gz-camera-search.png b/assets/tutorials/first-project/gz-camera-search.png
new file mode 100644
index 0000000000..b5e6389be6
Binary files /dev/null and b/assets/tutorials/first-project/gz-camera-search.png differ
diff --git a/assets/tutorials/first-project/try-vision-pipeline-fragment.png b/assets/tutorials/first-project/try-vision-pipeline-fragment.png
new file mode 100644
index 0000000000..2b2a776b9c
Binary files /dev/null and b/assets/tutorials/first-project/try-vision-pipeline-fragment.png differ
diff --git a/config.toml b/config.toml
index 2f47b84c1f..6c870a4af5 100644
--- a/config.toml
+++ b/config.toml
@@ -115,9 +115,9 @@ breadcrumb_disable = false
 footer_about_disable = false
 navbar_logo = true
 navbar_translucent_over_cover_disable = false
-sidebar_menu_compact = true  # When true, the section headings work like an accordian.
+sidebar_menu_compact = true  # When true, only the active path is expanded in the sidebar.
 sidebar_search_disable = true
-ul_show = 3  # Always expand every first level section of the sidenav -- due to tabs, our 'first level' is 3
+ul_show = 1  # Show only top-level sections; deeper levels collapse unless active
 
 [params.ui.feedback]
 enable = true
diff --git a/docs/_index.md b/docs/_index.md
index 5da8c88295..e3023a9295 100644
--- a/docs/_index.md
+++ b/docs/_index.md
@@ -3,17 +3,14 @@ title: "Viam Documentation"
 linkTitle: "Viam Documentation"
 description: "Viam integrates with hardware and software on any device. Use AI, machine learning, and more to make any machine smarter — for one machine to thousands."
 weight: 1
-no_list: true
 type: "docs"
-noToc: true
-hide_feedback: true
+layout: "empty"
+canonical: "/what-is-viam/"
 sitemap:
   priority: 1.0
 outputs:
   - html
   - REDIR
-imageAlt: "/general/understand.png"
-images: ["/general/understand.png"]
 noedit: true
 date: "2024-09-17"
 updated: "2024-10-11"
@@ -26,69 +23,3 @@ aliases:
   - "/get-started/"
   - "/platform/"
 ---
-
-<div class="max-page">
-  <div class="hero-container">
-    <div class="hero-text">
-      <h1>Viam Documentation</h1>
-      <p>
-        Viam integrates with hardware and software on <b>any device</b> in the physical world. Once you <a href="/operate/install/setup/">set up your machines</a>, you can use Viam SDKs to program your devices and connected hardware. Everything is managed in the cloud and you can use machine learning, data management, and much more for your projects.
-      </p>
-      <div class="cards max-page">
-        <div class="front-card-container">
-          <div class="hover-card primary">
-            <a href="/operate/hello-world/what-is-viam/" class="noanchor">
-            <div>
-              <p>Get started</p>
-            </div>
-          </a>
-          </div>
-          <div class="cta secondary">
-            <a href="/dev/" class="noanchor"><div>
-            <p>APIs & CLI →</p></div>
-            </a>
-          </div>
-        </div>
-      </div>
-    </div>
-    <img src="docs-hero-image.png" alt="App illustration" class="hero">
-  </div>
-</div>
-<br>
-
-<!-- Need to use upside down logic because using Subsequent-sibling combinator -->
-<div class="max-page gray-container">
-<h2 id="platform">The Viam platform
-  <div class="copied" id="copied-platform" aria-hidden="true">
-    <div class="copied-notification" id="copied-platform-text"></div>
-  </div>
-</h2>
-<p> Viam allows you to control and program any sensor, actuator or other hardware that is connected to a device. The Viam platform offers builtin capabilities to capture data from devices to the cloud, to build and deploy machine learning models, to alert on problems, and much more. With the connection to the cloud, you can configure, control, and manage your devices from anywhere.</p>
-<br>
-<div class="imgcontcenter">
-<div class="img-overlay-wrap aligncenter">
-  <img src="platform/platform-all.svg" alt="Platform diagram" id="fleet-platform-all" class="aligncenter overview" style="width:800px;height:auto" >
-  <img src="platform/platform-build-all.svg" alt="Platform diagram with connect elements highlighted" class="aligncenter overlay-platform" id="build-platform" style="width:800px;height:auto" loading="lazy" >
-  <img src="platform/platform-data-all.svg" alt="Platform diagram with apps element highlighted" class="aligncenter overlay-platform" id="data-platform" style="width:800px;height:auto" loading="lazy" >
-  <img src="platform/platform-fleet-all.svg" alt="Platform diagram with motion elements highlighted" class="aligncenter overlay-platform" id="fleet-platform" style="width:800px;height:auto" loading="lazy" >
-</div>
-</div>
-
-<br>
-
-<div class="three-cards hoveraction">
-
-<div class="col hover-card build-platform">
-<div><span><h3>Build & integrate</h3><p>To get started, install Viam on any device and integrate your hardware. Then you can control your device and any attached physical hardware securely from anywhere in the world.</p></span><p><a href="operate/">Learn more</a></p></div>
-</div>
-
-<div class="col hover-card data-platform">
-<div><span><h3>Work with Data and AI</h3><p>Viam's data and AI capabilities enable you to capture and sync or upload data, build a dataset, train and deploy ML models, and run inference with computer vision. Then, you can act or alert on inferences.</p></span><p><a href="data-ai/">Learn more</a></p></div>
-</div>
-
-<div class="col hover-card fleet-platform">
-<div><span><h3>Deploy, manage, and troubleshoot</h3><p>Viam’s fleet management tooling allows you to remotely deploy and manage software on any fleet of devices. You can monitor all connected devices and troubleshoot any issues - from anywhere.</p></span><p><a href="manage/">Learn more</a></p></div>
-</div>
-
-</div>
-</div>
diff --git a/docs/build-apps/_index.md b/docs/build-apps/_index.md
new file mode 100644
index 0000000000..6599d00c95
--- /dev/null
+++ b/docs/build-apps/_index.md
@@ -0,0 +1,20 @@
+---
+linkTitle: "Build apps"
+title: "Build apps"
+weight: 65
+layout: "docs"
+type: "docs"
+no_list: true
+manualLink: "/build-apps/overview/"
+description: "Build client apps that talk to your Viam machines and the Viam cloud."
+date: "2026-04-10"
+aliases:
+  # The following aliases are deferred. The pages listed still exist in
+  # the hidden operate/control/ and tutorials/control/ sections. Activate
+  # these aliases in the PR that deletes the old pages.
+  - /operate/control/web-app/
+  - /operate/control/mobile-app/
+  - /operate/control/viam-applications/
+  - /operate/control/kiosk-app/
+  - /operate/control/voice-app/
+---
diff --git a/docs/build-apps/app-tutorials/_index.md b/docs/build-apps/app-tutorials/_index.md
new file mode 100644
index 0000000000..e7686fe1b6
--- /dev/null
+++ b/docs/build-apps/app-tutorials/_index.md
@@ -0,0 +1,10 @@
+---
+linkTitle: "App tutorials"
+title: "App tutorials"
+weight: 100
+layout: "docs"
+type: "docs"
+no_list: true
+description: "Guided projects that walk through building a Viam app from start to finish."
+date: "2026-04-13"
+---
diff --git a/docs/build-apps/app-tutorials/tutorial-dashboard.md b/docs/build-apps/app-tutorials/tutorial-dashboard.md
new file mode 100644
index 0000000000..011c4aa140
--- /dev/null
+++ b/docs/build-apps/app-tutorials/tutorial-dashboard.md
@@ -0,0 +1,280 @@
+---
+linkTitle: "Tutorial: single-machine dashboard"
+title: "Build a single-machine dashboard"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Build a TypeScript web dashboard for a single Viam machine. Displays a camera feed, a live sensor reading, and a motor control button, with a connection status indicator."
+date: "2026-04-10"
+---
+
+In this tutorial, you will build a browser-based dashboard for a single Viam machine. The finished dashboard shows:
+
+- A live camera feed
+- The most recent reading from a sensor
+- A start/stop button for a motor
+- A connection status indicator
+
+You will learn the four patterns that almost every Viam client app uses: opening a connection, reading state from a component, changing state on a component, and reacting to connection events. The dashboard runs locally in your browser by the end; deployment is out of scope for this tutorial.
+
+The tutorial uses vanilla TypeScript and Vite without any frontend framework. The patterns work the same in React, Vue, or Svelte; a vanilla setup keeps the SDK calls visible without framework ceremony.
+
+## What you need
+
+- A configured Viam machine with a camera, a sensor, and a motor. Any models work. If you do not have the physical hardware, add fake components in the Viam app's **CONFIGURE** tab: `fake:camera`, `fake:sensor`, and `fake:motor`. The fake components respond to SDK calls the same way real ones do.
+- A completed [TypeScript setup](/build-apps/setup/typescript/). You should have a project directory with `@viamrobotics/sdk` installed, a `.env` file holding your machine credentials, and `index.html` plus `src/main.ts` files from the setup page.
+- Two browser windows side by side, or two tabs you can switch between. One window runs your dashboard; the other opens the Viam app's **CONTROL** tab for the same machine so you can see server-side state change when your code runs.
+
+Before continuing, confirm your setup by running `npx vite` and verifying that the page from the setup step shows `Connected. Found N resources.` in the browser. If it does not, go back to [TypeScript setup](/build-apps/setup/typescript/) and fix the connection before continuing.
+
+## Step 1: Replace the HTML
+
+Open `index.html` and replace its contents with a layout that has slots for each piece of the dashboard:
+
+```html
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <title>My Viam Dashboard</title>
+    <style>
+      body {
+        font-family: system-ui, sans-serif;
+        padding: 1rem;
+      }
+      #status {
+        font-weight: bold;
+      }
+      #status.connected {
+        color: green;
+      }
+      #status.disconnected {
+        color: red;
+      }
+      #camera {
+        width: 640px;
+        max-width: 100%;
+        background: #222;
+      }
+      .panel {
+        margin: 1rem 0;
+        padding: 1rem;
+        border: 1px solid #ccc;
+      }
+      button {
+        padding: 0.5rem 1rem;
+        font-size: 1rem;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>My Viam Dashboard</h1>
+    <p>Status: <span id="status">Connecting...</span></p>
+
+    <div class="panel">
+      <h2>Camera</h2>
+      <video id="camera" autoplay playsinline muted></video>
+    </div>
+
+    <div class="panel">
+      <h2>Sensor readings</h2>
+      <pre id="sensor">—</pre>
+    </div>
+
+    <div class="panel">
+      <h2>Motor</h2>
+      <button id="start">Start motor</button>
+      <button id="stop">Stop motor</button>
+    </div>
+
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
+```
+
+Save the file. If Vite is still running, it reloads automatically. You should see the page layout in your browser with empty values and non-functional buttons.
+
+## Step 2: Connect to your machine
+
+Open `src/main.ts` and replace its contents with a connection that stores the machine client as a module-level variable. You will add the dashboard logic on top of this connection in the steps that follow.
+
+```ts
+import * as VIAM from "@viamrobotics/sdk";
+
+const statusEl = document.getElementById("status") as HTMLSpanElement;
+const cameraEl = document.getElementById("camera") as HTMLVideoElement;
+const sensorEl = document.getElementById("sensor") as HTMLPreElement;
+const startBtn = document.getElementById("start") as HTMLButtonElement;
+const stopBtn = document.getElementById("stop") as HTMLButtonElement;
+
+let machine: VIAM.RobotClient;
+
+async function main() {
+  machine = await VIAM.createRobotClient({
+    host: import.meta.env.VITE_HOST,
+    credentials: {
+      type: "api-key",
+      authEntity: import.meta.env.VITE_API_KEY_ID,
+      payload: import.meta.env.VITE_API_KEY,
+    },
+    signalingAddress: "https://app.viam.com:443",
+  });
+
+  statusEl.textContent = "Connected";
+  statusEl.className = "connected";
+}
+
+main().catch((err) => {
+  statusEl.textContent = `Connection failed: ${err.message ?? err}`;
+  statusEl.className = "disconnected";
+});
+```
+
+Save the file. Refresh the browser. The status line should change from `Connecting...` to `Connected` in green. If it shows `Connection failed:`, check that your `.env` file has the right credentials and that your machine is online in the Viam app.
+
+## Step 3: Display the camera feed
+
+Add a camera stream to the dashboard. Use a `StreamClient` to attach the camera's WebRTC stream to the `<video>` element:
+
+```ts
+async function startCamera() {
+  const streamClient = new VIAM.StreamClient(machine);
+  const mediaStream = await streamClient.getStream("camera");
+  cameraEl.srcObject = mediaStream;
+}
+```
+
+Call `startCamera()` at the end of `main()`, after the connection is established:
+
+```ts
+async function main() {
+  machine = await VIAM.createRobotClient({
+    // ... (unchanged)
+  });
+
+  statusEl.textContent = "Connected";
+  statusEl.className = "connected";
+
+  await startCamera();
+}
+```
+
+The string `"camera"` is the component name you gave the camera in your machine config. If you named it something else (like `my_webcam` or `fake_camera`), change the argument to match.
+
+Save and refresh. The camera panel should now show a live feed. For a real camera, you will see the camera's image; for `fake:camera`, you will see a test pattern.
+
+## Step 4: Poll the sensor
+
+Sensors do not push data; you call `getReadings()` on a timer and display whatever you get back:
+
+```ts
+function startSensorPolling() {
+  const sensor = new VIAM.SensorClient(machine, "sensor");
+
+  setInterval(async () => {
+    try {
+      const readings = await sensor.getReadings();
+      sensorEl.textContent = JSON.stringify(readings, null, 2);
+    } catch (err) {
+      sensorEl.textContent = `Error: ${err}`;
+    }
+  }, 1000);
+}
+```
+
+Call `startSensorPolling()` after `startCamera()` in `main()`. Change the sensor name `"sensor"` if yours is configured differently.
+
+Save and refresh. The sensor panel now updates every second with the current readings from your sensor. For `fake:sensor`, this is usually a single key like `"reading": 0.5` that changes over time. For a real sensor, you see whatever values the component exposes.
+
+## Step 5: Control the motor
+
+Wire the Start and Stop buttons to `motor.setPower(1)` and `motor.stop()`:
+
+```ts
+function wireMotorButtons() {
+  const motor = new VIAM.MotorClient(machine, "motor");
+
+  startBtn.addEventListener("click", async () => {
+    try {
+      await motor.setPower(1);
+    } catch (err) {
+      console.error("setPower failed:", err);
+    }
+  });
+
+  stopBtn.addEventListener("click", async () => {
+    try {
+      await motor.stop();
+    } catch (err) {
+      console.error("stop failed:", err);
+    }
+  });
+}
+```
+
+Call `wireMotorButtons()` after `startSensorPolling()` in `main()`. Change the motor name `"motor"` if yours is configured differently.
+
+Save and refresh. Now open a second browser window to the Viam app's **CONTROL** tab for the same machine. Arrange the two windows side by side.
+
+Click **Start motor** in your dashboard. In the Viam app's Control tab, the motor's power slider moves to 1 (full power). Click **Stop motor**. The slider returns to 0. You just made a server-side state change from your own app code, and you can see it reflected in another client watching the same machine.
+
+For a `fake:motor`, the motor has no physical effect, but the state change is real. The same API call on a real motor would spin it at full power.
+
+## Step 6: Add connection state handling
+
+The dashboard is functional, but it does not react if the connection drops. Add a connection-state listener so the status indicator updates when the network changes:
+
+```ts
+function watchConnection() {
+  machine.on("connectionstatechange", (event) => {
+    const { eventType } = event as { eventType: VIAM.MachineConnectionEvent };
+    switch (eventType) {
+      case VIAM.MachineConnectionEvent.CONNECTED:
+        statusEl.textContent = "Connected";
+        statusEl.className = "connected";
+        break;
+      case VIAM.MachineConnectionEvent.DIALING:
+      case VIAM.MachineConnectionEvent.CONNECTING:
+        statusEl.textContent = "Connecting...";
+        statusEl.className = "";
+        break;
+      case VIAM.MachineConnectionEvent.RECONNECTING:
+        statusEl.textContent = "Reconnecting...";
+        statusEl.className = "";
+        break;
+      case VIAM.MachineConnectionEvent.RECONNECTION_FAILED:
+      case VIAM.MachineConnectionEvent.DISCONNECTING:
+      case VIAM.MachineConnectionEvent.DISCONNECTED:
+        statusEl.textContent = "Disconnected";
+        statusEl.className = "disconnected";
+        break;
+    }
+  });
+}
+```
+
+Call `watchConnection()` at the end of `main()`, after the motor buttons are wired.
+
+Save and refresh. The status indicator still says `Connected` on load. To test the state change, turn off your machine or disconnect your computer from the network briefly. The indicator switches to `Reconnecting...` while the SDK retries with backoff. Restore connectivity and the SDK reconnects automatically, switching the indicator back to `Connected` (green). If reconnection attempts are exhausted, the SDK emits `RECONNECTION_FAILED` and the indicator switches to `Disconnected`. The camera stream may or may not resume on its own depending on how long the disconnection lasted; see [Handle disconnection and reconnection](/build-apps/tasks/handle-connection-state/) for the rebuild-after-reconnect pattern.
+
+## What you built
+
+You now have a single-file TypeScript dashboard that:
+
+- Opens a connection to a Viam machine at startup
+- Displays a live camera feed
+- Polls and displays sensor readings every second
+- Controls a motor through start and stop buttons
+- Reflects connection state in a status indicator
+
+The full `src/main.ts` is around 80 lines of code. The four patterns you used (connect, read state, change state, react to events) cover almost every interactive Viam client app. When you build a larger app, you structure it around the same four operations, just with more components and a UI framework layered on top.
+
+## Next steps
+
+Extend the dashboard in one of these directions:
+
+- **Auto-stop the motor when the sensor crosses a threshold.** In the sensor polling loop, check the reading's value and call `motor.stop()` when it exceeds a limit. This is the smallest useful control loop: reads drive writes. Combining observation with action is the core pattern of all robotics software.
+- **Add a second camera.** Instantiate another `StreamClient.getStream("second_camera")` call and attach the result to a second `<video>` element. See [Stream video](/build-apps/tasks/stream-video/) for the multi-camera section and its bandwidth caveats.
+- **Rebuild state after reconnection.** The current dashboard does not re-attach the camera stream after a long disconnection. Follow [Handle disconnection and reconnection](/build-apps/tasks/handle-connection-state/) to add the rebuild pattern.
+- **Deploy the dashboard to Viam Applications.** Follow [Deploy a Viam application](/build-apps/hosting/deploy/) to host the dashboard at a public URL with authentication and cookie-injected credentials. The code you wrote here works the same when deployed, except you read credentials from cookies instead of `import.meta.env`.
+- **Build a multi-machine version.** See [the fleet tutorial](/build-apps/app-tutorials/tutorial-fleet/) for a dashboard that connects to the Viam cloud and aggregates data across several machines.
diff --git a/docs/build-apps/app-tutorials/tutorial-fleet.md b/docs/build-apps/app-tutorials/tutorial-fleet.md
new file mode 100644
index 0000000000..cb4a7ae26c
--- /dev/null
+++ b/docs/build-apps/app-tutorials/tutorial-fleet.md
@@ -0,0 +1,376 @@
+---
+linkTitle: "Tutorial: multi-machine fleet dashboard"
+title: "Build a multi-machine fleet dashboard"
+weight: 120
+layout: "docs"
+type: "docs"
+description: "Build a TypeScript web dashboard that connects to the Viam cloud, enumerates machines across an organization, and displays aggregated sensor data from a fleet."
+date: "2026-04-10"
+---
+
+In this tutorial, you will build a browser-based dashboard that reads captured sensor data from a fleet of Viam machines and displays aggregated values per machine. The finished dashboard:
+
+- Connects to the Viam cloud using a user API key
+- Lists the machines in your organization
+- Runs an MQL aggregation query over the last hour of sensor readings for each machine
+- Renders the results as a table
+
+You will learn the patterns for working with multi-machine Viam apps: connecting to the cloud rather than to one machine, enumerating resources across an organization, and aggregating captured data with MQL. The dashboard runs locally in your browser for most of the tutorial, with an optional final step to deploy it as a hosted Viam Application.
+
+The tutorial uses the air-quality use case as a concrete example: each machine has an air quality sensor that captures PM2.5 readings, and the dashboard shows the average for each machine over the last hour. The patterns work the same for any fleet and any captured data; substitute your own sensor type and field names as needed.
+
+## What you need
+
+- A Viam organization with at least two machines configured. Any machines work as long as each has a sensor you can capture data from. For the tutorial's air-quality framing, each machine has a sensor that returns a PM2.5 value under a field named `pm_2_5`, but you can use any field name as long as you update the MQL query in step 4 to match.
+- Data capture configured on the sensors, with enough data synced to the cloud that there are recent readings to aggregate. See [Capture and sync data](/data/capture-sync/capture-and-sync-data/) if you need to set this up.
+- An organization-scoped or location-scoped API key and its ID. Create one in [Admin and access](/organization/access/). A machine-scoped key will not work for this tutorial because you need access to multiple machines.
+- A completed [TypeScript setup](/build-apps/setup/typescript/) with Vite, the Viam TypeScript SDK, a `.env` file, and an `index.html` plus `src/main.ts` from the setup page.
+- Your organization ID. Find it in the Viam app by clicking your organization name and selecting **Settings**.
+
+Before continuing, update your `.env` file to use an organization-scoped API key instead of a machine-scoped one, and add your organization ID:
+
+```text
+VITE_API_KEY_ID=your-org-api-key-id
+VITE_API_KEY=your-org-api-key-secret
+VITE_ORG_ID=your-organization-id
+```
+
+You no longer need `VITE_HOST` for this tutorial; the cloud client does not connect to a specific machine address.
+
+## Step 1: Replace the HTML
+
+Open `index.html` and replace its contents:
+
+```html
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <title>Fleet Dashboard</title>
+    <style>
+      body {
+        font-family: system-ui, sans-serif;
+        padding: 1rem;
+      }
+      table {
+        border-collapse: collapse;
+        margin-top: 1rem;
+      }
+      th,
+      td {
+        border: 1px solid #ccc;
+        padding: 0.5rem 1rem;
+        text-align: left;
+      }
+      th {
+        background: #f0f0f0;
+      }
+      .good {
+        color: green;
+      }
+      .moderate {
+        color: orange;
+      }
+      .unhealthy {
+        color: red;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Fleet Dashboard</h1>
+    <p id="status">Connecting...</p>
+    <div id="dashboard"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
+```
+
+Save. If Vite is running, it reloads automatically.
+
+## Step 2: Connect to the Viam cloud
+
+Replace the contents of `src/main.ts` with a cloud connection that uses `createViamClient` instead of `createRobotClient`:
+
+```ts
+import * as VIAM from "@viamrobotics/sdk";
+
+const statusEl = document.getElementById("status") as HTMLParagraphElement;
+const dashboardEl = document.getElementById("dashboard") as HTMLDivElement;
+
+const ORG_ID = import.meta.env.VITE_ORG_ID;
+
+let client: VIAM.ViamClient;
+
+async function main() {
+  client = await VIAM.createViamClient({
+    credentials: {
+      type: "api-key",
+      authEntity: import.meta.env.VITE_API_KEY_ID,
+      payload: import.meta.env.VITE_API_KEY,
+    },
+  });
+
+  statusEl.textContent = "Connected to Viam cloud";
+}
+
+main().catch((err) => {
+  statusEl.textContent = `Connection failed: ${err.message ?? err}`;
+});
+```
+
+Save and refresh. The status line should change to `Connected to Viam cloud`. If you see `Connection failed:`, check that the API key you put in `.env` is organization-scoped (not machine-scoped) and that the organization ID matches your Viam account.
+
+Unlike `createRobotClient`, the cloud client does not open a WebRTC connection. It holds a transport that makes HTTP-based gRPC calls to the Viam cloud API. Each subsequent method call is a separate request.
+
+## Step 3: List the machines in the organization
+
+Add a function that lists all machines across all locations in your organization using `appClient.listMachineSummaries`:
+
+```ts
+interface Machine {
+  id: string;
+  name: string;
+  locationName: string;
+}
+
+async function listMachines(): Promise<Machine[]> {
+  const summaries = await client.appClient.listMachineSummaries(ORG_ID);
+  const machines: Machine[] = [];
+  for (const location of summaries) {
+    for (const m of location.machines) {
+      machines.push({
+        id: m.machineId,
+        name: m.machineName,
+        locationName: location.locationName,
+      });
+    }
+  }
+  return machines;
+}
+```
+
+Call `listMachines()` at the end of `main()` and log the result:
+
+```ts
+async function main() {
+  client = await VIAM.createViamClient({
+    // ... (unchanged)
+  });
+
+  statusEl.textContent = "Connected to Viam cloud";
+
+  const machines = await listMachines();
+  console.log(`Found ${machines.length} machines`);
+  for (const m of machines) {
+    console.log(`  ${m.name} (${m.id}) in ${m.locationName}`);
+  }
+}
+```
+
+Save and refresh. Open the browser's developer console. You should see a list of every machine in your organization with its name, ID, and location. If you have more than one location, machines from all of them are listed.
+
+## Step 4: Query aggregated data
+
+Now run an MQL aggregation query for each machine to get the average PM2.5 reading over the last hour. The TypeScript SDK accepts plain JavaScript objects for MQL queries and serializes them to BSON internally:
+
+```ts
+interface MachineReading {
+  machineId: string;
+  machineName: string;
+  locationName: string;
+  avgPm25: number | null;
+  sampleCount: number;
+}
+
+async function getReadingForMachine(m: Machine): Promise<MachineReading> {
+  const oneHourAgo = new Date(Date.now() - 3600 * 1000);
+
+  const pipeline = [
+    {
+      $match: {
+        robot_id: m.id,
+        component_name: "air_quality_sensor",
+        time_received: { $gte: oneHourAgo },
+      },
+    },
+    {
+      $group: {
+        _id: null,
+        avgPm25: { $avg: "$data.readings.pm_2_5" },
+        sampleCount: { $sum: 1 },
+      },
+    },
+  ];
+
+  const results = await client.dataClient.tabularDataByMQL(ORG_ID, pipeline);
+
+  if (results.length === 0) {
+    return {
+      machineId: m.id,
+      machineName: m.name,
+      locationName: m.locationName,
+      avgPm25: null,
+      sampleCount: 0,
+    };
+  }
+
+  const row = results[0] as { avgPm25: number; sampleCount: number };
+  return {
+    machineId: m.id,
+    machineName: m.name,
+    locationName: m.locationName,
+    avgPm25: row.avgPm25,
+    sampleCount: row.sampleCount,
+  };
+}
+```
+
+The `$match` stage filters the captured data to:
+
+- Only the current machine's readings (`robot_id` matches)
+- Only the air quality sensor component (change `"air_quality_sensor"` to your sensor's component name)
+- Only the last hour of data
+
+The `$group` stage computes the average of the `pm_2_5` field across all matching readings and counts how many samples contributed to the average. Change `$data.readings.pm_2_5` to the actual field path your sensor captures.
+
+Add a function that runs the query for every machine in parallel:
+
+```ts
+async function getFleetReadings(
+  machines: Machine[],
+): Promise<MachineReading[]> {
+  return Promise.all(machines.map(getReadingForMachine));
+}
+```
+
+Update `main()` to call it and log the results:
+
+```ts
+async function main() {
+  client = await VIAM.createViamClient({
+    // ... (unchanged)
+  });
+
+  statusEl.textContent = "Connected to Viam cloud";
+
+  const machines = await listMachines();
+  const readings = await getFleetReadings(machines);
+  console.log(readings);
+}
+```
+
+Save and refresh. The console now shows one entry per machine with the average PM2.5 value and sample count. If a machine has no data in the last hour, its `avgPm25` is `null` and its `sampleCount` is `0`.
+
+## Step 5: Render the dashboard
+
+Replace the console logging with a table rendered into the `#dashboard` element:
+
+```ts
+function categorize(pm25: number | null): string {
+  if (pm25 === null) return "";
+  if (pm25 < 12) return "good";
+  if (pm25 < 35) return "moderate";
+  return "unhealthy";
+}
+
+function renderDashboard(readings: MachineReading[]) {
+  const rows = readings
+    .map((r) => {
+      const category = categorize(r.avgPm25);
+      const value = r.avgPm25 === null ? "—" : `${r.avgPm25.toFixed(1)} µg/m³`;
+      return `
+        <tr>
+          <td>${r.machineName}</td>
+          <td>${r.locationName}</td>
+          <td class="${category}">${value}</td>
+          <td>${r.sampleCount}</td>
+        </tr>
+      `;
+    })
+    .join("");
+
+  dashboardEl.innerHTML = `
+    <table>
+      <thead>
+        <tr>
+          <th>Machine</th>
+          <th>Location</th>
+          <th>Avg PM2.5 (last hour)</th>
+          <th>Samples</th>
+        </tr>
+      </thead>
+      <tbody>${rows}</tbody>
+    </table>
+  `;
+}
+```
+
+Replace the `console.log(readings)` in `main()` with a call to `renderDashboard(readings)`:
+
+```ts
+const readings = await getFleetReadings(machines);
+renderDashboard(readings);
+statusEl.textContent = `Showing ${readings.length} machines`;
+```
+
+Save and refresh. You should now see a table with one row per machine, showing the machine name, location, average PM2.5 value over the last hour, and the number of samples that contributed to the average. Values below 12 µg/m³ display in green (good), 12–35 in orange (moderate), and above 35 in red (unhealthy).
+
+The category thresholds follow the United States EPA's air quality index breakpoints for PM2.5. Use whatever thresholds are appropriate for the data you are actually showing.
+
+## Step 6: Refresh on a timer
+
+A fleet dashboard is most useful when it updates on its own. Wrap the query-and-render in a function and run it on a 30-second interval:
+
+```ts
+async function refresh() {
+  try {
+    const machines = await listMachines();
+    const readings = await getFleetReadings(machines);
+    renderDashboard(readings);
+    statusEl.textContent = `Last updated ${new Date().toLocaleTimeString()}, ${readings.length} machines`;
+  } catch (err) {
+    statusEl.textContent = `Update failed: ${(err as Error).message}`;
+  }
+}
+```
+
+Replace the manual calls in `main()` with one initial call to `refresh()` followed by a `setInterval`:
+
+```ts
+async function main() {
+  client = await VIAM.createViamClient({
+    // ... (unchanged)
+  });
+
+  await refresh();
+  setInterval(refresh, 30_000);
+}
+```
+
+Save and refresh. The dashboard updates every 30 seconds. The status line shows the last update time and the number of machines displayed. If a refresh fails (network error, query timeout), the status line shows the error but the previous dashboard state stays on screen.
+
+## What you built
+
+You now have a multi-machine dashboard that:
+
+- Connects to the Viam cloud with an organization-scoped API key
+- Enumerates every machine in the organization across all locations
+- Runs an MQL aggregation query for each machine to compute the average PM2.5 reading over the last hour
+- Renders the results as a color-coded table
+- Refreshes every 30 seconds
+
+The full `src/main.ts` is around 130 lines. The patterns you used (cloud client, machine enumeration, MQL aggregation, periodic refresh) are the same patterns any multi-machine Viam app uses. Whether your fleet monitors air quality, tracks warehouse rovers, or aggregates manufacturing telemetry, the dashboard shape is the same.
+
+## Deploy as a Viam Application (optional)
+
+The dashboard runs locally right now. To host it at a Viam URL with built-in authentication, follow [Deploy a Viam application](/build-apps/hosting/deploy/). The key change when deploying: instead of reading credentials from `import.meta.env`, your deployed app reads them from a browser cookie that Viam injects after the user logs in.
+
+Replace the `createViamClient` call with code that reads the access token from the `userToken` cookie. The [hosting platform reference](/build-apps/hosting/hosting-reference/) documents the exact cookie format. When deployed as a multi-machine Viam Application, the rest of the dashboard code works unchanged; only the credential loading changes.
+
+## Next steps
+
+- **Filter by fragment.** If you configured the machines in your fleet with a shared fragment, pass `fragmentIds` to `listMachineSummaries` to scope the dashboard to only machines that include that fragment. Useful for multi-tenant apps where one organization has several customer fleets.
+- **Show historical trends.** Change the MQL pipeline to use `$bucket` or `$bucketAuto` to group readings into time buckets, then render a chart instead of a single aggregate value. [Query captured data](/build-apps/tasks/query-data/) covers more aggregation patterns.
+- **Aggregate across multiple sensor types.** Run a different MQL pipeline for each sensor you care about (PM2.5, PM10, VOC, temperature) and show all of them in the same row per machine.
+- **Add a machine detail view.** When the user clicks a row, open a second view that queries minute-by-minute data for that one machine. The common fleet dashboard pattern is an overview table plus a detail view per machine.
+- **Deploy to Viam Applications.** Follow [Deploy a Viam application](/build-apps/hosting/deploy/) for the packaging and upload workflow.
diff --git a/docs/build-apps/app-tutorials/tutorial-flutter-app.md b/docs/build-apps/app-tutorials/tutorial-flutter-app.md
new file mode 100644
index 0000000000..b1afe5e767
--- /dev/null
+++ b/docs/build-apps/app-tutorials/tutorial-flutter-app.md
@@ -0,0 +1,279 @@
+---
+linkTitle: "Tutorial: Flutter app with widgets"
+title: "Build a Flutter app with widgets"
+weight: 110
+layout: "docs"
+type: "docs"
+description: "Build a cross-platform Flutter app for a single Viam machine. Uses prebuilt widgets for the camera feed, sensor display, and motor control."
+date: "2026-04-10"
+---
+
+In this tutorial, you will build a Flutter app for a single Viam machine using the widgets that ship with the Flutter SDK. The finished app shows:
+
+- A live camera feed (`ViamCameraStreamView`)
+- A live sensor readings table (`ViamSensorWidget`)
+- A motor control widget (`ViamMotorWidget`)
+
+You will learn the Flutter SDK's widget-driven pattern, which is faster than writing stream and polling logic by hand. You will also see that the same Flutter app builds and runs on iOS, Android, and desktop from one codebase.
+
+This tutorial uses the Flutter-specific widget path rather than the raw SDK pattern. For a comparison using raw SDK calls, see [the TypeScript dashboard tutorial](/build-apps/app-tutorials/tutorial-dashboard/).
+
+## What you need
+
+- A configured Viam machine with a camera, a sensor, and a motor. Any models work. If you do not have the physical hardware, add fake components in the Viam app's **CONFIGURE** tab: `fake:camera`, `fake:sensor`, and `fake:motor`.
+- A completed [Flutter setup](/build-apps/setup/flutter/). You should have a Flutter project with `viam_sdk` and `flutter_dotenv` installed, a `.env` file holding your machine credentials, and the iOS/Android platform configuration applied.
+- A target platform to run the app on: an iOS simulator, an Android emulator, a physical device, or a desktop target (macOS, Linux, Windows).
+
+Before continuing, confirm your setup by running `flutter run` and verifying that the app from the setup step shows `Connected. Found N resources.` If it does not, go back to [Flutter setup](/build-apps/setup/flutter/) and fix the connection before continuing.
+
+## Step 1: Set up the app skeleton
+
+Replace the contents of `lib/main.dart` with a new app skeleton that defines a home screen with space for the three widgets and a connection indicator:
+
+```dart
+import 'package:flutter/material.dart';
+import 'package:flutter_dotenv/flutter_dotenv.dart';
+import 'package:viam_sdk/viam_sdk.dart';
+import 'package:viam_sdk/widgets.dart';
+
+void main() async {
+  WidgetsFlutterBinding.ensureInitialized();
+  await dotenv.load();
+  runApp(const MyApp());
+}
+
+class MyApp extends StatelessWidget {
+  const MyApp({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return MaterialApp(
+      title: 'My Viam Dashboard',
+      theme: ThemeData(useMaterial3: true),
+      home: const DashboardScreen(),
+    );
+  }
+}
+
+class DashboardScreen extends StatefulWidget {
+  const DashboardScreen({super.key});
+
+  @override
+  State<DashboardScreen> createState() => _DashboardScreenState();
+}
+
+class _DashboardScreenState extends State<DashboardScreen> {
+  RobotClient? _robot;
+  String _status = 'Connecting...';
+
+  @override
+  void initState() {
+    super.initState();
+    _connect();
+  }
+
+  @override
+  void dispose() {
+    _robot?.close();
+    super.dispose();
+  }
+
+  Future<void> _connect() async {
+    try {
+      final robot = await RobotClient.atAddress(
+        dotenv.env['MACHINE_ADDRESS']!,
+        RobotClientOptions.withApiKey(
+          dotenv.env['API_KEY_ID']!,
+          dotenv.env['API_KEY']!,
+        ),
+      );
+      setState(() {
+        _robot = robot;
+        _status = 'Connected';
+      });
+    } catch (e) {
+      setState(() {
+        _status = 'Connection failed: $e';
+      });
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(title: const Text('My Viam Dashboard')),
+      body: SingleChildScrollView(
+        padding: const EdgeInsets.all(16),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Text('Status: $_status'),
+            const SizedBox(height: 16),
+            if (_robot != null) ..._buildDashboard(_robot!),
+          ],
+        ),
+      ),
+    );
+  }
+
+  List<Widget> _buildDashboard(RobotClient robot) {
+    return const [
+      Text('Dashboard will go here'),
+    ];
+  }
+}
+```
+
+Save the file and run `flutter run`. Pick your target platform when prompted. The app builds, launches, and shows the app bar with "My Viam Dashboard" and the status text switching from `Connecting...` to `Connected`. The "Dashboard will go here" placeholder appears below the status once the connection is established.
+
+You will replace the placeholder in the next three steps.
+
+## Step 2: Add the camera widget
+
+Update `_buildDashboard` to include `ViamCameraStreamView`:
+
+```dart
+List<Widget> _buildDashboard(RobotClient robot) {
+  final camera = Camera.fromRobot(robot, 'camera');
+  final streamClient = robot.getStream('camera');
+
+  return [
+    const Text('Camera', style: TextStyle(fontSize: 20)),
+    const SizedBox(height: 8),
+    SizedBox(
+      height: 240,
+      child: ViamCameraStreamView(
+        camera: camera,
+        streamClient: streamClient,
+      ),
+    ),
+  ];
+}
+```
+
+The string `'camera'` is the component name you gave the camera in your machine config. Change it to match your config if you used a different name.
+
+Save the file. Flutter's hot reload updates the app without rebuilding. The camera panel now shows a live feed. For a real camera, you see the camera's image; for `fake:camera`, you see a test pattern.
+
+`ViamCameraStreamView` is a stateful widget that manages the `RTCVideoRenderer` lifecycle, initializes the WebRTC stream, tears it down on dispose, and displays an error state if the stream fails. You did not write any of that logic; the widget handles it all.
+
+## Step 3: Add the sensor widget
+
+Extend `_buildDashboard` to append a `ViamSensorWidget`:
+
+```dart
+List<Widget> _buildDashboard(RobotClient robot) {
+  final camera = Camera.fromRobot(robot, 'camera');
+  final streamClient = robot.getStream('camera');
+  final sensor = Sensor.fromRobot(robot, 'sensor');
+
+  return [
+    const Text('Camera', style: TextStyle(fontSize: 20)),
+    const SizedBox(height: 8),
+    SizedBox(
+      height: 240,
+      child: ViamCameraStreamView(
+        camera: camera,
+        streamClient: streamClient,
+      ),
+    ),
+    const SizedBox(height: 24),
+    const Text('Sensor readings', style: TextStyle(fontSize: 20)),
+    const SizedBox(height: 8),
+    ViamSensorWidget(sensor: sensor),
+  ];
+}
+```
+
+Save. The app now shows a data table under the camera, populated with the sensor's current readings. The widget refreshes the table on its own; you do not need a timer or a polling loop.
+
+Under the hood, `ViamSensorWidget` is a `ViamRefreshableDataTable` that calls `sensor.readings()` on a schedule and re-renders when new data arrives. The Flutter SDK's widget layer handles the polling so you do not have to.
+
+## Step 4: Add the motor widget
+
+Append a `ViamMotorWidget` to the dashboard:
+
+```dart
+List<Widget> _buildDashboard(RobotClient robot) {
+  final camera = Camera.fromRobot(robot, 'camera');
+  final streamClient = robot.getStream('camera');
+  final sensor = Sensor.fromRobot(robot, 'sensor');
+  final motor = Motor.fromRobot(robot, 'motor');
+
+  return [
+    const Text('Camera', style: TextStyle(fontSize: 20)),
+    const SizedBox(height: 8),
+    SizedBox(
+      height: 240,
+      child: ViamCameraStreamView(
+        camera: camera,
+        streamClient: streamClient,
+      ),
+    ),
+    const SizedBox(height: 24),
+    const Text('Sensor readings', style: TextStyle(fontSize: 20)),
+    const SizedBox(height: 8),
+    ViamSensorWidget(sensor: sensor),
+    const SizedBox(height: 24),
+    const Text('Motor', style: TextStyle(fontSize: 20)),
+    const SizedBox(height: 8),
+    ViamMotorWidget(motor: motor),
+  ];
+}
+```
+
+Save. The motor section now shows a power slider with auto-stop behavior. Drag the slider to set a power level; `ViamMotorWidget` calls `motor.setPower()` on the underlying component as you adjust it. The widget's auto-stop mode means releasing the slider calls `motor.stop()` so the motor does not continue running at the last commanded power when you let go.
+
+Open the Viam app's **CONTROL** tab for the same machine in another window. Arrange the two side by side. When you drag the slider in your Flutter app, the motor's power slider in the Viam app's Control tab moves in sync. You just made a server-side state change from your Flutter app, visible to another client watching the same machine.
+
+For `fake:motor`, the motor has no physical effect, but the state change is real. The same calls on a real motor would spin it.
+
+## Step 5: Run on another platform
+
+Stop the app and run it on a second target to see the cross-platform story. If you first ran it on an iOS simulator, try Android, or try a desktop target:
+
+```sh {class="command-line" data-prompt="$"}
+flutter run -d macos
+```
+
+Or:
+
+```sh {class="command-line" data-prompt="$"}
+flutter run -d chrome
+```
+
+Or:
+
+```sh {class="command-line" data-prompt="$"}
+flutter run -d windows
+```
+
+The same code builds and runs on each platform without modification. The widgets render with the platform's Material look, the camera stream decodes and displays on each target, the sensor data table updates, and the motor slider controls the same machine. This is the argument for Flutter over a browser-only framework when you need one app that runs across iOS, Android, and one or more desktop operating systems.
+
+Some platform-specific notes:
+
+- **iOS and macOS** require the `Info.plist` permissions you added in [Flutter setup](/build-apps/setup/flutter/) for WebRTC to work.
+- **Android** requires minimum SDK 23 and the setup page's Kotlin version.
+- **Web** support depends on whether `flutter_webrtc` has stable web behavior for your specific build. If the web target fails, fall back to native or desktop targets for now.
+
+## What you built
+
+You now have a Flutter app that:
+
+- Connects to a Viam machine at startup and closes the connection on dispose
+- Shows a live camera feed through `ViamCameraStreamView`
+- Shows live sensor readings through `ViamSensorWidget`
+- Controls a motor through `ViamMotorWidget` with auto-stop
+- Builds and runs on every Flutter target platform from one codebase
+
+The full `lib/main.dart` is around 100 lines of code, most of which is scaffolding for the app shell rather than Viam-specific logic. The three prebuilt widgets did the heavy lifting: you wrote no stream renderer, no polling timer, no motor button wiring. That is the Flutter widget advantage.
+
+## Next steps
+
+Extend the app in one of these directions:
+
+- **Add a joystick for base control.** If your machine has a base configured, add a `ViamJoystickWidget` to drive it. The joystick widget converts user input into base movement commands.
+- **Use the multi-camera widget.** The Flutter SDK ships `ViamMultiCameraStreamView` for showing several camera feeds at once. See the [Flutter SDK reference](https://flutter.viam.dev/) for its parameters.
+- **Build a list of resources with per-resource screens.** The `viam_robot_example_app` in the Flutter SDK repo shows a pattern for enumerating the machine's resources and showing a custom screen for each. Use it as a reference for larger apps.
+- **Read from the Viam cloud.** Switch from `RobotClient.atAddress` to `Viam.withApiKey` so you can use the `appClient` and `dataClient` to enumerate machines and query captured data. See [Connect to the Viam cloud](/build-apps/tasks/connect-to-cloud/).
+- **Build a multi-machine version.** See [the fleet tutorial](/build-apps/app-tutorials/tutorial-fleet/) for a dashboard that aggregates data across several machines.
diff --git a/docs/build-apps/app-tutorials/tutorial-monitoring-service.md b/docs/build-apps/app-tutorials/tutorial-monitoring-service.md
new file mode 100644
index 0000000000..461350899e
--- /dev/null
+++ b/docs/build-apps/app-tutorials/tutorial-monitoring-service.md
@@ -0,0 +1,317 @@
+---
+linkTitle: "Tutorial: Python monitoring service"
+title: "Build a Python monitoring service"
+weight: 115
+layout: "docs"
+type: "docs"
+description: "Build a Python service that connects to a Viam machine, monitors a sensor, controls a motor based on sensor readings, and shuts down cleanly."
+date: "2026-04-13"
+---
+
+In this tutorial, you will build a Python service that runs without a user interface. The finished service:
+
+- Connects to a Viam machine at startup
+- Starts a motor
+- Polls a sensor every two seconds and logs the readings
+- Stops the motor when a sensor reading exceeds a threshold
+- Shuts down cleanly when you press Ctrl+C
+
+You will learn the pattern that most headless Viam apps follow: connect, act, monitor, react, clean up. The same structure works for any long-running Python process that talks to a machine: a control loop, a data logger, a fleet monitor, or an integration service.
+
+## What you need
+
+- A configured Viam machine with a sensor and a motor. Any models work. If you do not have physical hardware, add `fake:sensor` and `fake:motor` in the Viam app's **CONFIGURE** tab.
+- A completed [Python setup](/build-apps/setup/python/). You should have a project directory with `viam-sdk` installed, a `.env` file holding your machine credentials, and a working `main.py` from the setup page.
+- A second window open to the Viam app's **CONTROL** tab for the same machine, so you can see motor state changes as they happen.
+
+Before continuing, confirm your setup by running `python main.py` and verifying that it shows `Connected. Found N resources.` If it does not, go back to [Python setup](/build-apps/setup/python/) and fix the connection before continuing.
+
+## Step 1: Connect and list resources
+
+Replace the contents of `main.py` with a connection that prints the machine's resources:
+
+```python
+import asyncio
+import os
+
+from dotenv import load_dotenv
+from viam.robot.client import RobotClient
+
+load_dotenv()
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key=os.environ["API_KEY"],
+        api_key_id=os.environ["API_KEY_ID"],
+    )
+    machine = await RobotClient.at_address(os.environ["MACHINE_ADDRESS"], opts)
+
+    print(f"Connected. Resources: {[r.name for r in machine.resource_names]}")
+
+    await machine.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```sh {class="command-line" data-prompt="$"}
+python main.py
+```
+
+You should see a list of resource names that includes your sensor and motor. If the names you see do not match the names you configured, update the constants in the next step to match.
+
+## Step 2: Get the sensor and motor, start the motor
+
+Add imports for `Sensor` and `Motor`, get them by name, and start the motor:
+
+```python
+import asyncio
+import os
+
+from dotenv import load_dotenv
+from viam.robot.client import RobotClient
+from viam.components.sensor import Sensor
+from viam.components.motor import Motor
+
+load_dotenv()
+
+SENSOR_NAME = "my_sensor"
+MOTOR_NAME = "my_motor"
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key=os.environ["API_KEY"],
+        api_key_id=os.environ["API_KEY_ID"],
+    )
+    machine = await RobotClient.at_address(os.environ["MACHINE_ADDRESS"], opts)
+
+    sensor = Sensor.from_robot(robot=machine, name=SENSOR_NAME)
+    motor = Motor.from_robot(robot=machine, name=MOTOR_NAME)
+
+    await motor.set_power(power=0.5)
+    print(f"Motor '{MOTOR_NAME}' started at 50% power.")
+
+    await machine.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Change `SENSOR_NAME` and `MOTOR_NAME` to match the names you gave these components in your machine configuration. If you used `fake:sensor` and `fake:motor`, the default names are usually `sensor` and `motor` unless you changed them.
+
+Run it. The terminal prints `Motor 'my_motor' started at 50% power.` Check the Viam app's **CONTROL** tab: the motor's power slider should show 50%. The script connects, starts the motor, and immediately closes the connection (which stops the motor through session cleanup). In the next step, you will keep the connection open.
+
+## Step 3: Poll the sensor in a loop
+
+Replace the `await machine.close()` call with a polling loop that reads the sensor every two seconds:
+
+```python
+POLL_INTERVAL = 2  # seconds
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key=os.environ["API_KEY"],
+        api_key_id=os.environ["API_KEY_ID"],
+    )
+    machine = await RobotClient.at_address(os.environ["MACHINE_ADDRESS"], opts)
+
+    sensor = Sensor.from_robot(robot=machine, name=SENSOR_NAME)
+    motor = Motor.from_robot(robot=machine, name=MOTOR_NAME)
+
+    await motor.set_power(power=0.5)
+    print(f"Motor '{MOTOR_NAME}' started at 50% power.")
+
+    print(f"Monitoring sensor '{SENSOR_NAME}' every {POLL_INTERVAL}s. Press Ctrl+C to stop.")
+
+    while True:
+        readings = await sensor.get_readings()
+        print(f"  {readings}")
+        await asyncio.sleep(POLL_INTERVAL)
+```
+
+Run it. The terminal prints sensor readings every two seconds. For `fake:sensor`, the output is `{'a': 1, 'b': 2, 'c': 3}` on every line. For a real sensor, the values change. The motor stays running in the background because the connection is still open.
+
+Press Ctrl+C to stop the script. The motor stops because the session ends, but the shutdown is abrupt: Python prints a traceback. The next step fixes this.
+
+## Step 4: Add graceful shutdown
+
+Wrap the polling loop in a try/finally block so the motor stops and the connection closes cleanly when you press Ctrl+C:
+
+```python
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key=os.environ["API_KEY"],
+        api_key_id=os.environ["API_KEY_ID"],
+    )
+    machine = await RobotClient.at_address(os.environ["MACHINE_ADDRESS"], opts)
+
+    sensor = Sensor.from_robot(robot=machine, name=SENSOR_NAME)
+    motor = Motor.from_robot(robot=machine, name=MOTOR_NAME)
+
+    await motor.set_power(power=0.5)
+    print(f"Motor '{MOTOR_NAME}' started at 50% power.")
+
+    print(f"Monitoring sensor '{SENSOR_NAME}' every {POLL_INTERVAL}s. Press Ctrl+C to stop.")
+
+    try:
+        while True:
+            readings = await sensor.get_readings()
+            print(f"  {readings}")
+            await asyncio.sleep(POLL_INTERVAL)
+    except (KeyboardInterrupt, asyncio.CancelledError):
+        pass
+    finally:
+        print("Shutting down...")
+        await motor.stop()
+        await machine.close()
+        print("Motor stopped. Connection closed.")
+```
+
+Run it. The sensor readings print as before. Press Ctrl+C. Instead of a traceback, you see:
+
+```text
+Shutting down...
+Motor stopped. Connection closed.
+```
+
+Check the **CONTROL** tab: the motor's power slider returns to zero. The shutdown is clean: the motor is explicitly stopped, not just abandoned when the session ends.
+
+## Step 5: Add a threshold check
+
+Add logic that stops the motor when a sensor reading exceeds a threshold. This is the "reads drive writes" pattern: the service observes a condition and takes an action.
+
+Add two constants at the top of the file:
+
+```python
+READING_KEY = "a"       # The sensor reading key to monitor
+THRESHOLD = 0           # Stop the motor when this value is exceeded
+```
+
+Update the polling loop to check the reading:
+
+```python
+    try:
+        while True:
+            readings = await sensor.get_readings()
+            value = readings.get(READING_KEY)
+            print(f"  {READING_KEY}={value}")
+
+            if value is not None and value > THRESHOLD:
+                print(f"  THRESHOLD EXCEEDED ({value} > {THRESHOLD})")
+                break
+
+            await asyncio.sleep(POLL_INTERVAL)
+    except (KeyboardInterrupt, asyncio.CancelledError):
+        pass
+    finally:
+        print("Shutting down...")
+        await motor.stop()
+        await machine.close()
+        print("Motor stopped. Connection closed.")
+```
+
+`READING_KEY` is the key from the sensor's readings map to watch. `THRESHOLD` is the value that triggers the motor stop. For `fake:sensor`, set `READING_KEY` to `"a"` and `THRESHOLD` to `0`. Since `fake:sensor` returns `a=1`, the condition `1 > 0` is true on the first reading and the motor stops immediately. For a real sensor, set these to values that match your hardware.
+
+Run it. The output shows one reading, the threshold message, and the shutdown:
+
+```text
+Motor 'my_motor' started at 50% power.
+Monitoring sensor 'my_sensor' every 2s. Press Ctrl+C to stop.
+  a=1
+  THRESHOLD EXCEEDED (1 > 0)
+Shutting down...
+Motor stopped. Connection closed.
+```
+
+To see the monitoring loop run for longer, raise `THRESHOLD` above the sensor's maximum value. The service polls indefinitely until you press Ctrl+C or the threshold triggers.
+
+## The complete script
+
+Here is the full `main.py`:
+
+```python
+import asyncio
+import os
+
+from dotenv import load_dotenv
+from viam.robot.client import RobotClient
+from viam.components.sensor import Sensor
+from viam.components.motor import Motor
+
+load_dotenv()
+
+SENSOR_NAME = "my_sensor"
+MOTOR_NAME = "my_motor"
+READING_KEY = "a"
+THRESHOLD = 0
+POLL_INTERVAL = 2
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key=os.environ["API_KEY"],
+        api_key_id=os.environ["API_KEY_ID"],
+    )
+    machine = await RobotClient.at_address(os.environ["MACHINE_ADDRESS"], opts)
+
+    sensor = Sensor.from_robot(robot=machine, name=SENSOR_NAME)
+    motor = Motor.from_robot(robot=machine, name=MOTOR_NAME)
+
+    await motor.set_power(power=0.5)
+    print(f"Motor '{MOTOR_NAME}' started at 50% power.")
+
+    print(f"Monitoring sensor '{SENSOR_NAME}' every {POLL_INTERVAL}s. Press Ctrl+C to stop.")
+
+    try:
+        while True:
+            readings = await sensor.get_readings()
+            value = readings.get(READING_KEY)
+            print(f"  {READING_KEY}={value}")
+
+            if value is not None and value > THRESHOLD:
+                print(f"  THRESHOLD EXCEEDED ({value} > {THRESHOLD})")
+                break
+
+            await asyncio.sleep(POLL_INTERVAL)
+    except (KeyboardInterrupt, asyncio.CancelledError):
+        pass
+    finally:
+        print("Shutting down...")
+        await motor.stop()
+        await machine.close()
+        print("Motor stopped. Connection closed.")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+The full script is 50 lines. Five constants at the top configure the behavior. One async function handles the full lifecycle: connect, start, monitor, react, clean up.
+
+## What you built
+
+You now have a Python service that:
+
+- Connects to a Viam machine using an API key from environment variables
+- Starts a motor and monitors a sensor in a polling loop
+- Stops the motor when a sensor reading exceeds a configurable threshold
+- Shuts down cleanly on Ctrl+C, explicitly stopping the motor and closing the connection
+
+This is the pattern for any headless Viam app: connect, do something, monitor something, react to conditions, clean up on exit. The specifics change (different sensors, different actions, different conditions), but the structure stays the same.
+
+## Next steps
+
+Extend the service in one of these directions:
+
+- **Monitor multiple sensors.** Get additional sensors with `Sensor.from_robot` and read from all of them in the same loop. Log each one separately.
+- **Add hysteresis.** Instead of stopping the motor permanently when the threshold is exceeded, restart it when the reading drops back below a lower threshold. This prevents rapid start-stop cycling around the boundary.
+- **Log to a file or external system.** Replace `print()` with Python's `logging` module, or send readings to a database, Prometheus, or a notification service.
+- **Run as a system service.** Deploy the script as a systemd unit so it starts on boot and restarts on failure. The graceful shutdown pattern you built in Step 4 handles `SIGTERM` from systemd the same way it handles Ctrl+C.
+- **Connect to the Viam cloud instead of one machine.** Switch from `RobotClient.at_address` to `ViamClient.create_from_dial_options` to monitor sensors across a fleet. See [Connect to the Viam cloud](/build-apps/tasks/connect-to-cloud/).
diff --git a/docs/build-apps/concepts/_index.md b/docs/build-apps/concepts/_index.md
new file mode 100644
index 0000000000..7e85dae282
--- /dev/null
+++ b/docs/build-apps/concepts/_index.md
@@ -0,0 +1,11 @@
+---
+linkTitle: "Concepts"
+title: "Concepts"
+weight: 10
+layout: "docs"
+type: "docs"
+no_list: true
+manualLink: "/build-apps/concepts/how-apps-connect/"
+description: "Mental models for building Viam client apps: how connections work and how authentication works."
+date: "2026-04-10"
+---
diff --git a/docs/build-apps/concepts/authentication.md b/docs/build-apps/concepts/authentication.md
new file mode 100644
index 0000000000..291cea1150
--- /dev/null
+++ b/docs/build-apps/concepts/authentication.md
@@ -0,0 +1,76 @@
+---
+linkTitle: "Authentication"
+title: "Authenticating Viam client apps"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "The credential types a Viam client app uses and when to use each. Covers API keys, access tokens, and hosted-app credential injection."
+date: "2026-04-10"
+---
+
+A Viam client application proves its identity to the machine or to the Viam cloud through a credential. The SDK supports two credential types: API keys for service-identity access and access tokens for user-identity access. Hosted Viam Applications inject credentials into the browser automatically through cookies.
+
+This page uses TypeScript SDK names for the specific APIs. The Flutter SDK supports the same credential types through `RobotClientOptions.withApiKey` and `Viam.withAccessToken`; see [Flutter setup](/build-apps/setup/flutter/).
+
+## API keys
+
+An API key is the default credential for a client app. You create the key in the Viam app, scope it to what it should be allowed to access, and pass it to the SDK at connection time.
+
+An API key has two pieces: an **ID** (the `authEntity` field in the SDK) and a **secret** (the `payload` field). Both are required for every connection. The secret is shown only at creation time; if you lose it, rotate the key to generate a new secret.
+
+```typescript
+const machine = await VIAM.createRobotClient({
+  host: "my-robot-main.xxxx.viam.cloud",
+  credentials: {
+    type: "api-key",
+    authEntity: process.env.API_KEY_ID,
+    payload: process.env.API_KEY,
+  },
+  signalingAddress: "https://app.viam.com:443",
+});
+```
+
+API keys have three possible scopes:
+
+| Scope        | Access                           | When to use                                                                                               |
+| ------------ | -------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| Machine      | One machine                      | Your app talks to a specific machine you control, and you want the smallest blast radius if the key leaks |
+| Location     | All machines in a location       | Your app needs to talk to several machines that share a location, such as a warehouse deployment          |
+| Organization | All machines in the organization | Your app needs broad fleet access, such as a fleet-management dashboard or a data-querying service        |
+
+Create and manage API keys in [Admin and access](/organization/access/).
+
+## Access tokens
+
+An access token represents a user, not a service. Where an API key is one identity that never changes, an access token is the identity of whoever is currently logged in.
+
+Hosted Viam Applications create access tokens through the Viam OAuth flow when a user logs in. Your app code reads the token from a browser cookie and passes it to `createViamClient` to make requests scoped to what that user is allowed to see. There is no API for creating access tokens yourself; they only come from the OAuth flow.
+
+Access tokens are useful when the same app shows different data to different users, and they are the only credential type you use in a hosted Viam Application.
+
+## Hosted Viam Applications: credential injection
+
+When you deploy a web app to Viam Applications, the Viam platform handles authentication. The behavior depends on the application type you declared in `meta.json`.
+
+**Single-machine application.** Users log into your app through Viam's OAuth flow. Viam selects a machine (either the one specified in the URL or one picked through the fragment-filtered machine picker) and writes machine-specific credentials into a browser cookie: the API key, the API key ID, and the machine hostname. Your app code reads the cookie and passes the credentials to `createRobotClient`.
+
+**Multi-machine application.** Users log into your app the same way. Viam writes a user access token into a browser cookie. Your app code reads the cookie and passes the token to `createViamClient`, then uses the resulting `AppClient` to enumerate the machines the user has access to and connect to each one.
+
+In both cases, the Viam Applications platform manages the cookie lifecycle: login, token refresh, and logout all happen without your app code touching the credential directly.
+
+See [Deploy a Viam application](/build-apps/hosting/deploy/) for the deployment workflow and [the hosting platform reference](/build-apps/hosting/hosting-reference/) for the cookie format.
+
+## Where to put credentials in self-hosted apps
+
+For apps you host yourself, not on Viam Applications:
+
+- Store API keys in environment variables, not in source code.
+- In development, use a `.env` file and add `.env` to `.gitignore`.
+- In production, use your platform's secret management: Vercel environment variables, AWS Secrets Manager, Kubernetes secrets, or similar.
+- Never commit an API key to a public repository. If you do, rotate the key immediately.
+
+For apps on Viam Applications, you do not store credentials; Viam injects them through cookies at runtime.
+
+## Robot secrets
+
+Robot secrets are a legacy credential type from earlier versions of Viam. They still work for backward compatibility. Use API keys instead in new apps.
diff --git a/docs/build-apps/concepts/how-apps-connect.md b/docs/build-apps/concepts/how-apps-connect.md
new file mode 100644
index 0000000000..c829496999
--- /dev/null
+++ b/docs/build-apps/concepts/how-apps-connect.md
@@ -0,0 +1,81 @@
+---
+linkTitle: "Connection model"
+title: "How Viam client apps connect"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "The transport paths the SDK uses, the session safety mechanism, and what the SDK reconnects automatically."
+date: "2026-04-10"
+---
+
+A Viam client application needs to reach a machine that may be on a different network, behind a NAT, or both. This page describes the transport paths the SDK uses, the session safety mechanism, and how the SDK reconnects when the network drops.
+
+This page uses TypeScript SDK names for specific APIs (`createRobotClient`, `DialWebRTCConf`, `disableSessions`, and so on). The Flutter SDK provides equivalent APIs with different names; see [Flutter setup](/build-apps/setup/flutter/).
+
+## Two transports
+
+The SDK reaches a machine through one of two transports, selected by which configuration type you pass to `createRobotClient`:
+
+**WebRTC** (`DialWebRTCConf`). The default path for machines deployed on Viam Cloud. The SDK contacts a signaling service, which brokers a peer-to-peer WebRTC connection between your app and the machine. Once the connection is established, data flows directly between the two endpoints. The signaling service is only needed for the initial handshake.
+
+**Direct gRPC** (`DialDirectConf`). The SDK opens a gRPC connection directly to a host and port. Use this when you have direct network access to the machine and do not need NAT traversal, typically for local development against a machine on the same network or for an app running in the same cluster as the machine.
+
+Both transports use gRPC as the application protocol. The difference is whether the gRPC bytes travel through a WebRTC data channel (NAT-friendly, goes through signaling) or through a direct TCP/HTTP2 connection (simpler, requires direct network reachability).
+
+## WebRTC connection parameters
+
+When you use the WebRTC transport, the SDK needs two pieces of configuration in addition to the machine host:
+
+**Signaling address.** Required. The URL of the signaling service that brokers the WebRTC handshake. For machines deployed on Viam Cloud, the value is `https://app.viam.com:443`. The Viam app's CONNECT tab writes this literal string into the code sample it generates, so you copy it along with the rest of the connection code. For self-hosted or air-gapped setups, you point to a different signaling service.
+
+**ICE servers.** Optional. The SDK needs ICE servers (STUN and optionally TURN) to traverse NATs. If you do not pass `iceServers`, the SDK defaults to Twilio's public STUN server at `stun:global.stun.twilio.com:3478`. Override `iceServers` if you have custom STUN or TURN requirements for your network.
+
+Most apps never change either field. See [the connectivity reference](/reference/sdks/connectivity/) for advanced options like TURN-only relay mode, forced peer-to-peer, and custom TURN URI overrides.
+
+## Sessions
+
+A session is a client-server association that the SDK creates automatically when you connect. Sessions exist to stop actuators when a client disappears.
+
+The mechanism is a heartbeat protocol. The SDK calls `StartSession` on the machine, which returns a heartbeat window (default 2 seconds, configurable between 30&nbsp;ms and 1 minute). The SDK sends heartbeats within that window. If the heartbeats stop, because your browser tab crashed, your laptop lost Wi-Fi, or your app closed without calling `close()`, the server stops any resources that are safety-monitored **and** where this session was the last caller.
+
+The practical effect: if your app called `motor.setPower(1)` and then crashed, the server stops the motor within a heartbeat window of the crash. The machine does not continue running the last command indefinitely.
+
+### Which methods are safety-monitored
+
+Not every method triggers a session stop. Only methods marked with the `safety_heartbeat_monitored` proto extension participate. The components with safety-monitored methods today:
+
+- `arm` (motion commands)
+- `base` (drive commands)
+- `button`
+- `gantry`
+- `gripper`
+- `motor` (power and position commands)
+- `servo`
+- `switch`
+
+Read-only methods like `sensor.getReadings()` or `camera.getImage()` are not safety-monitored. Reading state from a component does not trigger a session stop.
+
+### Disabling sessions
+
+Pass `disableSessions: true` in the connection options to disable session heartbeating. The session proto documentation calls this "acknowledging the safety risk": if you disable sessions, a crashed client leaves actuators in whatever state they were last commanded to. Disable sessions only for specific reasons, such as implementing your own crash-detection and cleanup logic.
+
+See [the sessions API reference](/reference/apis/sessions/) for the full protocol details.
+
+## Reconnection
+
+When the network drops, the SDK reconnects automatically with exponential backoff. The relevant options on `DialWebRTCConf` and `DialDirectConf`:
+
+- `reconnectMaxAttempts` — default 10, the number of retries before giving up
+- `reconnectMaxWait` — default `Number.POSITIVE_INFINITY`, the maximum time between retries
+- `noReconnect` — default `false`, set to `true` to disable reconnection
+
+Reconnection is transparent to your application code. The `RobotClient` object stays valid across the drop, and in-flight method calls throw errors that your app can catch and retry after the reconnection completes. While the SDK is retrying, it emits `RECONNECTING`. If retries are exhausted, it emits `RECONNECTION_FAILED`.
+
+{{< alert title="Behavior change" color="caution" >}}
+In versions of the Viam TypeScript SDK prior to v0.69.0, `DISCONNECTED` fired on any drop.
+From v0.69.0 onward, it fires only on intentional close or when `noReconnect` is set; transient drops emit `RECONNECTING`.
+{{< /alert >}}
+
+What does _not_ happen automatically is your app's UI state. If you were showing a camera stream when the network dropped, the stream stops, and your UI has to rebuild the stream when the connection returns. If you were polling a sensor, the polling stops, and your UI has to resume polling. The SDK reconnects the transport; your app reconnects its own state.
+
+Subscribe to `MachineConnectionEvent` to react to connection state changes. See [Handle disconnection and reconnection](/build-apps/tasks/handle-connection-state/) for the pattern.
diff --git a/docs/build-apps/hosting/_index.md b/docs/build-apps/hosting/_index.md
new file mode 100644
index 0000000000..ffb53a42c2
--- /dev/null
+++ b/docs/build-apps/hosting/_index.md
@@ -0,0 +1,11 @@
+---
+linkTitle: "Viam hosting"
+title: "Viam hosting"
+weight: 150
+layout: "docs"
+type: "docs"
+no_list: true
+manualLink: "/build-apps/hosting/overview/"
+description: "Deploy and host a web app on Viam Applications with built-in authentication and credential injection."
+date: "2026-04-13"
+---
diff --git a/docs/build-apps/hosting/deploy.md b/docs/build-apps/hosting/deploy.md
new file mode 100644
index 0000000000..6ae32616c3
--- /dev/null
+++ b/docs/build-apps/hosting/deploy.md
@@ -0,0 +1,131 @@
+---
+linkTitle: "Deploy a Viam application"
+title: "Deploy a Viam application"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Package your app with meta.json and upload it to Viam Applications for hosting with built-in authentication and credential injection."
+date: "2026-04-10"
+---
+
+Package your client app and upload it to Viam Applications, Viam's hosting service for web apps. Once uploaded, your app is served at `{appname}_{namespace}.viamapplications.com` with authentication and machine-credential injection handled by the platform.
+
+Viam Applications are distributed through the Viam module registry, which is why the CLI commands live under `viam module`. This has nothing to do with building server-side modules; the `module` in the command name is an artifact of the registry plumbing.
+
+## Prerequisites
+
+- A built client app. Any bundler output that produces HTML, JavaScript, and CSS works: a Vite `dist/` directory, a Create React App `build/` directory, a Flutter web build, and so on. See [TypeScript setup](/build-apps/setup/typescript/) for a minimal Vite starting point.
+- The [Viam CLI](/cli/) installed and authenticated (`viam login`).
+- A public namespace for your organization. Set this in the [organization settings](/organization/) if you have not already. Viam Applications require a public namespace because the app's URL uses it.
+
+## Create the module registry entry
+
+First-time setup only. Each Viam Application is represented as a module in the Viam registry. Create the registry entry:
+
+```sh {class="command-line" data-prompt="$"}
+viam module create --name my-app --public-namespace your-namespace
+```
+
+This creates a `meta.json` in your current directory with a `module_id` of `your-namespace:my-app` and `visibility: private`. You will change the visibility and add the `applications` field in the next step.
+
+## Configure meta.json
+
+Edit `meta.json` to declare the application. The generated file needs two changes:
+
+1. Change `visibility` from `private` to `public`. Viam Applications require public visibility.
+2. Add an `applications` array describing the app.
+
+A complete `meta.json` for a single-machine browser app:
+
+```json
+{
+  "$schema": "https://dl.viam.dev/module.schema.json",
+  "module_id": "your-namespace:my-app",
+  "visibility": "public",
+  "applications": [
+    {
+      "name": "my-app",
+      "type": "single_machine",
+      "entrypoint": "dist/index.html"
+    }
+  ]
+}
+```
+
+Key fields in the `applications` entry:
+
+- `name` — appears in the URL as `{name}_{namespace}.viamapplications.com`. Lowercase alphanumeric and hyphens only. Must be unique within your namespace.
+- `type` — `single_machine` or `multi_machine`. Single-machine apps pick one machine and inject that machine's credentials. Multi-machine apps inject a user access token and let the app enumerate machines.
+- `entrypoint` — path to the HTML entry point, relative to the uploaded archive's root. For a Vite build, this is typically `dist/index.html`.
+
+See [the meta.json applications reference](/build-apps/hosting/meta-json-reference/) for all available fields, including `fragmentIds`, `logoPath`, and `customizations`.
+
+## Build your app
+
+Run your bundler to produce the static output. For Vite:
+
+```sh {class="command-line" data-prompt="$"}
+npm run build
+```
+
+Confirm the output directory contains an `index.html` and all its asset files. The path you put in `entrypoint` must match what the build produces.
+
+## Package and upload
+
+Create a tarball of everything you want to serve, including `meta.json`:
+
+```sh {class="command-line" data-prompt="$"}
+tar -czvf module.tar.gz meta.json dist/
+```
+
+Adjust the tar command to include whatever directories your build produced. The `meta.json` must be at the root of the archive.
+
+Upload to the registry:
+
+```sh {class="command-line" data-prompt="$"}
+viam module upload --upload module.tar.gz --platform any --version 0.0.1
+```
+
+Use `--platform any` for Viam Applications. Static web apps are platform-independent; the `any` platform tag tells the registry to serve the same archive to every user regardless of operating system.
+
+The `--version` flag is required and must be a semver string. You cannot reuse a version number, so each upload needs a higher version than the last.
+
+## Verify the deployment
+
+Your app is now live at:
+
+```text
+https://{name}_{namespace}.viamapplications.com
+```
+
+Replace `{name}` with the `name` field from your `meta.json` and `{namespace}` with your organization's public namespace. Open the URL in a browser. You should see:
+
+1. A redirect to the Viam login flow.
+2. After login, for a single-machine app: the machine picker (if the app has no fragment filter) or the app itself (if the URL targets a specific machine).
+3. For a multi-machine app: your app loads directly with the user access token already in cookies.
+
+If the app does not load, check:
+
+- **The `applications` array in the uploaded `meta.json`**. If the registry sees no applications, no URL is assigned. Re-upload with the correct field after fixing `meta.json`.
+- **The `entrypoint` path.** The path is relative to the archive root. If `meta.json` is at the root and your HTML is at `dist/index.html`, the entrypoint should be `dist/index.html`, not `/dist/index.html` or `index.html`.
+- **The namespace.** The URL uses your organization's public namespace, not the organization name or ID. Confirm the public namespace in the [organization settings](/organization/).
+
+## Release updates
+
+To release a new version of your app, rebuild and re-upload with a higher version number:
+
+```sh {class="command-line" data-prompt="$"}
+npm run build
+tar -czvf module.tar.gz meta.json dist/
+viam module upload --upload module.tar.gz --platform any --version 0.0.2
+```
+
+Viam Applications always serve the latest uploaded version. There is no staging step and no version selection in the URL.
+
+To roll back, upload the previous code under a new, higher version number. The registry rejects duplicate version numbers, so you cannot reuse an older one.
+
+## Next
+
+- [meta.json applications reference](/build-apps/hosting/meta-json-reference/) for the full schema
+- [Hosting platform reference](/build-apps/hosting/hosting-reference/) for URL patterns, cookie structure, caching behavior, and limits
+- [Test against a local machine](/build-apps/tasks/test-locally/) for iterating on your app before each upload
diff --git a/docs/build-apps/hosting/hosting-reference.md b/docs/build-apps/hosting/hosting-reference.md
new file mode 100644
index 0000000000..f62cfecc8a
--- /dev/null
+++ b/docs/build-apps/hosting/hosting-reference.md
@@ -0,0 +1,162 @@
+---
+linkTitle: "Hosting reference"
+title: "Viam Applications hosting platform reference"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "URL patterns, cookie structure, caching behavior, and limits for the Viam Applications hosting platform."
+date: "2026-04-10"
+---
+
+Reference for the runtime behavior of the Viam Applications hosting platform. For the deployment workflow, see [Deploy a Viam application](/build-apps/hosting/deploy/). For the `meta.json` schema that configures the application, see [the meta.json applications reference](/build-apps/hosting/meta-json-reference/).
+
+## URL pattern
+
+Every Viam Application is served at:
+
+```text
+https://{name}_{namespace}.viamapplications.com
+```
+
+- `{name}` is the `name` field from the application's `meta.json` entry.
+- `{namespace}` is the public namespace of the organization that owns the module.
+
+Example: an application named `dashboard` in the `acme` namespace is served at `https://dashboard_acme.viamapplications.com`.
+
+Internal Viam environments use `viamapps.dev` instead of `viamapplications.com`, but the `{name}_{namespace}` pattern is the same.
+
+## Authentication flow
+
+All Viam Applications require the user to be logged into Viam. The first visit to an application's URL redirects through Viam's OAuth flow; after login, the user lands on the application with credentials in browser cookies.
+
+For single-machine applications, the flow includes a machine selection step if the application has `fragmentIds` that match more than one machine in the user's fleet, or if the user accesses the base URL without a specific machine in the path.
+
+## Cookies
+
+Viam injects credentials into browser cookies after login. Your application code reads the cookies and passes the credentials to the SDK.
+
+### Single-machine applications
+
+A single-machine application receives one cookie per machine the user has selected. The cookie name is the machine ID, and its value is a JSON object with the following shape:
+
+```json
+{
+  "apiKey": {
+    "id": "api-key-id",
+    "key": "api-key-secret"
+  },
+  "id": "api-key-id",
+  "key": "api-key-secret",
+  "credentials": {
+    "type": "api-key",
+    "payload": "api-key-secret",
+    "authEntity": "api-key-id"
+  },
+  "hostname": "machine-main.xxxx.viam.cloud",
+  "machineId": "machine-uuid",
+  "timestamp": 1712620800
+}
+```
+
+The `credentials` object is structured for direct use with `createRobotClient`:
+
+```ts
+import * as VIAM from "@viamrobotics/sdk";
+import Cookies from "js-cookie";
+
+const pathParts = window.location.pathname.split("/");
+const machineId = pathParts[2]; // from URL like /machine/{id}/...
+
+const cookieValue = JSON.parse(Cookies.get(machineId)!);
+
+const machine = await VIAM.createRobotClient({
+  host: cookieValue.hostname,
+  credentials: cookieValue.credentials,
+  signalingAddress: "https://app.viam.com:443",
+});
+```
+
+The `id` and `key` top-level fields are duplicates of `apiKey.id` and `apiKey.key` retained for backwards compatibility. New code should use either `apiKey` or `credentials` directly.
+
+### Multi-machine applications
+
+A multi-machine application receives one cookie named `userToken` containing the logged-in user's OAuth access token. The cookie value is a JSON object representing the full `oauth2.Token`:
+
+```json
+{
+  "access_token": "...",
+  "token_type": "Bearer",
+  "refresh_token": "...",
+  "expiry": "2026-04-10T12:00:00Z"
+}
+```
+
+Read the `access_token` field and pass it to `createViamClient` as an access-token credential:
+
+```ts
+import * as VIAM from "@viamrobotics/sdk";
+import Cookies from "js-cookie";
+
+const userTokenRaw = Cookies.get("userToken")!;
+const { access_token } = JSON.parse(userTokenRaw);
+
+const client = await VIAM.createViamClient({
+  credentials: {
+    type: "access-token",
+    payload: access_token,
+  },
+});
+```
+
+Use the resulting `ViamClient` to enumerate and connect to specific machines. See [Connect to the Viam cloud](/build-apps/tasks/connect-to-cloud/).
+
+## Cookie lifecycle
+
+Machine cookies in single-machine applications have a 30-day maximum age. The platform refreshes them automatically when the user visits the application after 75% of the maximum age has elapsed (approximately 22.5 days). Users who return within the refresh window stay logged in without re-authenticating.
+
+User tokens in multi-machine applications follow the underlying OAuth token lifecycle: the platform refreshes access tokens through the standard OAuth refresh flow without user interaction. The `userToken` cookie is updated with the new access token when it is refreshed.
+
+## Caching
+
+The hosting platform caches your app's files with the following `Cache-Control` behavior:
+
+| Content type                                     | Cache-Control header                  | Behavior                                                                    |
+| ------------------------------------------------ | ------------------------------------- | --------------------------------------------------------------------------- |
+| HTML files (entrypoint and any `.html`)          | `no-cache, no-store, must-revalidate` | Never cached in browser or CDN. Every request hits the latest version.      |
+| All other static assets (CSS, JS, images, fonts) | `private, max-age=86400`              | Cached in the user's browser for 24 hours. Not cached in shared CDN layers. |
+
+The server also maintains a short-lived in-memory cache (approximately 5 minutes) of each application's blob path and entrypoint lookup, to avoid hitting the module registry database on every request. This cache invalidates automatically within a few minutes of an upload, so new versions go live within minutes of `viam module upload` completing.
+
+If you see stale JavaScript or CSS after an upload, the cause is almost always your browser cache, not the platform cache. Hard-reload the page (Ctrl+Shift+R or Cmd+Shift+R) or open the application in an incognito window.
+
+## Storage and delivery
+
+Uploaded application tarballs are extracted to Google Cloud Storage under a path of the form `{namespace}/{app-name}/{version}/`. The hosting server proxies user requests to GCS through an authenticated reverse proxy. The proxy:
+
+- Strips the `/machine/{machineId}/` prefix from the URL before forwarding, for single-machine applications.
+- Injects a `<base href>` tag into HTML responses so relative asset paths resolve correctly under the prefix-stripped path.
+- Sets the cache headers described above.
+- Sets machine or user cookies on the response where applicable.
+
+Application authors do not interact with GCS directly; all uploads go through `viam module upload`.
+
+## Versioning
+
+Viam Applications always serve the latest uploaded version for a given `name` + namespace combination. There is no URL parameter, header, or manifest field for selecting a specific version.
+
+To release a new version, upload with a higher semver `--version`. The registry rejects duplicate version numbers.
+
+To roll back, upload the previous code under a new, higher version number. There is no direct "revert" operation.
+
+## Limits
+
+- **Public visibility required.** The module hosting the application must have `visibility: public` in `meta.json`. Private modules cannot host applications.
+- **Static files only.** Viam Applications does not execute server-side code. No serverless functions, no backend endpoints, no API routes. The hosted content is HTML, JS, CSS, images, and other static assets only. Your browser-side application logic can be arbitrarily dynamic.
+- **Cookies required.** Users whose browsers block cookies cannot log into Viam Applications.
+- **One application per URL.** Each `name`+namespace combination serves a single application. Multiple applications with the same name in the same namespace are not allowed.
+
+## Related
+
+- [Deploy a Viam application](/build-apps/hosting/deploy/) for the package-and-upload workflow
+- [meta.json applications schema](/build-apps/hosting/meta-json-reference/) for the application configuration
+- [Authentication](/build-apps/concepts/authentication/) for the credential injection model
diff --git a/docs/build-apps/hosting/meta-json-reference.md b/docs/build-apps/hosting/meta-json-reference.md
new file mode 100644
index 0000000000..76b7f53186
--- /dev/null
+++ b/docs/build-apps/hosting/meta-json-reference.md
@@ -0,0 +1,159 @@
+---
+linkTitle: "meta.json schema"
+title: "meta.json applications schema"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "Reference for the applications array in meta.json, which declares one or more Viam Applications for hosted deployment."
+date: "2026-04-10"
+---
+
+Reference for the `applications` array in `meta.json`. This array declares one or more Viam Applications that Viam hosts at `*.viamapplications.com` after you upload the module. For the deployment workflow that produces and uploads `meta.json`, see [Deploy a Viam application](/build-apps/hosting/deploy/).
+
+## Complete example
+
+```json
+{
+  "$schema": "https://dl.viam.dev/module.schema.json",
+  "module_id": "acme:dashboard",
+  "visibility": "public",
+  "applications": [
+    {
+      "name": "dashboard",
+      "type": "multi_machine",
+      "entrypoint": "dist/index.html",
+      "fragmentIds": ["f0b5a1c2-..."],
+      "allowedOrgIds": ["org-id-1", "org-id-2"],
+      "logoPath": "static/logo.png",
+      "customizations": {
+        "machinePicker": {
+          "heading": "Select your device",
+          "subheading": "Choose a machine to monitor"
+        }
+      }
+    }
+  ]
+}
+```
+
+## Top-level module fields
+
+These fields apply to the whole module, not to a specific application. They are required even when the module's only purpose is to host an application.
+
+| Field          | Type   | Required                                                                             | Notes                                                                                            |
+| -------------- | ------ | ------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------ |
+| `$schema`      | string | Optional                                                                             | Canonical value: `"https://dl.viam.dev/module.schema.json"`. Enables editor schema validation.   |
+| `module_id`    | string | Required                                                                             | Format: `<public-namespace>:<module-name>`. Generated by `viam module create`.                   |
+| `visibility`   | string | Required                                                                             | Must be `"public"` for modules with applications. Private modules cannot host Viam Applications. |
+| `applications` | array  | Optional at the module level, but required if the module has any application content | See the application object fields below.                                                         |
+
+## Application object fields
+
+Each element of the `applications` array is an application object with the fields below.
+
+### `name`
+
+Type: `string`. Required.
+
+The application's URL segment. Appears in the URL as `{name}_{namespace}.viamapplications.com`, where `{namespace}` is your organization's public namespace.
+
+Constraints:
+
+- Lowercase alphanumeric characters and hyphens only.
+- Cannot start or end with a hyphen.
+- Must be unique within your organization's namespace.
+
+Example: `"dashboard"` produces `dashboard_acme.viamapplications.com` (if the namespace is `acme`).
+
+### `type`
+
+Type: `string`. Required.
+
+Declares how the application accesses machines. Two valid values:
+
+| Value              | Behavior                                                                                                                                   |
+| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| `"single_machine"` | The application operates on one machine at a time. Viam injects that machine's API key and hostname into browser cookies.                  |
+| `"multi_machine"`  | The application can access any machine the logged-in user has permissions for. Viam injects the user's access token into a browser cookie. |
+
+See [Authentication](/build-apps/concepts/authentication/) for what gets injected and how your app code reads the cookies.
+
+### `entrypoint`
+
+Type: `string`. Required.
+
+Path to the HTML entry point, relative to the root of the uploaded archive. This is where the hosting platform's proxy looks for the first HTML file to serve.
+
+Example: `"dist/index.html"` for a Vite build that outputs to `dist/`.
+
+The path must match what your build produces. If your bundler writes `build/index.html` instead of `dist/index.html`, use `"build/index.html"`.
+
+### `fragmentIds`
+
+Type: `array of string`. Optional. Single-machine applications only.
+
+List of fragment IDs that restrict which machines appear in the machine picker. A machine is selectable only if its configuration includes every fragment in this list. Use this to scope a single-machine application to machines provisioned for a specific customer or device model.
+
+If the array is empty or omitted, any machine the user has access to is selectable.
+
+### `allowedOrgIds`
+
+Type: `array of string`. Optional.
+
+List of organization IDs that are allowed to use this application. If set, users who belong to organizations not in this list cannot access the application even if it is public.
+
+If the array is empty or omitted, any organization with access to the application can use it.
+
+### `logoPath`
+
+Type: `string`. Optional. Single-machine applications only.
+
+Path to a logo image to display on the machine picker screen. Two forms are accepted:
+
+- A path relative to the uploaded archive root, such as `"static/logo.png"`.
+- An absolute URL, such as `"https://example.com/logo.png"`.
+
+Relative paths are served from the application's own archive; absolute URLs are loaded from the remote host you specify.
+
+### `customizations`
+
+Type: `object`. Optional. Currently applies to the machine picker screen only.
+
+Customizes user-facing text on Viam-rendered screens (the machine picker for single-machine applications, and potentially other screens in the future). Currently one subfield:
+
+#### `customizations.machinePicker`
+
+Type: `object`. Optional.
+
+| Field        | Type   | Max length     | Notes                                     |
+| ------------ | ------ | -------------- | ----------------------------------------- |
+| `heading`    | string | 60 characters  | Large title on the machine picker screen. |
+| `subheading` | string | 256 characters | Supporting text below the heading.        |
+
+Example:
+
+```json
+"customizations": {
+  "machinePicker": {
+    "heading": "ACME Warehouse Dashboard",
+    "subheading": "Select a warehouse rover to monitor and control."
+  }
+}
+```
+
+## Field summary
+
+| Field            | Type            | Required | Single-machine only | Notes                                           |
+| ---------------- | --------------- | -------- | ------------------- | ----------------------------------------------- |
+| `name`           | string          | Yes      | —                   | URL segment, lowercase alphanumeric and hyphens |
+| `type`           | string          | Yes      | —                   | `"single_machine"` or `"multi_machine"`         |
+| `entrypoint`     | string          | Yes      | —                   | Relative path to HTML file                      |
+| `fragmentIds`    | array of string | No       | Yes                 | Filter machines by fragment                     |
+| `allowedOrgIds`  | array of string | No       | —                   | Restrict access to specific orgs                |
+| `logoPath`       | string          | No       | Yes                 | Path or URL for machine picker logo             |
+| `customizations` | object          | No       | —                   | Custom headings for Viam-rendered screens       |
+
+## Related
+
+- [Deploy a Viam application](/build-apps/hosting/deploy/) for the package-and-upload workflow
+- [Hosting platform reference](/build-apps/hosting/hosting-reference/) for URL patterns, cookie structure, caching, and limits
diff --git a/docs/build-apps/hosting/overview.md b/docs/build-apps/hosting/overview.md
new file mode 100644
index 0000000000..3f88b66ff9
--- /dev/null
+++ b/docs/build-apps/hosting/overview.md
@@ -0,0 +1,39 @@
+---
+linkTitle: "Overview"
+title: "Viam hosting"
+weight: 1
+layout: "docs"
+type: "docs"
+description: "Host a browser-based Viam app on Viam Applications with built-in authentication, credential injection, and a dedicated URL."
+date: "2026-04-13"
+---
+
+Viam Applications is a hosting service for browser-based apps built with the TypeScript SDK or any frontend framework that produces HTML, JavaScript, and CSS. You upload your app's build output to the Viam registry, and Viam serves it at `{name}_{namespace}.viamapplications.com`.
+
+Viam Applications is one of five [deployment options](/build-apps/overview/#deployment-options) for SDK-based apps. It works by serving your app's files (HTML, JavaScript, CSS) to a web browser. The browser downloads the files and runs the JavaScript locally. This means Viam Applications works for apps built with TypeScript, React, Vue, Svelte, or any other framework that compiles to files a browser can run. It does not work for Python, Go, or C++ apps, which run as processes on a server or workstation and need their own hosting; see the long-running service and local execution rows in the [deployment options table](/build-apps/overview/#deployment-options).
+
+Viam Applications handles three things that you would otherwise build yourself:
+
+- **Authentication.** Users log in through Viam's OAuth flow. You do not implement a login page, manage tokens, or integrate an identity provider.
+- **Credential delivery.** After login, Viam stores an authentication credential in a browser cookie that your app reads to connect to machines. For single-machine apps, this is a machine-scoped API key. For multi-machine apps, this is the user's OAuth access token. The cookie is scoped to the app's domain and set with `SameSite=Strict`.
+- **Hosting and TLS.** Viam serves your app over HTTPS at a dedicated URL. You do not configure a web server, provision a certificate, or manage a CDN.
+
+## Two application types
+
+Viam Applications supports two types, declared in your `meta.json`:
+
+**Single-machine.** The app operates on one machine at a time. After login, Viam presents a machine picker (optionally filtered by fragment) and delivers a machine-scoped API key and hostname to the browser. Your app reads the credential from the cookie and passes it to the SDK. Use this when your app is a control interface or dashboard for a specific device.
+
+**Multi-machine.** The app can access any machine the logged-in user has permissions for. After login, Viam delivers the user's OAuth access token to the browser. Your app reads the token from the cookie and passes it to the SDK to enumerate machines across the organization and connect to each one. Use this when your app is a fleet dashboard or a multi-device management tool.
+
+## What's in this section
+
+- [Deploy a Viam application](/build-apps/hosting/deploy/) walks through packaging your app, configuring `meta.json`, and uploading to the registry.
+- [meta.json applications schema](/build-apps/hosting/meta-json-reference/) is the field-by-field reference for the `applications` array that declares your app's type, entrypoint, fragment filters, and branding.
+- [Hosting platform reference](/build-apps/hosting/hosting-reference/) documents the URL pattern, cookie structure, caching behavior, and limits.
+
+## Constraints
+
+- Viam Applications hosts browser-based apps only. It serves your files from storage and does not execute any server-side code: no serverless functions, no backend endpoints, no API routes.
+- Viam always serves the latest uploaded version. There is no version selection or rollback UI; to roll back, upload the previous code under a new version number.
+- Cookies are required. Browsers with cookies disabled cannot use Viam Applications.
diff --git a/docs/build-apps/overview.md b/docs/build-apps/overview.md
new file mode 100644
index 0000000000..596dab0cc3
--- /dev/null
+++ b/docs/build-apps/overview.md
@@ -0,0 +1,71 @@
+---
+linkTitle: "Overview"
+title: "Build apps"
+weight: 1
+layout: "docs"
+type: "docs"
+description: "Build software that uses a Viam SDK to talk to your machines and the Viam cloud, from web dashboards to long-running backend services."
+date: "2026-04-10"
+---
+
+A Viam app is software that uses a Viam SDK to talk to a machine or to the Viam cloud. It runs outside `viam-server`: in a browser, on a phone, on a server, or on a laptop. Viam apps come in many shapes: a browser dashboard, a Flutter app on a kiosk, a Python service that polls sensors, a Go program that orchestrates a fleet.
+
+The line between an app and a [module](/build-modules/) is where the code runs. A module runs inside `viam-server` and extends it with new components or services. An app runs outside `viam-server` and uses the SDK to talk to it.
+
+This section covers building apps: setup for each language, connection and authentication, streaming video, querying captured data, controlling components, and deployment.
+
+## What the SDK does
+
+The Viam SDKs handle the connection details for you. They open the transport (WebRTC where appropriate, gRPC otherwise), manage sessions for safety, and reconnect automatically when the network drops. You write business logic; the SDK handles the wire.
+
+## Deployment options
+
+A Viam app can be distributed and run in five different ways. Most apps fit cleanly into one of these shapes; a few combine two (a long-running service plus a web frontend, for example).
+
+| Deployment               | What it is                                                                                                                                                                                                                                                                                                        | Typical platform                                                                  |
+| ------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
+| **Viam Applications**    | A web app hosted by Viam at `{name}_{namespace}.viamapplications.com`. Auth and machine credentials are injected automatically. No server-side code execution. Always serves the latest uploaded version.                                                                                                         | Browser (TypeScript or any frontend framework)                                    |
+| **Self-hosted web app**  | A web app you serve yourself: Vercel, Netlify, S3, GitHub Pages, your own server. You handle TLS, auth, credentials, and the domain. You get full control of versioning, server-side functions, and anything else your hosting platform supports.                                                                 | Browser (TypeScript or any frontend framework)                                    |
+| **Distributed binary**   | A native app you build and ship through an app store, an installer, or an internal channel. The user installs it on their device and opens it from their home screen or desktop.                                                                                                                                  | Flutter (iOS, Android, Linux, macOS, web, Windows) or React Native (iOS, Android) |
+| **Long-running service** | A daemon that runs continuously on a server, container, or edge device. No UI; it talks to one or more machines, processes data, triggers actions, exposes its own API, or integrates with other systems. Operated by ops tooling (systemd, Kubernetes, supervisord) rather than by a user clicking on something. | Python, Go, Node.js, C++                                                          |
+| **Local execution**      | Code you run from your own laptop or terminal: a script, a notebook, a Flutter desktop build for development. Useful for prototyping, ad-hoc operations, debugging, or scripts you run by hand.                                                                                                                   | TypeScript, Python, Go, Flutter, Node.js, React Native, C++                       |
+
+The platform column is a guide, not a constraint. Most platforms fit several deployment shapes (a Flutter app can be distributed as a binary or run locally for development; TypeScript can run in a browser or as a Node service).
+
+## Viam hosting
+
+If you are building a browser-based app, Viam can host it for you. Viam Applications serves your app at a dedicated URL with authentication and credential injection handled by the platform. See [Viam hosting](/build-apps/hosting/) for how it works, how to deploy, and the hosting platform details.
+
+## Where to start
+
+If you want **a quick operator interface and don't need to write code**, use [teleop workspaces](/monitor/teleop-workspaces/). They are widget-based and live in the monitor section.
+
+If you want **a custom web dashboard or operator interface in a browser**, see [TypeScript setup](/build-apps/setup/typescript/) and the [single-machine dashboard tutorial](/build-apps/app-tutorials/tutorial-dashboard/).
+
+If you want **one app that runs on phones, tablets, and desktops from a single codebase**, see [Flutter setup](/build-apps/setup/flutter/) and the [Flutter widget tutorial](/build-apps/app-tutorials/tutorial-flutter-app/).
+
+If you want **a long-running service or script that talks to Viam without a UI**, pick your language: [Python](/build-apps/setup/python/), [Go](/build-apps/setup/go/), [Node.js](/build-apps/setup/node/), or [C++](/build-apps/setup/cpp/). The [Python monitoring service tutorial](/build-apps/app-tutorials/tutorial-monitoring-service/) walks through building one from scratch.
+
+If you want **a dashboard that aggregates data across many machines**, see [Connect to the Viam cloud](/build-apps/tasks/connect-to-cloud/) and the [multi-machine fleet dashboard tutorial](/build-apps/app-tutorials/tutorial-fleet/).
+
+If you want **Viam to host your web app**, see [Hosting](/build-apps/hosting/) and [Deploy a Viam application](/build-apps/hosting/deploy/).
+
+If you are **coming from Foxglove, rosbridge, or a custom WebRTC stack**, read [How apps connect](/build-apps/concepts/how-apps-connect/) to understand Viam's connection model, then check the limits below.
+
+## What build-apps does not cover
+
+Some things that sound related live elsewhere or are not currently supported.
+
+- **3D scene visualization inside a custom app.** Viam has a built-in 3D Scene tab on the machine page, but the SDKs do not expose 3D rendering primitives. If you need 3D in a custom app, bring your own library (three.js, react-three-fiber, Unity, Babylon) and plot Viam data into it.
+- **Alarm aggregation for fleet dashboards.** Viam has alerts in the [monitor section](/monitor/alert/), but the SDKs do not provide alarm aggregation, deduplication, or severity ranking. Build that yourself.
+- **Foxglove interop.** Viam does not support MCAP log import, Foxglove layout import, or embedding Foxglove panels.
+- **Server-side code execution on Viam Applications.** Viam Applications serves your app's files from storage and does not execute any of your code server-side. No serverless functions, no backend endpoints, no API routes. Your app can be as dynamic and interactive as you want in the browser; Viam just does not run server-side logic on your behalf. For that, host a backend service yourself (the long-running service deployment shape above).
+- **Version pinning and rollback for hosted apps.** Viam Applications always serves the latest uploaded version. To roll back, upload the previous code under a new version number.
+- **Modules.** Code that runs _inside_ `viam-server` to extend it with new component types, services, or logic is a module, not an app. See [Build and deploy modules](/build-modules/) for that path.
+
+## See also
+
+- [Teleop workspaces](/monitor/teleop-workspaces/) for no-code custom control interfaces built from widgets
+- [SDK reference](/reference/sdks/) for TypeScript, Flutter, Python, Go, and C++ API documentation
+- [Connectivity reference](/reference/sdks/connectivity/) for sessions, WebRTC behavior, and local-network connections
+- [Admin and access](/organization/) for creating API keys and managing organization access
diff --git a/docs/build-apps/setup/_index.md b/docs/build-apps/setup/_index.md
new file mode 100644
index 0000000000..9421a3ed66
--- /dev/null
+++ b/docs/build-apps/setup/_index.md
@@ -0,0 +1,11 @@
+---
+linkTitle: "App scaffolding"
+title: "App scaffolding"
+weight: 20
+layout: "docs"
+type: "docs"
+no_list: true
+manualLink: "/build-apps/setup/overview/"
+description: "Scaffold a Viam app project in any supported language: create a project, install the SDK, configure credentials, and verify the connection."
+date: "2026-04-13"
+---
diff --git a/docs/build-apps/setup/cpp.md b/docs/build-apps/setup/cpp.md
new file mode 100644
index 0000000000..abfcc46657
--- /dev/null
+++ b/docs/build-apps/setup/cpp.md
@@ -0,0 +1,156 @@
+---
+linkTitle: "C++ setup"
+title: "C++ setup"
+weight: 70
+layout: "docs"
+type: "docs"
+description: "Set up a project for writing a Viam app in C++: an embedded application, a high-performance service, or any other C++ program that talks to a Viam machine."
+date: "2026-04-13"
+---
+
+Set up a project for writing a Viam app in C++: an embedded application, a high-performance service, or any other C++ program that talks to a Viam machine. The C++ SDK has a heavier build setup than the other SDKs because it requires CMake and several system-level dependencies. For the connection patterns your app will actually use, see [Connect to a machine](/build-apps/tasks/connect-to-machine/).
+
+## Prerequisites
+
+- CMake 3.25 or later
+- A C++ compiler with C++17 support
+- The following system libraries, installed through your package manager:
+
+  **Linux (apt):**
+
+  ```sh {class="command-line" data-prompt="$"}
+  sudo apt-get install cmake build-essential libboost-all-dev libgrpc++-dev libprotobuf-dev libxtensor-dev pkg-config ninja-build
+  ```
+
+  **macOS (Homebrew):**
+
+  ```sh {class="command-line" data-prompt="$"}
+  brew install cmake boost grpc protobuf xtensor pkg-config ninja buf
+  ```
+
+- A configured Viam machine
+- The machine's URI (address), an API key ID, and an API key
+
+Get the three credentials from the machine's **CONNECT** tab in the Viam app: go to the machine's page, click **CONNECT**, select **C++**, and toggle **Include API key** on.
+
+## Build or install the SDK
+
+The C++ SDK can be built from source or consumed through the [Conan package manager](https://github.com/viamrobotics/viam-cpp-sdk/blob/main/doc/conan.md). Building from source:
+
+```sh {class="command-line" data-prompt="$"}
+git clone https://github.com/viamrobotics/viam-cpp-sdk.git
+cd viam-cpp-sdk
+mkdir build
+cd build
+cmake .. -G Ninja
+ninja
+sudo ninja install
+```
+
+See the SDK's [BUILDING.md](https://github.com/viamrobotics/viam-cpp-sdk/blob/main/doc/BUILDING.md) for the full set of CMake options, Conan instructions, and Docker-based development workflows.
+
+## Create a project
+
+Create a directory for your app:
+
+```sh {class="command-line" data-prompt="$"}
+mkdir my-viam-app
+cd my-viam-app
+```
+
+Create a `CMakeLists.txt`:
+
+```cmake
+cmake_minimum_required(VERSION 3.25)
+project(my-viam-app)
+
+find_package(viam-cpp-sdk REQUIRED)
+
+add_executable(my-viam-app main.cpp)
+target_link_libraries(my-viam-app PRIVATE viam-cpp-sdk::viamsdk)
+```
+
+## Verify the connection
+
+Create `main.cpp`:
+
+```cpp
+#include <cstdlib>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <viam/sdk/common/instance.hpp>
+#include <viam/sdk/robot/client.hpp>
+#include <viam/sdk/rpc/dial.hpp>
+
+using namespace viam::sdk;
+
+int main() {
+    Instance inst;
+
+    const char* uri = std::getenv("MACHINE_ADDRESS");
+    const char* key_id = std::getenv("API_KEY_ID");
+    const char* key = std::getenv("API_KEY");
+
+    if (!uri || !key_id || !key) {
+        std::cerr << "Set MACHINE_ADDRESS, API_KEY_ID, and API_KEY\n";
+        return 1;
+    }
+
+    ViamChannel::Options channel_options;
+    channel_options.set_entity(std::string(key_id));
+    Credentials credentials("api-key", std::string(key));
+    channel_options.set_credentials(credentials);
+    Options options(1, channel_options);
+
+    auto robot = RobotClient::at_address(std::string(uri), options);
+
+    std::vector<Name> resource_names = robot->resource_names();
+    std::cout << "Connected. Found " << resource_names.size()
+              << " resources." << std::endl;
+
+    return 0;
+}
+```
+
+Build and run:
+
+```sh {class="command-line" data-prompt="$"}
+mkdir build
+cd build
+cmake ..
+make
+MACHINE_ADDRESS=my-robot-main.xxxx.viam.cloud \
+  API_KEY_ID=your-api-key-id \
+  API_KEY=your-api-key-secret \
+  ./my-viam-app
+```
+
+You should see:
+
+```text
+Connected. Found N resources.
+```
+
+where `N` is the number of components and services on your machine.
+
+The `Instance` object must be created before any other SDK objects and must outlive them all. It initializes the SDK's internal state. Creating it at the top of `main()` and letting it go out of scope at the end is the standard pattern.
+
+## WebRTC note
+
+The C++ SDK's WebRTC support is implemented through a Rust FFI layer. The SDK's README notes that this implementation is still maturing and may have issues with streaming requests. If you encounter problems with WebRTC connections, disable WebRTC to fall back to direct gRPC. See the [SDK's README](https://github.com/viamrobotics/viam-cpp-sdk#a-note-on-connectivity-and-webrtc-functionality) for the current status.
+
+## Troubleshooting
+
+- **`find_package(viam-cpp-sdk)` fails.** The SDK is not installed or not on CMake's search path. Rebuild and install the SDK (`sudo ninja install`), or set `CMAKE_PREFIX_PATH` to where you installed it.
+- **Linker errors referencing Boost, gRPC, or protobuf.** One of the system dependencies is missing or is an incompatible version. Reinstall through your package manager and confirm versions meet the minimums.
+- **Connection hangs.** Verify the machine address matches the **CONNECT** tab exactly. If WebRTC is the issue, try disabling it to isolate the transport layer from your application logic.
+
+## Next
+
+- [Connect to a machine](/build-apps/tasks/connect-to-machine/) for the connection patterns your app will actually use
+- [Handle disconnection and reconnection](/build-apps/tasks/handle-connection-state/) for reconnection and status indicators
+- [C++ SDK reference](https://cpp.viam.dev/) for per-component API details
+- [BUILDING.md](https://github.com/viamrobotics/viam-cpp-sdk/blob/main/doc/BUILDING.md) for the full build system documentation
diff --git a/docs/build-apps/setup/flutter.md b/docs/build-apps/setup/flutter.md
new file mode 100644
index 0000000000..f2853d4a3b
--- /dev/null
+++ b/docs/build-apps/setup/flutter.md
@@ -0,0 +1,204 @@
+---
+linkTitle: "Flutter setup"
+title: "Flutter setup"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "Set up a project for building a Viam app that runs across iOS, Android, and desktop platforms from a single codebase."
+date: "2026-04-10"
+---
+
+Set up a project for building a Viam app that runs across iOS, Android, and desktop platforms from a single codebase: a tablet operator interface, a warehouse kiosk, a phone app for technicians in the field. This page covers the project scaffolding with [Flutter](https://flutter.dev/), the Viam Flutter SDK install, and the iOS/macOS and Android platform configuration. For the connection patterns your app will actually use, see [Connect to a machine](/build-apps/tasks/connect-to-machine/).
+
+## Prerequisites
+
+- Flutter SDK 3.0.0 or later ([install Flutter](https://docs.flutter.dev/get-started/install))
+- Platform tooling for at least one of your targets:
+  - **iOS:** Xcode and an Apple Developer account (or the iOS Simulator)
+  - **Android:** Android Studio with Android SDK 23 or later and Kotlin `1.8.20` or later
+  - **Linux, macOS, Windows:** the desktop tooling for your target ([Flutter desktop setup](https://docs.flutter.dev/platform-integration/desktop))
+  - **Web:** a Chromium-based browser for development ([Flutter web setup](https://docs.flutter.dev/platform-integration/web))
+- A configured Viam machine
+- The machine's address, an API key, and an API key ID
+
+Get the credentials from the machine's **CONNECT** tab in the Viam app: click **CONNECT**, select **Flutter**, and copy the address, API key ID, and API key from the generated code sample.
+
+## Create a project
+
+```sh {class="command-line" data-prompt="$"}
+flutter create my_viam_app
+cd my_viam_app
+```
+
+`flutter create` generates a project that targets all six Flutter platforms. To narrow the targets, pass `--platforms=ios,android` (or any subset) to the command.
+
+## Add the Viam SDK
+
+```sh {class="command-line" data-prompt="$"}
+flutter pub add viam_sdk flutter_dotenv
+```
+
+`flutter_dotenv` loads environment variables from a `.env` file at runtime, which keeps credentials out of source code.
+
+## Configure iOS and macOS (if targeting Apple platforms)
+
+The Viam SDK uses WebRTC and mDNS, both of which require explicit permissions on iOS and macOS.
+
+Add the following to `ios/Runner/Info.plist` and `macos/Runner/Info.plist`, inside the top-level `<dict>`:
+
+```xml
+<key>NSLocalNetworkUsageDescription</key>
+<string>This app needs access to the local network to connect to your Viam machine.</string>
+<key>NSBonjourServices</key>
+<array>
+  <string>_rpc._tcp</string>
+</array>
+```
+
+Set the minimum iOS deployment target to 13.0 in `ios/Podfile`:
+
+```ruby
+platform :ios, '13.0'
+```
+
+## Configure Android (if targeting Android)
+
+In `android/app/build.gradle`, confirm that the minimum SDK version is 23 or higher:
+
+```groovy
+defaultConfig {
+    minSdkVersion 23
+    // ...
+}
+```
+
+If your Kotlin version is lower than `1.8.20`, bump it in `android/build.gradle`:
+
+```groovy
+ext.kotlin_version = '1.8.20'
+```
+
+## Configure environment variables
+
+Create a `.env` file in your project root:
+
+```text
+MACHINE_ADDRESS=my-robot-main.xxxx.viam.cloud
+API_KEY_ID=your-api-key-id
+API_KEY=your-api-key-secret
+```
+
+Replace the three values with what you copied from the **CONNECT** tab.
+
+Add `.env` to your `.gitignore`:
+
+```sh {class="command-line" data-prompt="$"}
+echo ".env" >> .gitignore
+```
+
+Register `.env` as an asset in `pubspec.yaml` so Flutter bundles it with the app:
+
+```yaml
+flutter:
+  assets:
+    - .env
+```
+
+## Verify the connection
+
+Replace the contents of `lib/main.dart` with:
+
+```dart
+import 'package:flutter/material.dart';
+import 'package:flutter_dotenv/flutter_dotenv.dart';
+import 'package:viam_sdk/viam_sdk.dart';
+
+void main() async {
+  WidgetsFlutterBinding.ensureInitialized();
+  await dotenv.load();
+  runApp(const MyApp());
+}
+
+class MyApp extends StatelessWidget {
+  const MyApp({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return const MaterialApp(
+      home: Scaffold(body: Center(child: StatusText())),
+    );
+  }
+}
+
+class StatusText extends StatefulWidget {
+  const StatusText({super.key});
+
+  @override
+  State<StatusText> createState() => _StatusTextState();
+}
+
+class _StatusTextState extends State<StatusText> {
+  String _status = 'Connecting...';
+
+  @override
+  void initState() {
+    super.initState();
+    _connect();
+  }
+
+  Future<void> _connect() async {
+    try {
+      final address = dotenv.env['MACHINE_ADDRESS']!;
+      final apiKeyId = dotenv.env['API_KEY_ID']!;
+      final apiKey = dotenv.env['API_KEY']!;
+
+      final robot = await RobotClient.atAddress(
+        address,
+        RobotClientOptions.withApiKey(apiKeyId, apiKey),
+      );
+
+      setState(() {
+        _status = 'Connected. Found ${robot.resourceNames.length} resources.';
+      });
+    } catch (e) {
+      setState(() {
+        _status = 'Connection failed: $e';
+      });
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Text(_status);
+  }
+}
+```
+
+## Run the app
+
+Run the app on a connected device or simulator:
+
+```sh {class="command-line" data-prompt="$"}
+flutter run
+```
+
+If multiple targets are available, Flutter prompts you to choose. Select your device. The app builds, launches, and shows:
+
+```text
+Connected. Found N resources.
+```
+
+where `N` is the number of components and services on your machine.
+
+If you see `Connection failed:`, the most common causes are:
+
+- **iOS or macOS permissions not granted.** The app prompts the user for local network access on first run; declining blocks WebRTC. Verify the `Info.plist` entries are present on both `ios/Runner/Info.plist` and `macos/Runner/Info.plist` if you target macOS.
+- **Android minimum SDK too low.** The Viam Flutter SDK requires Android SDK 23 or later. Raise `minSdkVersion` in `android/app/build.gradle`.
+- **`.env` not bundled.** Confirm `.env` is listed under `flutter.assets` in `pubspec.yaml` and that the file exists at the project root.
+- **Credentials wrong.** Compare the three values in `.env` to the **CONNECT** tab output.
+
+## Next
+
+- [Connect to a machine](/build-apps/tasks/connect-to-machine/) for the connection patterns your app will actually use, including the `Viam` class for multi-machine access
+- [Handle disconnection and reconnection](/build-apps/tasks/handle-connection-state/) for reconnection and UI indicators
+- [The Flutter SDK reference](https://flutter.viam.dev/) for per-component API details and widget documentation
diff --git a/docs/build-apps/setup/go.md b/docs/build-apps/setup/go.md
new file mode 100644
index 0000000000..680d0785e9
--- /dev/null
+++ b/docs/build-apps/setup/go.md
@@ -0,0 +1,116 @@
+---
+linkTitle: "Go setup"
+title: "Go setup"
+weight: 60
+layout: "docs"
+type: "docs"
+description: "Set up a project for writing a Viam app in Go: a backend service, a fleet orchestrator, a CLI tool, or any other Go program that talks to a Viam machine."
+date: "2026-04-13"
+---
+
+Set up a project for writing a Viam app in Go: a backend service, a fleet orchestrator, a CLI tool, or any other Go program that talks to a Viam machine. The Go client lives in the RDK package at `go.viam.com/rdk/robot/client`, not in a separate SDK. For the connection patterns your app will actually use, see [Connect to a machine](/build-apps/tasks/connect-to-machine/).
+
+## Prerequisites
+
+- Go 1.21 or later
+- A configured Viam machine
+- The machine's address, an API key, and an API key ID
+
+Get the three credentials from the machine's **CONNECT** tab in the Viam app: go to the machine's page, click **CONNECT**, select **Golang**, and toggle **Include API key** on. Copy the address, API key, and API key ID from the generated code sample.
+
+## Create a project
+
+```sh {class="command-line" data-prompt="$"}
+mkdir my-viam-app
+cd my-viam-app
+go mod init my-viam-app
+```
+
+## Install the client package
+
+```sh {class="command-line" data-prompt="$"}
+go get go.viam.com/rdk/robot/client
+```
+
+This pulls the RDK client package and its dependencies. After writing the code below, run `go mod tidy` to clean up the module file.
+
+## Verify the connection
+
+Create `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "os"
+
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/utils/rpc"
+)
+
+func main() {
+    logger := logging.NewDebugLogger("client")
+
+    address := os.Getenv("MACHINE_ADDRESS")
+    apiKeyID := os.Getenv("API_KEY_ID")
+    apiKey := os.Getenv("API_KEY")
+
+    machine, err := client.New(
+        context.Background(),
+        address,
+        logger,
+        client.WithDialOptions(rpc.WithEntityCredentials(
+            apiKeyID,
+            rpc.Credentials{
+                Type:    "api-key",
+                Payload: apiKey,
+            },
+        )),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer machine.Close(context.Background())
+
+    fmt.Printf("Connected. Found %d resources.\n", len(machine.ResourceNames()))
+}
+```
+
+Run `go mod tidy` to resolve dependencies, then run with your credentials:
+
+```sh {class="command-line" data-prompt="$"}
+go mod tidy
+MACHINE_ADDRESS=my-robot-main.xxxx.viam.cloud \
+  API_KEY_ID=your-api-key-id \
+  API_KEY=your-api-key-secret \
+  go run main.go
+```
+
+You should see:
+
+```text
+Connected. Found N resources.
+```
+
+where `N` is the number of components and services on your machine.
+
+Always call `machine.Close(ctx)` when done (or use `defer` as shown above) to release the connection cleanly.
+
+## Credentials in production
+
+The example above reads credentials from environment variables set inline on the command line. For a deployed service, set environment variables through your deployment platform (systemd unit file, Kubernetes secret, Docker Compose `.env`, or similar) rather than passing them on the command line.
+
+## Troubleshooting
+
+- **`go mod tidy` errors.** The RDK has many transitive dependencies. If `go mod tidy` fails with version conflicts, check that your Go version is 1.21 or later and that you are not inside another module's directory.
+- **Connection hangs or times out.** Verify the machine address matches the **CONNECT** tab exactly. Verify the machine is online in the Viam app.
+- **Credentials wrong.** The `rpc.WithEntityCredentials` call takes the API key ID as the first argument and the API key secret as `Payload`. Reversing them causes an authentication failure with a generic error message.
+
+## Next
+
+- [Connect to a machine](/build-apps/tasks/connect-to-machine/) for the connection patterns your app will actually use
+- [Handle disconnection and reconnection](/build-apps/tasks/handle-connection-state/) for reconnection and status indicators
+- [Go SDK reference](https://pkg.go.dev/go.viam.com/rdk) for per-component API details
diff --git a/docs/build-apps/setup/node.md b/docs/build-apps/setup/node.md
new file mode 100644
index 0000000000..2a995f04f0
--- /dev/null
+++ b/docs/build-apps/setup/node.md
@@ -0,0 +1,159 @@
+---
+linkTitle: "Node.js setup"
+title: "Node.js setup"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "Set up a project for running Viam SDK code from a Node.js process: a backend service, a CLI tool, or another Node app that talks to a Viam machine."
+date: "2026-04-10"
+---
+
+Set up a project for running Viam SDK code from a Node.js process: a backend service that supports a web app frontend, a CLI tool, or another Node app that talks to a Viam machine. Node.js requires extra setup compared to the browser because Node does not provide WebRTC natively: you register a WebRTC polyfill and plug in a Node-compatible gRPC transport before calling any SDK function. For the connection patterns your app will actually use, see [Connect to a machine](/build-apps/tasks/connect-to-machine/).
+
+## Prerequisites
+
+- Node.js 20 or later
+- A configured Viam machine
+- The machine's host address, an API key, and an API key ID
+
+Get the three credentials from the machine's **CONNECT** tab in the Viam app: go to the machine's page, click **CONNECT**, select **TypeScript**, and toggle **Include API key** on. Copy the `host`, `authEntity` (API key ID), and `payload` (API key) from the generated code sample.
+
+## Create a project
+
+```sh {class="command-line" data-prompt="$"}
+mkdir my-viam-node-app
+cd my-viam-node-app
+npm init -y
+```
+
+## Install the SDK and dependencies
+
+Node.js needs three runtime packages:
+
+- `@viamrobotics/sdk` — the Viam SDK
+- `@connectrpc/connect-node` — the Node-compatible gRPC transport
+- `node-datachannel` — a WebRTC implementation for Node
+
+Install everything at once:
+
+```sh {class="command-line" data-prompt="$"}
+npm install @viamrobotics/sdk @connectrpc/connect-node node-datachannel
+npm install --save-dev tsx typescript @types/node
+```
+
+`tsx` runs TypeScript files directly and loads `.env` files, so you do not need a separate build step or env loader.
+
+## Configure environment variables
+
+Create a `.env` file in your project root:
+
+```text
+HOST=my-robot-main.xxxx.viam.cloud
+API_KEY_ID=your-api-key-id
+API_KEY=your-api-key-secret
+```
+
+Replace the three values with what you copied from the **CONNECT** tab.
+
+Add `.env` to your `.gitignore`:
+
+```sh {class="command-line" data-prompt="$"}
+echo ".env" >> .gitignore
+```
+
+## Verify the connection
+
+Create `src/main.ts`:
+
+```ts
+const VIAM = require("@viamrobotics/sdk");
+const wrtc = require("node-datachannel/polyfill");
+const connectNode = require("@connectrpc/connect-node");
+
+// Register a Node-compatible gRPC transport.
+// @ts-expect-error -- globalThis.VIAM is not in standard types
+globalThis.VIAM = {
+  GRPC_TRANSPORT_FACTORY: (opts: any) =>
+    connectNode.createGrpcTransport({ httpVersion: "2", ...opts }),
+};
+
+// Register WebRTC polyfills on the global object.
+for (const key in wrtc) {
+  (global as any)[key] = (wrtc as any)[key];
+}
+
+async function main() {
+  const host = process.env.HOST;
+  const apiKeyId = process.env.API_KEY_ID;
+  const apiKey = process.env.API_KEY;
+
+  if (!host || !apiKeyId || !apiKey) {
+    throw new Error("HOST, API_KEY_ID, and API_KEY must all be set in .env");
+  }
+
+  const machine = await VIAM.createRobotClient({
+    host,
+    credentials: {
+      type: "api-key",
+      authEntity: apiKeyId,
+      payload: apiKey,
+    },
+    signalingAddress: "https://app.viam.com:443",
+  });
+
+  const resources = await machine.resourceNames();
+  console.log(`Connected. Found ${resources.length} resources.`);
+  process.exit(0);
+}
+
+main().catch((err) => {
+  console.error("Connection failed:", err);
+  process.exit(1);
+});
+```
+
+Two blocks in this file are specific to Node.js and do not appear in a browser app:
+
+**The WebRTC polyfill loop.** The SDK expects browser WebRTC APIs (`RTCPeerConnection`, `RTCDataChannel`, and so on) on the global object. Node does not provide these natively, so `node-datachannel/polyfill` installs them before any SDK code runs.
+
+**The custom gRPC transport factory.** The SDK's default gRPC transport targets browsers. Node needs an HTTP/2 transport, which is what `@connectrpc/connect-node`'s `createGrpcTransport` provides. The `globalThis.VIAM.GRPC_TRANSPORT_FACTORY` hook lets you plug in an alternative transport.
+
+Both must run before any SDK function is called. If you move them to a separate module or import them later, the SDK will fail to connect.
+
+## Run the script
+
+Add a `start` script to `package.json`:
+
+```json
+{
+  "scripts": {
+    "start": "tsx --env-file=.env src/main.ts"
+  }
+}
+```
+
+Run it:
+
+```sh {class="command-line" data-prompt="$"}
+npm start
+```
+
+You should see:
+
+```text
+Connected. Found N resources.
+```
+
+where `N` is the number of components and services on your machine.
+
+If the script hangs or errors, the most common causes are:
+
+- **Polyfills registered too late.** The polyfill loop and transport factory must run before the first call into the SDK. If you split them into a separate module that is imported after the SDK, the SDK initializes without them.
+- **`.env` not loaded.** The `tsx --env-file=.env` flag loads the file. If you run the script a different way (`node`, `ts-node`, a bundler), use `dotenv` or your runtime's env loader instead.
+- **Wrong transport.** If you see `Unsupported HTTP version` or similar, confirm that `@connectrpc/connect-node` is installed and the transport factory is registered on `globalThis.VIAM`.
+
+## Next
+
+- [Connect to a machine](/build-apps/tasks/connect-to-machine/) for the connection patterns your app will actually use
+- [Handle disconnection and reconnection](/build-apps/tasks/handle-connection-state/) for reconnection and UI indicators
+- [The SDK's `Node.md`](https://github.com/viamrobotics/viam-typescript-sdk/blob/main/Node.md) for deeper detail on the polyfill and transport setup
diff --git a/docs/build-apps/setup/overview.md b/docs/build-apps/setup/overview.md
new file mode 100644
index 0000000000..5ea9ba59f9
--- /dev/null
+++ b/docs/build-apps/setup/overview.md
@@ -0,0 +1,43 @@
+---
+linkTitle: "Overview"
+title: "App scaffolding"
+weight: 1
+layout: "docs"
+type: "docs"
+description: "The pattern every Viam app project follows: create a project, install the SDK, configure credentials, and verify the connection."
+date: "2026-04-13"
+---
+
+Every Viam app follows the same scaffolding pattern regardless of language. The per-language pages in this section walk through each step for a specific SDK, but the shape is always the same:
+
+1. **Create a project.** Set up a directory with the build tooling for your language: `npm init` for TypeScript, `flutter create` for Flutter, `go mod init` for Go, a virtual environment for Python, a CMake project for C++.
+2. **Add the Viam SDK as a dependency.** Each language has its own package manager and package name: `npm install @viamrobotics/sdk` for TypeScript, `flutter pub add viam_sdk` for Flutter, `pip install viam-sdk` for Python, `go get go.viam.com/rdk/robot/client` for Go, and a CMake `find_package` for C++. Some platforms need additional dependencies (WebRTC polyfills for Node.js, platform permissions for iOS and Android).
+3. **Configure credentials.** Store your machine's address, API key, and API key ID in environment variables or a `.env` file. Never commit credentials to source control.
+4. **Write a connection verification.** A short program that connects to your machine and prints the resource count. This confirms the SDK is installed correctly, credentials are valid, and the connection works.
+5. **Run it.** Execute the program and confirm you see `Connected. Found N resources.` If you do, the scaffold is complete and you can start writing your app.
+
+After scaffolding, the next step is [Connect to a machine](/build-apps/tasks/connect-to-machine/) for the connection patterns your app will actually use, or one of the [tutorials](/build-apps/app-tutorials/tutorial-dashboard/) for a guided project.
+
+## Pick your language
+
+| Language             | Page                                                  | Notes                                                                                                                                                   |
+| -------------------- | ----------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TypeScript (browser) | [TypeScript setup](/build-apps/setup/typescript/)     | Web app: dashboards, operator interfaces, any browser-based app. The setup page uses Vite; any bundler that handles TypeScript and ESM works.           |
+| TypeScript (Node.js) | [Node.js setup](/build-apps/setup/node/)              | Node process for backend services and CLI tools. Requires WebRTC polyfills and a custom gRPC transport.                                                 |
+| Flutter              | [Flutter setup](/build-apps/setup/flutter/)           | Cross-platform project for iOS, Android, and desktop. Includes iOS/Android platform configuration.                                                      |
+| React Native         | [React Native setup](/build-apps/setup/react-native/) | Mobile project for teams with existing React Native codebases. Requires six polyfill packages and a custom transport. For new projects, prefer Flutter. |
+| Python               | [Python setup](/build-apps/setup/python/)             | Virtual environment for scripts, services, and backend integrations                                                                                     |
+| Go                   | [Go setup](/build-apps/setup/go/)                     | Go module for backend services, fleet orchestrators, and CLI tools                                                                                      |
+| C++                  | [C++ setup](/build-apps/setup/cpp/)                   | CMake project for embedded and high-performance apps. Requires system-level dependencies (Boost, gRPC, protobuf).                                       |
+
+## Where credentials come from
+
+Every scaffolding page asks for three values: the machine's address, an API key, and an API key ID. Get all three from the same place:
+
+1. Go to the machine's page in the Viam app.
+2. Click the **CONNECT** tab.
+3. Select the language tab that matches the page you are following.
+4. Toggle **Include API key** on.
+5. Copy the address, API key ID, and API key from the generated code sample.
+
+For apps that access multiple machines or the Viam cloud APIs, use an organization-scoped or location-scoped API key instead of a machine-scoped one. Create these in [Admin and access](/organization/access/).
diff --git a/docs/build-apps/setup/python.md b/docs/build-apps/setup/python.md
new file mode 100644
index 0000000000..bb73e2d52f
--- /dev/null
+++ b/docs/build-apps/setup/python.md
@@ -0,0 +1,126 @@
+---
+linkTitle: "Python setup"
+title: "Python setup"
+weight: 50
+layout: "docs"
+type: "docs"
+description: "Set up a project for writing a Viam app in Python: a control script, a backend service, a data pipeline, or any other Python program that talks to a Viam machine."
+date: "2026-04-13"
+---
+
+Set up a project for writing a Viam app in Python: a control script, a backend service, a data pipeline, or any other Python program that talks to a Viam machine. For the connection patterns your app will actually use, see [Connect to a machine](/build-apps/tasks/connect-to-machine/).
+
+## Prerequisites
+
+- Python 3.9 or later
+- A configured Viam machine
+- The machine's address, an API key, and an API key ID
+
+Get the three credentials from the machine's **CONNECT** tab in the Viam app: go to the machine's page, click **CONNECT**, select **Python**, and toggle **Include API key** on. Copy the address, API key, and API key ID from the generated code sample.
+
+## Create a project
+
+Create a directory for your project and set up a virtual environment:
+
+```sh {class="command-line" data-prompt="$"}
+mkdir my-viam-app
+cd my-viam-app
+python3 -m venv .venv
+source .venv/bin/activate
+```
+
+## Install the SDK
+
+```sh {class="command-line" data-prompt="$"}
+pip install viam-sdk
+```
+
+Pre-built binaries are available for macOS (Intel and Apple Silicon) and Linux (x86_64, aarch64, armv6l). On Windows, WebRTC is not supported natively; use WSL or connect with `disable_webrtc=True` in the dial options.
+
+If you need the ML model service, install with the optional dependency:
+
+```sh {class="command-line" data-prompt="$"}
+pip install 'viam-sdk[mlmodel]'
+```
+
+## Configure credentials
+
+Create a `.env` file in your project root:
+
+```text
+MACHINE_ADDRESS=my-robot-main.xxxx.viam.cloud
+API_KEY_ID=your-api-key-id
+API_KEY=your-api-key-secret
+```
+
+Replace the three values with what you copied from the **CONNECT** tab.
+
+Add `.env` to your `.gitignore`:
+
+```sh {class="command-line" data-prompt="$"}
+echo ".env" >> .gitignore
+```
+
+Install `python-dotenv` to load the file:
+
+```sh {class="command-line" data-prompt="$"}
+pip install python-dotenv
+```
+
+## Verify the connection
+
+Create `main.py`:
+
+```python
+import asyncio
+import os
+
+from dotenv import load_dotenv
+from viam.robot.client import RobotClient
+
+load_dotenv()
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key=os.environ["API_KEY"],
+        api_key_id=os.environ["API_KEY_ID"],
+    )
+    machine = await RobotClient.at_address(os.environ["MACHINE_ADDRESS"], opts)
+
+    print(f"Connected. Found {len(machine.resource_names)} resources.")
+
+    await machine.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```sh {class="command-line" data-prompt="$"}
+python main.py
+```
+
+You should see:
+
+```text
+Connected. Found N resources.
+```
+
+where `N` is the number of components and services on your machine.
+
+All Viam Python SDK methods are async. Your app code runs inside `asyncio.run()` and uses `await` for every SDK call. Always call `machine.close()` when done to release the connection.
+
+## Troubleshooting
+
+- **`ModuleNotFoundError: No module named 'viam'`.** Confirm the virtual environment is activated (`source .venv/bin/activate`) and that you installed the SDK inside it.
+- **Connection hangs on Windows.** WebRTC is not supported on native Windows. Either use WSL, or pass `disable_webrtc=True` in your `DialOptions` to fall back to direct gRPC.
+- **Credentials wrong.** Compare the three values in `.env` to the **CONNECT** tab output.
+
+## Next
+
+- [Connect to a machine](/build-apps/tasks/connect-to-machine/) for the connection patterns your app will actually use
+- [Handle disconnection and reconnection](/build-apps/tasks/handle-connection-state/) for reconnection and status indicators
+- [The Python SDK reference](https://python.viam.dev/) for per-component API details
diff --git a/docs/build-apps/setup/react-native.md b/docs/build-apps/setup/react-native.md
new file mode 100644
index 0000000000..9468b20906
--- /dev/null
+++ b/docs/build-apps/setup/react-native.md
@@ -0,0 +1,202 @@
+---
+linkTitle: "React Native setup"
+title: "React Native setup"
+weight: 40
+layout: "docs"
+type: "docs"
+description: "Set up a project for building a Viam mobile app using React Native specifically. For new cross-platform apps, prefer Flutter."
+date: "2026-04-10"
+---
+
+Set up a project for building a Viam mobile app using React Native specifically. **If you do not already have a React Native codebase, prefer [Flutter](/build-apps/setup/flutter/) for new cross-platform apps; React Native is here for teams whose existing apps are React Native.** This page covers the project scaffolding, the Viam SDK install, six runtime polyfill packages, a custom XHR-based gRPC transport, a Metro bundler configuration fix for a dependency version conflict, and platform permissions on Android and iOS. For the connection patterns your app will actually use, see [Connect to a machine](/build-apps/tasks/connect-to-machine/).
+
+{{< alert title="Expo is not supported" color="caution" >}}
+The Viam TypeScript SDK does not work with Expo (neither Expo Go nor development builds). You must use the React Native CLI. If your project uses Expo, you cannot add the Viam SDK without ejecting to a bare workflow.
+{{< /alert >}}
+
+## Prerequisites
+
+- The React Native CLI environment for your development platform ([React Native environment setup](https://reactnative.dev/docs/environment-setup))
+- Xcode for iOS targets, Android Studio for Android targets
+- A configured Viam machine
+- The machine's address, an API key, and an API key ID
+
+Get the credentials from the machine's **CONNECT** tab in the Viam app. Click **CONNECT**, select **TypeScript**, toggle **Include API key** on, and copy the `host`, `authEntity`, and `payload` values.
+
+## Create a project
+
+```sh {class="command-line" data-prompt="$"}
+npx @react-native-community/cli@latest init MyViamApp
+cd MyViamApp
+```
+
+## Install the SDK and dependencies
+
+The Viam SDK needs six runtime packages in addition to itself:
+
+```sh {class="command-line" data-prompt="$"}
+npm install @viamrobotics/sdk \
+  fast-text-encoding \
+  react-native-fast-encoder \
+  react-native-fetch-api \
+  react-native-url-polyfill \
+  react-native-webrtc \
+  web-streams-polyfill
+```
+
+After the install completes, run `pod install` for iOS:
+
+```sh {class="command-line" data-prompt="$"}
+cd ios && pod install && cd ..
+```
+
+## Add polyfill files
+
+The SDK expects browser-style globals (`TextEncoder`, `fetch`, `Headers`, `Request`, `Response`, `ReadableStream`, WebRTC APIs) that React Native does not provide natively. The polyfill files from the SDK example repo register these globals before the SDK initializes.
+
+Create `polyfills.native.ts` in your project root with the contents from the [SDK example's `polyfills.native.ts`](https://github.com/viamrobotics/viam-typescript-sdk/blob/main/examples/react-native/polyfills.native.ts). The file is stable and you can copy it as-is.
+
+Also create `polyfills.ts` (no-op fallback for web builds) with the contents from [the SDK example's `polyfills.ts`](https://github.com/viamrobotics/viam-typescript-sdk/blob/main/examples/react-native/polyfills.ts).
+
+## Add the custom gRPC transport
+
+React Native's `fetch` does not support the streaming and binary-body semantics that Connect's default gRPC-web transport requires. The SDK example provides an XHR-based transport that works around this. Copy it from the SDK example:
+
+Create `transport.ts` in your project root with the contents from [the SDK example's `transport.ts`](https://github.com/viamrobotics/viam-typescript-sdk/blob/main/examples/react-native/transport.ts). Do not modify it. The transport implementation is verbose (roughly 350 lines) and stable; treating it as a copy-and-forget dependency is the intended approach.
+
+## Update metro.config.js
+
+`react-native` and `react-native-webrtc` depend on conflicting versions of `event-target-shim`. Metro's default resolver picks the wrong one, which causes runtime errors. Tell Metro to resolve `event-target-shim` inside `react-native-webrtc` using its own nested version:
+
+```js
+const { getDefaultConfig } = require("@react-native/metro-config");
+const resolveFrom = require("resolve-from");
+
+const config = getDefaultConfig(__dirname);
+
+config.resolver.resolveRequest = (context, moduleName, platform) => {
+  if (
+    moduleName.startsWith("event-target-shim") &&
+    context.originModulePath.includes("react-native-webrtc")
+  ) {
+    return {
+      filePath: resolveFrom(context.originModulePath, moduleName),
+      type: "sourceFile",
+    };
+  }
+  return context.resolveRequest(context, moduleName, platform);
+};
+
+module.exports = config;
+```
+
+Save this as `metro.config.js` in your project root, replacing whatever `react-native init` generated.
+
+## Add Android permission
+
+React Native apps targeting Android need the `ACCESS_NETWORK_STATE` permission for WebRTC. Add it to `android/app/src/main/AndroidManifest.xml` inside the top-level `<manifest>` element:
+
+```xml
+<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+```
+
+## Register polyfills and transport in App.tsx
+
+Replace the contents of `App.tsx` with:
+
+```tsx
+import * as VIAM from "@viamrobotics/sdk";
+import { polyfills } from "./polyfills";
+polyfills();
+
+import { GrpcWebTransportOptions } from "@connectrpc/connect-web";
+import { createXHRGrpcWebTransport } from "./transport";
+
+// @ts-expect-error -- globalThis.VIAM is not in standard types
+globalThis.VIAM = {
+  GRPC_TRANSPORT_FACTORY: (opts: GrpcWebTransportOptions) => {
+    return createXHRGrpcWebTransport(opts);
+  },
+};
+
+import React, { useEffect, useState } from "react";
+import { SafeAreaView, Text, StyleSheet } from "react-native";
+
+// Replace these with the values from your machine's CONNECT tab.
+// For a production app, use react-native-config or a secure store
+// instead of hardcoding credentials in source.
+const HOST = "my-robot-main.xxxx.viam.cloud";
+const API_KEY_ID = "your-api-key-id";
+const API_KEY = "your-api-key-secret";
+
+function App(): React.JSX.Element {
+  const [status, setStatus] = useState("Connecting...");
+
+  useEffect(() => {
+    async function connect() {
+      try {
+        const machine = await VIAM.createRobotClient({
+          host: HOST,
+          credentials: {
+            type: "api-key",
+            authEntity: API_KEY_ID,
+            payload: API_KEY,
+          },
+          signalingAddress: "https://app.viam.com:443",
+        });
+        const resources = await machine.resourceNames();
+        setStatus(`Connected. Found ${resources.length} resources.`);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        setStatus(`Connection failed: ${msg}`);
+      }
+    }
+    connect();
+  }, []);
+
+  return (
+    <SafeAreaView style={styles.container}>
+      <Text style={styles.text}>{status}</Text>
+    </SafeAreaView>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: { flex: 1, justifyContent: "center", alignItems: "center" },
+  text: { fontSize: 18 },
+});
+
+export default App;
+```
+
+**The order of imports in this file matters.** The polyfills and the transport factory assignment must run before any SDK call. If you move the `polyfills()` call or the `globalThis.VIAM` assignment below the React imports, or import any SDK submodule before them, the SDK will fail to initialize.
+
+## Run the app
+
+```sh {class="command-line" data-prompt="$"}
+npm run ios
+# or
+npm run android
+```
+
+The app builds, launches on the selected simulator or device, and shows:
+
+```text
+Connected. Found N resources.
+```
+
+where `N` is the number of components and services on your machine.
+
+If you see `Connection failed:`, the most common causes are:
+
+- **Polyfills imported out of order.** The `polyfills()` call and the `globalThis.VIAM` assignment must appear before any other code that touches the SDK, including React imports if you reference SDK types in them.
+- **`metro.config.js` not applied.** Metro caches aggressively. Stop the Metro bundler and run `npm start -- --reset-cache` after editing `metro.config.js`.
+- **Android permission missing.** Confirm `ACCESS_NETWORK_STATE` is in `AndroidManifest.xml` and rebuild the Android app.
+- **iOS pods out of date.** Run `cd ios && pod install && cd ..` again after any native dependency change.
+- **Using Expo.** If you started from an Expo project, none of this setup will work. You must use a bare React Native project.
+
+## Next
+
+- [Connect to a machine](/build-apps/tasks/connect-to-machine/) for the connection patterns your app will actually use
+- [Handle disconnection and reconnection](/build-apps/tasks/handle-connection-state/) for reconnection and UI indicators
+- [The SDK's `ReactNative.md`](https://github.com/viamrobotics/viam-typescript-sdk/blob/main/ReactNative.md) for deeper detail on the polyfills, the transport, and the Android environment variables needed for the Android build
diff --git a/docs/build-apps/setup/typescript.md b/docs/build-apps/setup/typescript.md
new file mode 100644
index 0000000000..e8f19189e0
--- /dev/null
+++ b/docs/build-apps/setup/typescript.md
@@ -0,0 +1,138 @@
+---
+linkTitle: "TypeScript setup"
+title: "TypeScript setup"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Set up a project for building a Viam web app with TypeScript: a custom dashboard, an operator interface, or any other browser-based app that talks to a Viam machine."
+date: "2026-04-10"
+---
+
+Set up a project for building a Viam web app with TypeScript: a custom dashboard, an operator interface, or any other browser-based app that talks to a Viam machine. This page covers the project scaffolding with [Vite](https://vitejs.dev/) and the Viam TypeScript SDK install. For the connection patterns your app will actually use, see [Connect to a machine](/build-apps/tasks/connect-to-machine/).
+
+## Prerequisites
+
+- Node.js 20 or later
+- A configured Viam machine
+- The machine's host address, an API key, and an API key ID
+
+Get all three credentials from the machine's **CONNECT** tab in the Viam app: go to the machine's page, click **CONNECT**, select **TypeScript**, and toggle **Include API key** on. Copy the `host`, `authEntity` (the API key ID), and `payload` (the API key) from the generated code sample.
+
+## Create a project
+
+Create a directory for your project and initialize `package.json`.
+
+```sh {class="command-line" data-prompt="$"}
+mkdir my-viam-app
+cd my-viam-app
+npm init -y
+```
+
+Open `package.json` and add `"type": "module"` so Node treats `.js` files as ES modules:
+
+```json
+{
+  "name": "my-viam-app",
+  "type": "module",
+  "version": "1.0.0"
+}
+```
+
+## Install the SDK and Vite
+
+```sh {class="command-line" data-prompt="$"}
+npm install @viamrobotics/sdk
+npm install --save-dev vite typescript
+```
+
+## Configure environment variables
+
+Create a `.env` file in your project root:
+
+```text
+VITE_HOST=my-robot-main.xxxx.viam.cloud
+VITE_API_KEY_ID=your-api-key-id
+VITE_API_KEY=your-api-key-secret
+```
+
+Replace the three values with what you copied from the **CONNECT** tab. Vite exposes environment variables prefixed with `VITE_` to browser code through `import.meta.env`. See [the Vite env docs](https://vitejs.dev/guide/env-and-mode.html) for details.
+
+Add `.env` to your `.gitignore` so you do not accidentally commit credentials:
+
+```sh {class="command-line" data-prompt="$"}
+echo ".env" >> .gitignore
+```
+
+## Create the HTML entry point
+
+Create `index.html` in your project root:
+
+```html
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <title>My Viam App</title>
+  </head>
+  <body>
+    <div id="status"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
+```
+
+## Verify the connection
+
+Create `src/main.ts`:
+
+```ts
+import * as VIAM from "@viamrobotics/sdk";
+
+const statusEl = document.getElementById("status") as HTMLDivElement;
+
+async function main() {
+  statusEl.textContent = "Connecting...";
+  try {
+    const machine = await VIAM.createRobotClient({
+      host: import.meta.env.VITE_HOST,
+      credentials: {
+        type: "api-key",
+        authEntity: import.meta.env.VITE_API_KEY_ID,
+        payload: import.meta.env.VITE_API_KEY,
+      },
+      signalingAddress: "https://app.viam.com:443",
+    });
+    const resources = await machine.resourceNames();
+    statusEl.textContent = `Connected. Found ${resources.length} resources.`;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    statusEl.textContent = `Connection failed: ${msg}`;
+  }
+}
+
+main();
+```
+
+This connects to your machine, fetches the list of configured resources, and shows the count in the page.
+
+## Run the dev server
+
+```sh {class="command-line" data-prompt="$"}
+npx vite
+```
+
+Vite prints a local URL, typically `http://localhost:5173`. Open it in a browser. You should see:
+
+```text
+Connected. Found N resources.
+```
+
+where `N` is the number of components and services configured on your machine. If the page shows `Connection failed:` followed by an error, check that the three values in your `.env` file match the **CONNECT** tab exactly, including the `https://` in the host if the generated sample includes one.
+
+If you use Firefox for development, see the [Firefox WebRTC localhost workaround](/build-apps/tasks/test-locally/#firefox-webrtc-localhost-workaround) on the Test against a local machine page. Firefox blocks WebRTC connections from `localhost`, so you need a small `/etc/hosts` adjustment to develop locally.
+
+## Next
+
+- [Connect to a machine](/build-apps/tasks/connect-to-machine/) for the connection patterns your app will actually use, including language tabs for Flutter
+- [Handle disconnection and reconnection](/build-apps/tasks/handle-connection-state/) for reconnection and UI indicators
+- [Stream video](/build-apps/tasks/stream-video/) for displaying camera feeds
diff --git a/docs/build-apps/tasks/_index.md b/docs/build-apps/tasks/_index.md
new file mode 100644
index 0000000000..fac7beb412
--- /dev/null
+++ b/docs/build-apps/tasks/_index.md
@@ -0,0 +1,11 @@
+---
+linkTitle: "Common tasks"
+title: "Common tasks"
+weight: 30
+layout: "docs"
+type: "docs"
+no_list: true
+manualLink: "/build-apps/tasks/connect-to-machine/"
+description: "Connect to machines, stream video, query data, handle disconnections, and test locally."
+date: "2026-04-13"
+---
diff --git a/docs/build-apps/tasks/connect-to-cloud.md b/docs/build-apps/tasks/connect-to-cloud.md
new file mode 100644
index 0000000000..ee9a5964bf
--- /dev/null
+++ b/docs/build-apps/tasks/connect-to-cloud.md
@@ -0,0 +1,246 @@
+---
+linkTitle: "Connect to the Viam cloud"
+title: "Connect to the Viam cloud"
+weight: 40
+layout: "docs"
+type: "docs"
+description: "Open a connection to the Viam cloud to access the fleet, data, ML training, billing, and provisioning APIs, and to enumerate and connect to multiple machines."
+date: "2026-04-10"
+---
+
+Open a connection to the Viam cloud to access the fleet, data, ML training, billing, and provisioning APIs, and to enumerate and connect to multiple machines from one app. For connecting directly to a single known machine, use [Connect to a machine](/build-apps/tasks/connect-to-machine/) instead.
+
+## When to connect to the cloud
+
+Use the cloud connection when your app needs any of these:
+
+- **Multiple machines.** Your app lets users pick from a fleet, shows status across many devices, or connects to different machines based on user input.
+- **Machine discovery.** Your app does not know the machine address ahead of time and needs to list machines from an organization or location.
+- **Captured data queries.** Your app queries sensor or binary data with SQL or MQL (see [Query captured data](/build-apps/tasks/query-data/)).
+- **Fleet management.** Your app creates or manages machines, API keys, locations, or fragments programmatically.
+- **Custom provisioning.** Your app onboards new machines through the provisioning service (see [Provision devices](/fleet/provision-devices/)).
+- **Billing or ML training.** Your app reads billing information or launches ML training jobs.
+
+If your app only talks to one machine whose address you already know, skip this page and use [Connect to a machine](/build-apps/tasks/connect-to-machine/) directly.
+
+## Prerequisites
+
+- A project set up with the Viam SDK (see [App scaffolding](/build-apps/setup/))
+- An API key scoped to the organization or location your app needs to access, and its API key ID. Create an API key in [Admin and access](/organization/access/).
+
+## Open a cloud connection
+
+{{< tabs >}}
+{{% tab name="TypeScript" %}}
+
+```ts
+import * as VIAM from "@viamrobotics/sdk";
+
+const client = await VIAM.createViamClient({
+  credentials: {
+    type: "api-key",
+    authEntity: "<API-KEY-ID>",
+    payload: "<API-KEY>",
+  },
+});
+```
+
+`createViamClient` returns a `ViamClient` with five platform-client properties:
+
+| Property                    | Purpose                                                       |
+| --------------------------- | ------------------------------------------------------------- |
+| `client.appClient`          | Organizations, locations, machines, API keys, fragments, RBAC |
+| `client.dataClient`         | Query and upload captured data                                |
+| `client.mlTrainingClient`   | Launch and monitor ML training jobs                           |
+| `client.billingClient`      | Read billing information                                      |
+| `client.provisioningClient` | Device provisioning for custom provisioning apps              |
+
+The default `serviceHost` is `https://app.viam.com`. Override it only if you are pointing at a self-hosted Viam platform.
+
+{{% /tab %}}
+{{% tab name="Flutter" %}}
+
+```dart
+import 'package:viam_sdk/viam_sdk.dart';
+
+final viam = await Viam.withApiKey(
+  'your-api-key-id',
+  'your-api-key-secret',
+);
+```
+
+`Viam.withApiKey` returns a `Viam` instance with five platform-client properties:
+
+| Property                  | Purpose                                                       |
+| ------------------------- | ------------------------------------------------------------- |
+| `viam.appClient`          | Organizations, locations, machines, API keys, fragments, RBAC |
+| `viam.dataClient`         | Query and upload captured data                                |
+| `viam.mlTrainingClient`   | Launch and monitor ML training jobs                           |
+| `viam.billingClient`      | Read billing information                                      |
+| `viam.provisioningClient` | Device provisioning for custom provisioning apps              |
+
+The default `serviceHost` is `app.viam.com`. Override it through the optional `serviceHost` parameter if you are pointing at a self-hosted Viam platform.
+
+{{% /tab %}}
+{{% tab name="Python" %}}
+
+```python
+from viam.app.viam_client import ViamClient
+from viam.rpc.dial import DialOptions
+
+
+async def connect():
+    dial_options = DialOptions.with_api_key(
+        api_key='your-api-key-secret',
+        api_key_id='your-api-key-id'
+    )
+    return await ViamClient.create_from_dial_options(dial_options)
+
+
+client = await connect()
+```
+
+`ViamClient` exposes the same platform clients:
+
+| Property                     | Purpose                                                       |
+| ---------------------------- | ------------------------------------------------------------- |
+| `client.app_client`          | Organizations, locations, machines, API keys, fragments, RBAC |
+| `client.data_client`         | Query and upload captured data                                |
+| `client.ml_training_client`  | Launch and monitor ML training jobs                           |
+| `client.billing_client`      | Read billing information                                      |
+| `client.provisioning_client` | Device provisioning for custom provisioning apps              |
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+import (
+    "context"
+    "go.viam.com/rdk/app"
+    "go.viam.com/rdk/logging"
+)
+
+logger := logging.NewDebugLogger("client")
+client, err := app.CreateViamClientWithAPIKey(
+    context.Background(),
+    app.Options{},
+    "your-api-key-secret",
+    "your-api-key-id",
+    logger,
+)
+if err != nil {
+    logger.Fatal(err)
+}
+```
+
+Access platform clients through methods on `ViamClient`:
+
+| Method                        | Purpose                                                       |
+| ----------------------------- | ------------------------------------------------------------- |
+| `client.AppClient()`          | Organizations, locations, machines, API keys, fragments, RBAC |
+| `client.DataClient()`         | Query and upload captured data                                |
+| `client.MLTrainingClient()`   | Launch and monitor ML training jobs                           |
+| `client.BillingClient()`      | Read billing information                                      |
+| `client.ProvisioningClient()` | Device provisioning                                           |
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Unlike `RobotClient`, the cloud client does not hold a persistent WebRTC connection. Each method call is a separate request to the Viam cloud. There is no `close()` or `disconnect()` method to call when you are done.
+
+## Enumerate machines
+
+Common pattern: list the organizations a user can access, then list machines in a selected organization.
+
+{{< tabs >}}
+{{% tab name="TypeScript" %}}
+
+```ts
+const orgs = await client.appClient.listOrganizations();
+console.log(`Found ${orgs.length} organizations`);
+
+const orgId = orgs[0].id;
+const summaries = await client.appClient.listMachineSummaries(orgId);
+for (const location of summaries) {
+  console.log(`Location: ${location.locationName}`);
+  for (const machine of location.machines) {
+    console.log(`  ${machine.machineName} (${machine.machineId})`);
+  }
+}
+```
+
+`listMachineSummaries` returns a list of location summaries, each containing the machines in that location. Pass `fragmentIds` to filter to machines that include specific fragments, or `locationIds` to scope to particular locations.
+
+{{% /tab %}}
+{{% tab name="Flutter" %}}
+
+```dart
+final orgs = await viam.appClient.listOrganizations();
+print('Found ${orgs.length} organizations');
+
+final orgId = orgs.first.id;
+final locations = await viam.appClient.listLocations(orgId);
+
+for (final location in locations) {
+  print('Location: ${location.name}');
+  final robots = await viam.appClient.listRobots(location.id);
+  for (final robot in robots) {
+    print('  ${robot.name} (${robot.id})');
+  }
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+See [the fleet API reference](/reference/apis/fleet/) for the full method list on `AppClient`.
+
+## Connect to a machine from the cloud client
+
+Once you have identified a machine, open a `RobotClient` connection to it.
+
+{{< tabs >}}
+{{% tab name="TypeScript" %}}
+
+```ts
+const machine = await client.connectToMachine({
+  id: "abc-123-def-456",
+});
+```
+
+`connectToMachine` accepts either `{ host: "..." }` with the machine's FQDN or `{ id: "..." }` with the machine's UUID. It returns a `RobotClient` that behaves the same as one created by `createRobotClient`.
+
+Note that `connectToMachine` uses `reconnectMaxAttempts: 1` instead of the default of 10. If you need the standard reconnection behavior, call `createRobotClient` directly with the host and credentials you obtained from the cloud client.
+
+{{% /tab %}}
+{{% tab name="Flutter" %}}
+
+```dart
+final locations = await viam.appClient.listLocations(orgId);
+final location = locations.first;
+final robots = await viam.appClient.listRobots(location.id);
+final robot = robots.first;
+
+final robotClient = await viam.getRobotClient(robot);
+```
+
+`getRobotClient` takes a `Robot` object (returned from `appClient.listRobots` or `appClient.getRobot`) and returns a `RobotClient` connected to the machine's main part.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Close the `RobotClient` when your app is done with the machine. See [Connect to a machine](/build-apps/tasks/connect-to-machine/) for the close pattern and for error handling.
+
+## Handle errors
+
+API key errors, network failures, and missing permissions all raise errors from `createViamClient` or `Viam.withApiKey`. Wrap the call in a try-catch the same way you would for a machine connection. The cloud client does not distinguish credential errors from network errors in its error messages; log the error verbatim when debugging.
+
+If a subsequent `appClient` or `dataClient` call fails because the API key does not have permission for the target resource, the SDK throws an error from that specific call, not from the initial `createViamClient`. Check errors on every cloud method call that accesses resources across organizations or locations.
+
+## Next
+
+- [Query captured data](/build-apps/tasks/query-data/) for using `dataClient` to read sensor and binary data
+- [Handle disconnection and reconnection](/build-apps/tasks/handle-connection-state/) for reconnection behavior on the `RobotClient` instances you get from the cloud connection
+- [Provision devices](/fleet/provision-devices/) for custom provisioning apps that use `provisioningClient`
+- [Fleet API reference](/reference/apis/fleet/) for the full `AppClient` method list
+- [Data API reference](/reference/apis/data-client/) for the full `DataClient` method list
diff --git a/docs/build-apps/tasks/connect-to-machine.md b/docs/build-apps/tasks/connect-to-machine.md
new file mode 100644
index 0000000000..3e34b64346
--- /dev/null
+++ b/docs/build-apps/tasks/connect-to-machine.md
@@ -0,0 +1,248 @@
+---
+linkTitle: "Connect to a machine"
+title: "Connect to a machine"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "Open a connection to a single Viam machine from your app, structure the connection code correctly, and close the connection when your app is done with it."
+date: "2026-04-10"
+---
+
+Open a connection to a single Viam machine from your app, structure the connection code so you do not reconnect unnecessarily, and close the connection when the app is done with it. This page covers the basic connection pattern. For reconnection, UI indicators, and connection-state events, see [Handle disconnection and reconnection](/build-apps/tasks/handle-connection-state/). For apps that access multiple machines or the fleet APIs, see [Connect to the Viam cloud](/build-apps/tasks/connect-to-cloud/).
+
+## Prerequisites
+
+- A project set up with the Viam SDK (see [App scaffolding](/build-apps/setup/))
+- The machine's address, an API key, and an API key ID, copied from the machine's **CONNECT** tab in the Viam app
+
+## Open a connection
+
+{{< tabs >}}
+{{% tab name="TypeScript" %}}
+
+```ts
+import * as VIAM from "@viamrobotics/sdk";
+
+const machine = await VIAM.createRobotClient({
+  host: "my-robot-main.xxxx.viam.cloud",
+  credentials: {
+    type: "api-key",
+    authEntity: "<API-KEY-ID>",
+    payload: "<API-KEY>",
+  },
+  signalingAddress: "https://app.viam.com:443",
+});
+```
+
+`createRobotClient` returns a `RobotClient` connected to your machine. The `await` resolves once the WebRTC connection is established and the session has started.
+
+{{% /tab %}}
+{{% tab name="Flutter" %}}
+
+```dart
+import 'package:viam_sdk/viam_sdk.dart';
+
+final robot = await RobotClient.atAddress(
+  'my-robot-main.xxxx.viam.cloud',
+  RobotClientOptions.withApiKey('your-api-key-id', 'your-api-key-secret'),
+);
+```
+
+`RobotClient.atAddress` returns a `RobotClient` connected to your machine. The `await` resolves once the WebRTC connection is established and the session has started.
+
+{{% /tab %}}
+{{% tab name="Python" %}}
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+
+
+async def connect():
+    opts = RobotClient.Options.with_api_key(
+        api_key='your-api-key-secret',
+        api_key_id='your-api-key-id'
+    )
+    return await RobotClient.at_address('my-robot-main.xxxx.viam.cloud', opts)
+
+
+machine = await connect()
+```
+
+`RobotClient.at_address` is async. All Viam Python SDK methods use `async`/`await` and run inside `asyncio.run()`.
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+import (
+    "context"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/utils/rpc"
+)
+
+logger := logging.NewDebugLogger("client")
+machine, err := client.New(
+    context.Background(),
+    "my-robot-main.xxxx.viam.cloud",
+    logger,
+    client.WithDialOptions(rpc.WithEntityCredentials(
+        "your-api-key-id",
+        rpc.Credentials{
+            Type:    "api-key",
+            Payload: "your-api-key-secret",
+        },
+    )),
+)
+if err != nil {
+    logger.Fatal(err)
+}
+```
+
+`client.New` returns a `*RobotClient` and an error. Always check the error before using the client.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+For an explanation of what the SDK does during connection (WebRTC signaling, ICE, sessions, reconnection), see [Connection model](/build-apps/concepts/how-apps-connect/). The defaults work for machines deployed on Viam Cloud; you override them only for self-hosted or local-network setups.
+
+## Close the connection
+
+Close the connection when your app is done with it. Closing releases resources, ends the session, and stops background reconnection attempts.
+
+{{< tabs >}}
+{{% tab name="TypeScript" %}}
+
+```ts
+await machine.disconnect();
+```
+
+{{% /tab %}}
+{{% tab name="Flutter" %}}
+
+```dart
+await robot.close();
+```
+
+{{% /tab %}}
+{{% tab name="Python" %}}
+
+```python
+await machine.close()
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+machine.Close(context.Background())
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+In a browser app, the tab closing eventually tears down the connection on its own, but closing explicitly avoids a race where pending operations continue after the page unloads. In a Node.js script, always close before `process.exit()` or the script may hang on an open WebRTC connection. In a Flutter app, close in `State.dispose()` if the connection was created per-screen, or in a service class's dispose method if the connection is app-wide.
+
+## Handle errors during connect
+
+Network failures, wrong credentials, and unreachable machines all raise errors from the connect call. Wrap the call in a try-catch:
+
+{{< tabs >}}
+{{% tab name="TypeScript" %}}
+
+```ts
+let machine: VIAM.RobotClient;
+try {
+  machine = await VIAM.createRobotClient({
+    host: "my-robot-main.xxxx.viam.cloud",
+    credentials: {
+      type: "api-key",
+      authEntity: "<API-KEY-ID>",
+      payload: "<API-KEY>",
+    },
+    signalingAddress: "https://app.viam.com:443",
+  });
+} catch (err) {
+  console.error("Failed to connect:", err);
+  return;
+}
+```
+
+{{% /tab %}}
+{{% tab name="Flutter" %}}
+
+```dart
+late RobotClient robot;
+try {
+  robot = await RobotClient.atAddress(
+    'my-robot-main.xxxx.viam.cloud',
+    RobotClientOptions.withApiKey('your-api-key-id', 'your-api-key-secret'),
+  );
+} catch (e) {
+  print('Failed to connect: $e');
+  return;
+}
+```
+
+{{% /tab %}}
+{{% tab name="Python" %}}
+
+```python {class="line-numbers linkable-line-numbers" data-line=""}
+try:
+    opts = RobotClient.Options.with_api_key(
+        api_key='your-api-key-secret',
+        api_key_id='your-api-key-id'
+    )
+    machine = await RobotClient.at_address(
+        'my-robot-main.xxxx.viam.cloud', opts
+    )
+except Exception as e:
+    print(f"Failed to connect: {e}")
+    # In a real app: raise, sys.exit(1), or handle appropriately
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+machine, err := client.New(
+    context.Background(),
+    "my-robot-main.xxxx.viam.cloud",
+    logger,
+    client.WithDialOptions(rpc.WithEntityCredentials(
+        "your-api-key-id",
+        rpc.Credentials{
+            Type:    "api-key",
+            Payload: "your-api-key-secret",
+        },
+    )),
+)
+if err != nil {
+    logger.Fatalf("Failed to connect: %v", err)
+}
+defer machine.Close(context.Background())
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+The error from a failed connect is generic. The SDK does not always distinguish credential errors from network errors. Log the error message verbatim when debugging, and check the **CONNECT** tab in the Viam app to confirm the machine is online before assuming the code is wrong.
+
+Once the connection is established, subsequent network drops trigger automatic reconnection rather than thrown errors. See [Handle disconnection and reconnection](/build-apps/tasks/handle-connection-state/) for the reconnection pattern.
+
+## Where to put connection code
+
+Create the `RobotClient` once at the right lifetime boundary and share it across the parts of your app that need it. Do not call `createRobotClient` or `RobotClient.atAddress` inside a render function or a click handler: each call opens a new connection and orphans the previous one.
+
+- **Browser SPA.** Create the client in your app's root component or in a service module imported at startup. Pass it down through props, context, or a state store. Close once on app unmount.
+- **Node.js script.** Create the client at the top of `main()` and close it before `process.exit()`. For long-running services, keep the client alive and let automatic reconnection handle network drops.
+- **Python script or service.** Create the client at the top of your `main()` coroutine. Use `async with` or call `await machine.close()` in a `finally` block. For long-running services, keep the client alive for the service's lifetime.
+- **Go service.** Create the client at the top of `main()` and `defer machine.Close(ctx)`. For long-running services, keep the client alive and let automatic reconnection handle drops.
+- **Flutter app.** Create the client in `initState` or a service class (Provider, Riverpod, or similar). Dispose in `dispose()`. For apps with multiple screens, put the client in a service class rather than in each screen's state.
+
+## Next
+
+- [Handle disconnection and reconnection](/build-apps/tasks/handle-connection-state/) for reconnection behavior, UI indicators, and connection events
+- [Connect to the Viam cloud](/build-apps/tasks/connect-to-cloud/) for apps that access multiple machines or use the fleet, data, and billing APIs
+- [Stream video](/build-apps/tasks/stream-video/) for displaying camera feeds from your connected machine
diff --git a/docs/build-apps/tasks/control-components.md b/docs/build-apps/tasks/control-components.md
new file mode 100644
index 0000000000..9b56cffb97
--- /dev/null
+++ b/docs/build-apps/tasks/control-components.md
@@ -0,0 +1,228 @@
+---
+linkTitle: "Control components"
+title: "Control components"
+weight: 55
+layout: "docs"
+type: "docs"
+description: "Read from sensors and control motors, arms, and other actuators from your app using the SDK component clients."
+date: "2026-04-13"
+---
+
+Read sensor data and send commands to motors, arms, grippers, and other actuators from your app. Each component type has its own SDK client with methods specific to that type. This page shows the pattern for getting a component client and calling its methods.
+
+For the full list of component types and their methods, see the SDK reference for your language: [TypeScript](https://ts.viam.dev/), [Python](https://python.viam.dev/), [Flutter](https://flutter.viam.dev/), [Go](https://pkg.go.dev/go.viam.com/rdk), or [C++](https://cpp.viam.dev/).
+
+## Prerequisites
+
+- A project with an active machine connection (see [Connect to a machine](/build-apps/tasks/connect-to-machine/))
+- At least one component configured on the machine (sensor, motor, camera, arm, or any other type). If you do not have physical hardware, add a fake component in the Viam app's **CONFIGURE** tab (`fake:sensor`, `fake:motor`, and so on).
+
+## Get a component client
+
+Every component type follows the same pattern: you get a typed client from the connected machine by name, then call methods on that client.
+
+{{< tabs >}}
+{{% tab name="TypeScript" %}}
+
+```ts
+import * as VIAM from "@viamrobotics/sdk";
+
+const sensor = new VIAM.SensorClient(machine, "my_sensor");
+const motor = new VIAM.MotorClient(machine, "my_motor");
+```
+
+In TypeScript, you construct a client by passing the `RobotClient` and the component name.
+
+{{% /tab %}}
+{{% tab name="Flutter" %}}
+
+```dart
+import 'package:viam_sdk/viam_sdk.dart';
+
+final sensor = Sensor.fromRobot(robot, 'my_sensor');
+final motor = Motor.fromRobot(robot, 'my_motor');
+```
+
+In Flutter, each component type has a `fromRobot` factory method.
+
+{{% /tab %}}
+{{% tab name="Python" %}}
+
+```python
+from viam.components.sensor import Sensor
+from viam.components.motor import Motor
+
+sensor = Sensor.from_robot(robot=machine, name="my_sensor")
+motor = Motor.from_robot(robot=machine, name="my_motor")
+```
+
+In Python, each component type has a `from_robot` class method.
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+import (
+    "go.viam.com/rdk/components/sensor"
+    "go.viam.com/rdk/components/motor"
+)
+
+mySensor, err := sensor.FromProvider(machine, "my_sensor")
+if err != nil {
+    logger.Fatal(err)
+}
+
+myMotor, err := motor.FromProvider(machine, "my_motor")
+if err != nil {
+    logger.Fatal(err)
+}
+```
+
+In Go, each component package has a `FromProvider` function that returns the typed interface.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+The string `"my_sensor"` or `"my_motor"` is the name you gave the component in your machine configuration. If you named it something different, change the string to match.
+
+## Read from a sensor
+
+{{< tabs >}}
+{{% tab name="TypeScript" %}}
+
+```ts
+const readings = await sensor.getReadings();
+console.log(readings);
+// Example output: { temperature: 22.5, humidity: 45.2 }
+```
+
+{{% /tab %}}
+{{% tab name="Flutter" %}}
+
+```dart
+final readings = await sensor.readings();
+print(readings);
+// Example output: {temperature: 22.5, humidity: 45.2}
+```
+
+{{% /tab %}}
+{{% tab name="Python" %}}
+
+```python
+readings = await sensor.get_readings()
+print(readings)
+# Example output: {'temperature': 22.5, 'humidity': 45.2}
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+readings, err := mySensor.Readings(context.Background(), nil)
+if err != nil {
+    logger.Fatal(err)
+}
+fmt.Println(readings)
+// Example output: map[temperature:22.5 humidity:45.2]
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+The readings map contains whatever key-value pairs the sensor returns. The keys and types depend on the sensor model. For `fake:sensor`, the readings are generated test values.
+
+## Control a motor
+
+{{< tabs >}}
+{{% tab name="TypeScript" %}}
+
+```ts
+// Set power (range: -1 to 1)
+await motor.setPower(0.5);
+
+// Stop
+await motor.stop();
+
+// Check if moving
+const moving = await motor.isMoving();
+console.log(`Motor is moving: ${moving}`);
+```
+
+{{% /tab %}}
+{{% tab name="Flutter" %}}
+
+```dart
+// Set power (range: -1 to 1)
+await motor.setPower(0.5);
+
+// Stop
+await motor.stop();
+
+// Check if moving
+final moving = await motor.isMoving();
+print('Motor is moving: $moving');
+```
+
+{{% /tab %}}
+{{% tab name="Python" %}}
+
+```python
+# Set power (range: -1 to 1)
+await motor.set_power(power=0.5)
+
+# Stop
+await motor.stop()
+
+# Check if moving
+moving = await motor.is_moving()
+print(f"Motor is moving: {moving}")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+// Set power (range: -1 to 1)
+err = myMotor.SetPower(context.Background(), 0.5, nil)
+if err != nil {
+    logger.Fatal(err)
+}
+
+// Stop
+err = myMotor.Stop(context.Background(), nil)
+if err != nil {
+    logger.Fatal(err)
+}
+
+// Check if moving
+moving, err := myMotor.IsMoving(context.Background())
+if err != nil {
+    logger.Fatal(err)
+}
+fmt.Printf("Motor is moving: %v\n", moving)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+`setPower` takes a value from -1 (full reverse) to 1 (full forward). 0 is stopped. For `fake:motor`, the state changes are tracked internally but nothing physical moves. You can verify the state change by opening the Viam app's **CONTROL** tab for the same machine.
+
+## Other component types
+
+The pattern is the same for every component type. Get a typed client by name, then call that type's methods:
+
+| Component | Get client (Python)                           | Common methods                                                                                   |
+| --------- | --------------------------------------------- | ------------------------------------------------------------------------------------------------ |
+| Arm       | `Arm.from_robot(robot=machine, name="x")`     | `get_end_position`, `move_to_position`, `get_joint_positions`, `move_to_joint_positions`, `stop` |
+| Base      | `Base.from_robot(robot=machine, name="x")`    | `move_straight`, `spin`, `set_power`, `set_velocity`, `stop`                                     |
+| Camera    | `Camera.from_robot(robot=machine, name="x")`  | `get_images`, `get_point_cloud`, `get_properties`                                                |
+| Gripper   | `Gripper.from_robot(robot=machine, name="x")` | `open`, `grab`, `stop`, `is_moving`                                                              |
+| Servo     | `Servo.from_robot(robot=machine, name="x")`   | `move`, `get_position`, `stop`                                                                   |
+
+The method names follow the same naming convention in each language: Python uses `snake_case`, Go uses `CamelCase`, TypeScript uses `camelCase`, Flutter uses `camelCase`. See your SDK's reference for the exact signatures.
+
+## Next
+
+- [Stream video](/build-apps/tasks/stream-video/) for displaying camera feeds (TypeScript and Flutter WebRTC streaming, or `get_images` polling for Python and Go)
+- [Handle disconnection and reconnection](/build-apps/tasks/handle-connection-state/) for reconnection behavior when controlling actuators
+- [Connect to a machine](/build-apps/tasks/connect-to-machine/) if you have not set up a connection yet
diff --git a/docs/build-apps/tasks/handle-connection-state.md b/docs/build-apps/tasks/handle-connection-state.md
new file mode 100644
index 0000000000..8912ab1f77
--- /dev/null
+++ b/docs/build-apps/tasks/handle-connection-state.md
@@ -0,0 +1,263 @@
+---
+linkTitle: "Handle disconnection and reconnection"
+title: "Handle disconnection and reconnection"
+weight: 50
+layout: "docs"
+type: "docs"
+description: "Show a connection status indicator, react to reconnection, and rebuild your app's UI state after the SDK reconnects to a machine."
+date: "2026-04-10"
+---
+
+Show a connection status indicator in your app, react to connection events, and rebuild UI state after the SDK reconnects. The SDK reconnects the transport layer automatically; your app is responsible for rebuilding streams, timers, and anything else that depended on the old connection.
+
+For an explanation of how the SDK reconnects under the hood, see [Connection model](/build-apps/concepts/how-apps-connect/#reconnection).
+
+{{< alert title="Behavior change" color="caution" >}}
+In versions of the Viam TypeScript SDK prior to v0.69.0, `DISCONNECTED` fired on any connection drop, including transient network interruptions.
+From v0.69.0 onward, `DISCONNECTED` fires only on intentional close or when `noReconnect` is set.
+Transient drops emit `RECONNECTING` instead, followed by `CONNECTED` on success or `RECONNECTION_FAILED` when retries are exhausted.
+
+If your app listens for `DISCONNECTED` to detect network drops, listen for `RECONNECTING` instead.
+{{< /alert >}}
+
+## Prerequisites
+
+- A project with an active machine connection (see [Connect to a machine](/build-apps/tasks/connect-to-machine/))
+
+## TypeScript: subscribe to connection events
+
+The TypeScript SDK emits events on the `RobotClient` whenever the connection state changes. Subscribe to `connectionstatechange` to get a single handler for all state transitions:
+
+```ts
+import * as VIAM from "@viamrobotics/sdk";
+
+const machine = await VIAM.createRobotClient({
+  /* ... */
+});
+
+machine.on("connectionstatechange", (event) => {
+  const { eventType } = event as { eventType: VIAM.MachineConnectionEvent };
+  switch (eventType) {
+    case VIAM.MachineConnectionEvent.DIALING:
+    case VIAM.MachineConnectionEvent.CONNECTING:
+      console.log("Connecting...");
+      break;
+    case VIAM.MachineConnectionEvent.CONNECTED:
+      console.log("Connected");
+      break;
+    case VIAM.MachineConnectionEvent.RECONNECTING:
+      console.log("Connection dropped, reconnecting...");
+      break;
+    case VIAM.MachineConnectionEvent.RECONNECTION_FAILED:
+      console.log("Reconnection failed, giving up");
+      break;
+    case VIAM.MachineConnectionEvent.DISCONNECTING:
+    case VIAM.MachineConnectionEvent.DISCONNECTED:
+      console.log("Disconnected");
+      break;
+  }
+});
+```
+
+`MachineConnectionEvent` has seven values:
+
+| Value                 | When the SDK emits it                                                                                                                        |
+| --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| `DIALING`             | The SDK is dialing the initial connection.                                                                                                   |
+| `CONNECTING`          | The SDK is establishing the WebRTC or gRPC channel.                                                                                          |
+| `CONNECTED`           | The connection is up and ready for calls.                                                                                                    |
+| `RECONNECTING`        | The connection dropped and the SDK is retrying with backoff. Replaces the immediate `DISCONNECTED` event for unintentional drops.            |
+| `RECONNECTION_FAILED` | All reconnection attempts were exhausted. The event payload includes `error` and `attempts` fields.                                          |
+| `DISCONNECTING`       | The app initiated a disconnect (`disconnect()` or app shutdown).                                                                             |
+| `DISCONNECTED`        | The connection is closed and will not retry. Emitted when `noReconnect` is set, when the client was closed, or after intentional disconnect. |
+
+To listen for a specific state only, subscribe to that event type directly:
+
+```ts
+machine.on(VIAM.MachineConnectionEvent.DISCONNECTED, () => {
+  console.log("Disconnected from machine");
+});
+```
+
+### Show a status indicator in the browser
+
+A minimal connection indicator in a vanilla browser app:
+
+```ts
+const statusEl = document.getElementById("status") as HTMLElement;
+
+function setStatus(text: string, color: string) {
+  statusEl.textContent = text;
+  statusEl.style.color = color;
+}
+
+machine.on("connectionstatechange", (event) => {
+  const { eventType } = event as { eventType: VIAM.MachineConnectionEvent };
+  switch (eventType) {
+    case VIAM.MachineConnectionEvent.CONNECTED:
+      setStatus("Connected", "green");
+      break;
+    case VIAM.MachineConnectionEvent.DIALING:
+    case VIAM.MachineConnectionEvent.CONNECTING:
+      setStatus("Connecting...", "orange");
+      break;
+    case VIAM.MachineConnectionEvent.RECONNECTING:
+      setStatus("Reconnecting...", "orange");
+      break;
+    case VIAM.MachineConnectionEvent.RECONNECTION_FAILED:
+    case VIAM.MachineConnectionEvent.DISCONNECTING:
+    case VIAM.MachineConnectionEvent.DISCONNECTED:
+      setStatus("Disconnected", "red");
+      break;
+  }
+});
+```
+
+In React, Vue, or Svelte, set a reactive state variable inside the handler instead of mutating the DOM directly.
+
+## Flutter: check `isConnected`
+
+The Flutter SDK does not expose a connection-event API. Check `robot.isConnected` to know the current state:
+
+```dart
+if (robot.isConnected) {
+  // Connected
+} else {
+  // Not connected
+}
+```
+
+`RobotClient` runs a background connection check on a timer (default every 10 seconds) and attempts reconnection on its own if the check fails. You can tune these intervals through `RobotClientOptions`:
+
+```dart
+final options = RobotClientOptions.withApiKey(apiKeyId, apiKey);
+options.checkConnectionInterval = 5;   // seconds between connection checks
+options.attemptReconnectInterval = 2;  // seconds between reconnection attempts
+
+final robot = await RobotClient.atAddress(address, options);
+```
+
+Setting either interval to `0` disables the corresponding behavior.
+
+### Show a status indicator in Flutter
+
+Poll `isConnected` on a timer to drive a UI indicator:
+
+```dart
+class ConnectionIndicator extends StatefulWidget {
+  final RobotClient robot;
+  const ConnectionIndicator({super.key, required this.robot});
+
+  @override
+  State<ConnectionIndicator> createState() => _ConnectionIndicatorState();
+}
+
+class _ConnectionIndicatorState extends State<ConnectionIndicator> {
+  Timer? _timer;
+  bool _connected = true;
+
+  @override
+  void initState() {
+    super.initState();
+    _timer = Timer.periodic(const Duration(seconds: 2), (_) {
+      setState(() {
+        _connected = widget.robot.isConnected;
+      });
+    });
+  }
+
+  @override
+  void dispose() {
+    _timer?.cancel();
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Row(
+      children: [
+        Icon(Icons.circle, color: _connected ? Colors.green : Colors.red, size: 12),
+        const SizedBox(width: 8),
+        Text(_connected ? 'Connected' : 'Disconnected'),
+      ],
+    );
+  }
+}
+```
+
+Adjust the `Duration(seconds: 2)` to match how quickly you want the UI to reflect state changes. A shorter interval gives faster feedback but uses more CPU.
+
+## Python and Go
+
+The Python and Go SDKs handle reconnection internally with configurable intervals, similar to Flutter. Both provide a connection check and automatic reconnection.
+
+**Python:**
+
+```python
+# Connection check and reconnection are configured through RobotClient.Options
+opts = RobotClient.Options.with_api_key(api_key, api_key_id)
+opts.check_connection_interval = 10  # seconds between checks (default 10)
+opts.attempt_reconnect_interval = 1  # seconds between reconnect attempts (default 1)
+```
+
+The Python SDK does not expose a connection-event API. For long-running services, wrap SDK calls in try/except blocks to catch connection errors and log them.
+
+**Go:**
+
+```go
+// Connection options are set through RobotClientOption functions
+machine, err := client.New(
+    ctx, address, logger,
+    client.WithDialOptions(rpc.WithEntityCredentials(apiKeyID, creds)),
+    client.WithCheckConnectedEvery(10 * time.Second),
+)
+```
+
+The Go SDK reconnects automatically. For long-running services, check errors returned from individual method calls. A `codes.Unavailable` gRPC status indicates the connection is down; the SDK will attempt to reconnect on the next call.
+
+## Rebuild UI state after reconnection
+
+The SDK reconnects the transport layer automatically, but anything your app built on top of the old connection does not resume automatically. This is the single most important pattern for apps that run through network drops:
+
+- **Camera streams** — the stream is torn down when the connection drops. After reconnection, call `getStream` again and re-attach the stream to your video element.
+- **Live sensor polling** — if you were polling `sensor.getReadings()` on a timer, the timer may still be running but the calls will have failed during the outage. Cancel and restart the timer on reconnect, or catch the errors and let the timer naturally resume on reconnection.
+- **Operation handles** — any operation IDs, session IDs, or other handles from before the reconnection are no longer valid. Drop them.
+- **UI state derived from the connection** — lists of resources, last-known readings, and similar cached data may be stale. Re-fetch after reconnection.
+
+A concrete pattern in TypeScript: when the connection handler reaches `CONNECTED` after having seen `RECONNECTING`, call a `rebuildAfterReconnect()` function that restarts streams and polling:
+
+```ts
+let wasReconnecting = false;
+
+machine.on("connectionstatechange", async (event) => {
+  const { eventType } = event as { eventType: VIAM.MachineConnectionEvent };
+  switch (eventType) {
+    case VIAM.MachineConnectionEvent.RECONNECTING:
+      wasReconnecting = true;
+      break;
+    case VIAM.MachineConnectionEvent.CONNECTED:
+      if (wasReconnecting) {
+        wasReconnecting = false;
+        await rebuildAfterReconnect();
+      }
+      break;
+    case VIAM.MachineConnectionEvent.RECONNECTION_FAILED:
+    case VIAM.MachineConnectionEvent.DISCONNECTED:
+      // Reset the flag so a later fresh connect is not treated as a reconnect.
+      wasReconnecting = false;
+      break;
+  }
+});
+
+async function rebuildAfterReconnect() {
+  // Recreate camera streams, restart polling, re-fetch resource names, etc.
+}
+```
+
+Use `RECONNECTING` as the trigger rather than `DISCONNECTED`. The SDK emits `RECONNECTING` as soon as it loses an unintentional connection and starts retrying; `DISCONNECTED` is now only emitted for closed clients or when `noReconnect` is set. Clear `wasReconnecting` on `RECONNECTION_FAILED` and `DISCONNECTED` so that a later reconnect attempt (for example, after the user manually reconnects) does not incorrectly trigger `rebuildAfterReconnect()` on its first `CONNECTED` event. Listen for `RECONNECTION_FAILED` separately if you want to surface the give-up state to the user.
+
+## Next
+
+- [Stream video](/build-apps/tasks/stream-video/) for the camera stream rebuild pattern in detail
+- [Query captured data](/build-apps/tasks/query-data/) for polling live data from an app
+- [Connection model](/build-apps/concepts/how-apps-connect/#reconnection) for a deeper explanation of the reconnection behavior
diff --git a/docs/build-apps/tasks/query-data.md b/docs/build-apps/tasks/query-data.md
new file mode 100644
index 0000000000..d7826439f3
--- /dev/null
+++ b/docs/build-apps/tasks/query-data.md
@@ -0,0 +1,312 @@
+---
+linkTitle: "Query captured data"
+title: "Query captured data"
+weight: 70
+layout: "docs"
+type: "docs"
+description: "Query sensor and binary data from a client app using SQL and MQL through DataClient."
+date: "2026-04-10"
+---
+
+Query data that your Viam machines have captured and synced to the cloud, from inside a client app. This page covers the SDK calls for running SQL and MQL queries from app code. For the query languages themselves (schema, operators, examples), see [Query data](/data/query-data/) in the data section.
+
+## Prerequisites
+
+- A project with a cloud connection (see [Connect to the Viam cloud](/build-apps/tasks/connect-to-cloud/))
+- The organization ID that owns the data you want to query
+- Data capture configured on at least one machine so there is something to query (see [Capture and sync data](/data/capture-sync/capture-and-sync-data/))
+
+## Run a SQL query
+
+SQL is the simplest entry point. The query runs against your organization's captured tabular data.
+
+{{< tabs >}}
+{{% tab name="TypeScript" %}}
+
+```ts
+const orgId = "your-organization-id";
+
+const rows = await client.dataClient.tabularDataBySQL(
+  orgId,
+  `SELECT component_name, time_received, data
+   FROM readings
+   WHERE component_name = 'temperature_sensor'
+   ORDER BY time_received DESC
+   LIMIT 20`,
+);
+
+console.log(`Got ${rows.length} rows`);
+for (const row of rows) {
+  console.log(row);
+}
+```
+
+`tabularDataBySQL` returns an array of row objects. The shape of each row depends on your query's `SELECT` list.
+
+{{% /tab %}}
+{{% tab name="Flutter" %}}
+
+```dart
+final orgId = 'your-organization-id';
+
+final rows = await viam.dataClient.tabularDataBySql(
+  orgId,
+  '''
+  SELECT component_name, time_received, data
+  FROM readings
+  WHERE component_name = 'temperature_sensor'
+  ORDER BY time_received DESC
+  LIMIT 20
+  ''',
+);
+
+print('Got ${rows.length} rows');
+for (final row in rows) {
+  print(row);
+}
+```
+
+`tabularDataBySql` returns a `List<Map<String, dynamic>>` where each map is one row.
+
+{{% /tab %}}
+{{% tab name="Python" %}}
+
+```python
+org_id = "your-organization-id"
+
+rows = await client.data_client.tabular_data_by_sql(
+    org_id,
+    """SELECT component_name, time_received, data
+       FROM readings
+       WHERE component_name = 'temperature_sensor'
+       ORDER BY time_received DESC
+       LIMIT 20"""
+)
+
+print(f"Got {len(rows)} rows")
+for row in rows:
+    print(row)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+orgID := "your-organization-id"
+
+rows, err := client.DataClient().TabularDataBySQL(
+    context.Background(),
+    orgID,
+    "SELECT component_name, time_received, data FROM readings WHERE component_name = 'temperature_sensor' ORDER BY time_received DESC LIMIT 20",
+)
+if err != nil {
+    logger.Fatal(err)
+}
+
+fmt.Printf("Got %d rows\n", len(rows))
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Run an MQL query
+
+MQL (MongoDB Query Language) supports aggregation pipelines: `$match`, `$group`, `$project`, and so on. Use MQL when you need to aggregate data across machines or compute derived values.
+
+{{< tabs >}}
+{{% tab name="TypeScript" %}}
+
+```ts
+const orgId = "your-organization-id";
+
+const pipeline = [
+  {
+    $match: {
+      component_name: "air_quality_sensor",
+      time_received: { $gte: new Date(Date.now() - 3600 * 1000) },
+    },
+  },
+  {
+    $group: {
+      _id: "$robot_id",
+      avg_pm_25: { $avg: "$data.readings.pm_2_5" },
+      max_pm_25: { $max: "$data.readings.pm_2_5" },
+      sample_count: { $sum: 1 },
+    },
+  },
+];
+
+const results = await client.dataClient.tabularDataByMQL(orgId, pipeline);
+console.log(results);
+```
+
+The SDK serializes plain JavaScript objects into BSON automatically. You can also pass pre-serialized `Uint8Array[]` if you are generating the pipeline elsewhere.
+
+{{% /tab %}}
+{{% tab name="Flutter" %}}
+
+```dart
+final orgId = 'your-organization-id';
+
+final pipeline = [
+  {
+    '\$match': {
+      'component_name': 'air_quality_sensor',
+      'time_received': {
+        '\$gte': DateTime.now().subtract(const Duration(hours: 1)),
+      },
+    },
+  },
+  {
+    '\$group': {
+      '_id': '\$robot_id',
+      'avg_pm_25': {'\$avg': '\$data.readings.pm_2_5'},
+      'max_pm_25': {'\$max': '\$data.readings.pm_2_5'},
+      'sample_count': {'\$sum': 1},
+    },
+  },
+];
+
+final results = await viam.dataClient.tabularDataByMql(orgId, pipeline);
+print(results);
+```
+
+Flutter's `tabularDataByMql` also accepts either `List<Map<String, dynamic>>` (auto-serialized) or `List<Uint8List>` (pre-serialized with `BsonCodec.serialize`).
+
+Note that `$` is a special character in Dart string interpolation, so MQL operators must be escaped as `\$match`, `\$group`, and so on inside string literals.
+
+{{% /tab %}}
+{{% tab name="Python" %}}
+
+```python
+from datetime import datetime, timedelta
+
+org_id = "your-organization-id"
+
+pipeline = [
+    {
+        "$match": {
+            "component_name": "air_quality_sensor",
+            "time_received": {"$gte": datetime.now() - timedelta(hours=1)},
+        }
+    },
+    {
+        "$group": {
+            "_id": "$robot_id",
+            "avg_pm_25": {"$avg": "$data.readings.pm_2_5"},
+            "max_pm_25": {"$max": "$data.readings.pm_2_5"},
+            "sample_count": {"$sum": 1},
+        }
+    },
+]
+
+results = await client.data_client.tabular_data_by_mql(org_id, pipeline)
+print(results)
+```
+
+Python's `tabular_data_by_mql` accepts either a list of dicts (auto-serialized) or pre-serialized BSON bytes.
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+orgID := "your-organization-id"
+
+pipeline := []map[string]interface{}{
+    {
+        "$match": map[string]interface{}{
+            "component_name": "air_quality_sensor",
+        },
+    },
+    {
+        "$group": map[string]interface{}{
+            "_id":          "$robot_id",
+            "avg_pm_25":    map[string]interface{}{"$avg": "$data.readings.pm_2_5"},
+            "sample_count": map[string]interface{}{"$sum": 1},
+        },
+    },
+}
+
+results, err := client.DataClient().TabularDataByMQL(
+    context.Background(), orgID, pipeline, nil,
+)
+if err != nil {
+    logger.Fatal(err)
+}
+fmt.Println(results)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## SQL or MQL, when to use each
+
+- **SQL** for simple selects, filters, and joins against captured tabular data. Familiar syntax, works well for dashboards that show raw or lightly filtered data.
+- **MQL** for aggregation pipelines: averages, windowed sums, grouping across components, computing derived fields. Required for fleet-wide aggregations that SQL cannot express cleanly.
+
+The two query languages run against the same underlying data. Pick the one that matches how you want to think about the query, not based on any performance difference.
+
+## Refresh data on a timer
+
+Dashboards typically refresh on a timer. Neither the TypeScript nor the Flutter SDK provides a subscription API for live data: you poll on a `setInterval` or `Timer.periodic` and update your UI when the results come back.
+
+{{< tabs >}}
+{{% tab name="TypeScript" %}}
+
+```ts
+const intervalId = setInterval(async () => {
+  try {
+    const rows = await client.dataClient.tabularDataBySQL(orgId, query);
+    updateDashboard(rows);
+  } catch (err) {
+    console.error("Query failed:", err);
+  }
+}, 10_000);
+
+// Later, when the component unmounts or the user navigates away:
+clearInterval(intervalId);
+```
+
+{{% /tab %}}
+{{% tab name="Flutter" %}}
+
+```dart
+Timer.periodic(const Duration(seconds: 10), (timer) async {
+  try {
+    final rows = await viam.dataClient.tabularDataBySql(orgId, query);
+    setState(() {
+      _rows = rows;
+    });
+  } catch (e) {
+    print('Query failed: $e');
+  }
+});
+```
+
+Cancel the timer in your `State.dispose()` method.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Pick a refresh interval that balances UI freshness against query cost. Every query is a network round trip to the Viam cloud and a database query against your captured data. For a dashboard showing minute-scale aggregations, refresh every 10-30 seconds. For near-real-time displays, refresh every 1-5 seconds but expect higher data transfer.
+
+## Query binary data
+
+The same `DataClient` can filter binary data (images, point clouds) captured by the data manager. Use `binaryDataByFilter` with a filter specification:
+
+```ts
+const binaries = await client.dataClient.binaryDataByFilter({
+  componentName: "front_camera",
+  startTime: new Date("2026-04-01T00:00:00Z"),
+  endTime: new Date("2026-04-02T00:00:00Z"),
+  tags: ["training"],
+});
+```
+
+Binary data responses include metadata and a URL to download the file. See the [Data API reference](/reference/apis/data-client/) for the full request shape.
+
+## Next
+
+- [Query data](/data/query-data/) for the SQL and MQL query languages, the schema, and operator reference
+- [Connect to the Viam cloud](/build-apps/tasks/connect-to-cloud/) for setting up the cloud connection that `dataClient` requires
+- [Data API reference](/reference/apis/data-client/) for the full `DataClient` method list
diff --git a/docs/build-apps/tasks/stream-video.md b/docs/build-apps/tasks/stream-video.md
new file mode 100644
index 0000000000..654a4031e2
--- /dev/null
+++ b/docs/build-apps/tasks/stream-video.md
@@ -0,0 +1,151 @@
+---
+linkTitle: "Stream video"
+title: "Stream video"
+weight: 60
+layout: "docs"
+type: "docs"
+description: "Display live camera feeds in a client app. Covers single-camera and multi-camera streaming, resolution tradeoffs, and bandwidth considerations."
+date: "2026-04-10"
+---
+
+Display a live camera feed from a Viam machine in your client app. The TypeScript and Flutter SDKs use WebRTC for video streaming, which gives low latency suitable for teleoperation. Python, Go, and C++ access camera data through single-frame methods (`get_images`, `GetImages`) rather than WebRTC streams; for live video in those languages, poll `get_images` on a timer. This page focuses on the WebRTC streaming path available in TypeScript and Flutter.
+
+## Prerequisites
+
+- A project with an active machine connection (see [Connect to a machine](/build-apps/tasks/connect-to-machine/))
+- A camera component configured on the machine. Any camera model will work, including `fake:camera` for testing without real hardware.
+
+## Stream one camera
+
+{{< tabs >}}
+{{% tab name="TypeScript" %}}
+
+Create a `StreamClient` from your `RobotClient` and call `getStream(name)` to get a `MediaStream`. Attach it to an HTML `<video>` element:
+
+```html
+<video id="camera" autoplay playsinline muted></video>
+```
+
+```ts
+import * as VIAM from "@viamrobotics/sdk";
+
+const streamClient = new VIAM.StreamClient(machine);
+const mediaStream = await streamClient.getStream("my_camera");
+
+const videoEl = document.getElementById("camera") as HTMLVideoElement;
+videoEl.srcObject = mediaStream;
+```
+
+`getStream` waits up to 5 seconds for the first video track to arrive, then resolves with a `MediaStream`. The `<video>` element must have `autoplay`, `playsinline`, and `muted` attributes to play a `MediaStream` without user interaction in most browsers.
+
+To stop a stream, call `remove` with the camera name:
+
+```ts
+await streamClient.remove("my_camera");
+```
+
+{{% /tab %}}
+{{% tab name="Flutter" %}}
+
+The Flutter SDK ships a `ViamCameraStreamView` widget that handles the WebRTC renderer internally. Obtain a `Camera` component and a `StreamClient` from your `RobotClient`, then pass both to the widget:
+
+```dart
+import 'package:flutter/material.dart';
+import 'package:viam_sdk/viam_sdk.dart';
+import 'package:viam_sdk/widgets.dart';
+
+class CameraView extends StatelessWidget {
+  final RobotClient robot;
+  const CameraView({super.key, required this.robot});
+
+  @override
+  Widget build(BuildContext context) {
+    final camera = Camera.fromRobot(robot, 'my_camera');
+    final streamClient = robot.getStream('my_camera');
+    return ViamCameraStreamView(
+      camera: camera,
+      streamClient: streamClient,
+    );
+  }
+}
+```
+
+`ViamCameraStreamView` manages the underlying `RTCVideoRenderer`, tears it down in `dispose()`, and displays an error state if the stream fails.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Stream multiple cameras
+
+Multiple cameras work the same way as one: call `getStream` (TypeScript) or `robot.getStream` plus `ViamCameraStreamView` (Flutter) once per camera name.
+
+{{< tabs >}}
+{{% tab name="TypeScript" %}}
+
+```ts
+const streamClient = new VIAM.StreamClient(machine);
+
+const frontStream = await streamClient.getStream("front_camera");
+const rearStream = await streamClient.getStream("rear_camera");
+
+(document.getElementById("front") as HTMLVideoElement).srcObject = frontStream;
+(document.getElementById("rear") as HTMLVideoElement).srcObject = rearStream;
+```
+
+A single `StreamClient` can manage multiple streams. You do not need one client per camera.
+
+{{% /tab %}}
+{{% tab name="Flutter" %}}
+
+The Flutter SDK also ships a `ViamMultiCameraStreamView` widget for multi-camera layouts, which handles the stream management for several cameras at once. See the [Flutter SDK reference](https://flutter.viam.dev/) for the widget's parameters.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Hardware and bandwidth limits
+
+Streaming more than two or three cameras at once from the same machine is unreliable on typical hardware. Reported failure modes from practitioners:
+
+- **USB bandwidth ceilings.** Stacking several USB cameras on the same host saturates the bus before the WebRTC encoder does. Cameras appear to connect but deliver corrupt or empty frames.
+- **WebRTC peer connection limits.** Some host hardware cannot negotiate more than three simultaneous WebRTC video tracks. The third or fourth `getStream` call hangs or times out.
+- **Cellular bandwidth cost.** A single 720p camera stream can use 1-3 Mbps sustained. On a cellular deployment, two or three simultaneous streams can burn through a monthly data cap in days.
+
+If you need more than two cameras in one UI, drop resolution first, then consider whether you can show one camera at a time and let the user switch.
+
+## Resolution and bandwidth
+
+Lower resolutions use less bandwidth and CPU on both ends. The TypeScript SDK exposes resolution control on `StreamClient`:
+
+```ts
+// See what resolutions the camera advertises
+const options = await streamClient.getOptions("my_camera");
+console.log(options);
+
+// Set a specific resolution (width, height in pixels)
+await streamClient.setOptions("my_camera", 640, 480);
+
+// Reset to the camera's default
+await streamClient.resetOptions("my_camera");
+```
+
+`setOptions` takes effect on the next `getStream` call for that camera. If you change the resolution while a stream is active, remove and re-add the stream to apply the change.
+
+Practical guidance:
+
+- **Teleoperation of a vehicle or arm.** Prioritize framerate and latency over resolution. 640x480 at 30 fps is usually better than 1920x1080 at 5 fps.
+- **Inspection dashboards where the user stares at one feed.** Higher resolution helps. Use the camera's native resolution unless bandwidth is a hard constraint.
+- **Multi-camera fleet overviews.** Drop every stream to the lowest useful resolution. The user is scanning, not inspecting.
+
+## Reconnection behavior
+
+The TypeScript SDK's `StreamClient` tracks open streams and automatically re-adds them when the `RobotClient` reconnects. Your app does not need to re-call `getStream`, but the HTML `<video>` element may still need its `srcObject` reattached because the old `MediaStream` object becomes invalid. A simple pattern is to re-run the `getStream` and `videoEl.srcObject = mediaStream` assignment inside your connection-state handler.
+
+In the Flutter SDK, `StreamClient` does not explicitly re-add streams on reconnect. If a stream becomes inactive after a disconnection, tear down the `ViamCameraStreamView` and recreate it, or listen for connection-state changes and restart the stream manually.
+
+See [Handle disconnection and reconnection](/build-apps/tasks/handle-connection-state/) for the connection-event pattern.
+
+## Next
+
+- [Handle disconnection and reconnection](/build-apps/tasks/handle-connection-state/) for the rebuild-after-reconnect pattern
+- [Query captured data](/build-apps/tasks/query-data/) for reading captured data alongside live streams
+- [Camera component reference](/hardware/common-components/add-a-camera/) for per-model configuration
diff --git a/docs/build-apps/tasks/test-locally.md b/docs/build-apps/tasks/test-locally.md
new file mode 100644
index 0000000000..7f6593434c
--- /dev/null
+++ b/docs/build-apps/tasks/test-locally.md
@@ -0,0 +1,144 @@
+---
+linkTitle: "Test against a local machine"
+title: "Test against a local machine"
+weight: 80
+layout: "docs"
+type: "docs"
+description: "Develop a Viam client app against a real machine without deploying. Covers direct local-network connections and the viam module local-app-testing CLI."
+date: "2026-04-10"
+---
+
+Develop your Viam client app against a real machine without deploying to production on every change. There are two ways: open a direct connection to the machine from your local dev server, or use the `viam module local-app-testing` CLI to emulate the Viam Applications hosting environment.
+
+For the CLI command name: `viam module local-app-testing` is grouped under `viam module` because Viam Applications are distributed through the same module registry. It has nothing to do with building server-side modules. Treat the `module` in the command name as an artifact of the registry plumbing.
+
+## Which approach to use
+
+- **Direct connection** if your app does not need cookie-based credential injection. You use the same connection code you would use in production, with the credentials in a local `.env` file. Simplest for single-machine browser apps and for Flutter apps.
+- **`local-app-testing` CLI** if your app is a hosted Viam Application that reads credentials from browser cookies. The CLI emulates the cookie injection that Viam Applications does in production, so your app code can use the same cookie-reading logic in development.
+
+## Direct connection
+
+Run your local dev server with credentials in a `.env` file. Your app calls `createRobotClient` or `RobotClient.atAddress` with the credentials from the file.
+
+See [App scaffolding](/build-apps/setup/) for the platform-specific setup pages, which all use this pattern in their connection verification step. The setup pages are the canonical reference for this approach.
+
+### Local-network connections
+
+If the machine is on the same network as your dev server, you can skip the cloud signaling service and connect directly over the local network. Restart `viam-server` with the `-no-tls` flag, then set `signalingAddress` to the machine's local address instead of `https://app.viam.com:443`:
+
+```ts
+const machine = await VIAM.createRobotClient({
+  host: "my-robot-main.xxxx.viam.cloud",
+  credentials: {
+    type: "api-key",
+    authEntity: "<API-KEY-ID>",
+    payload: "<API-KEY>",
+  },
+  signalingAddress: "http://my-robot.local:8080",
+});
+```
+
+Local-network connections eliminate the cloud round trip and are useful for latency-sensitive testing. See the [connectivity reference](/reference/sdks/connectivity/#connect-over-local-network-or-offline) for the exact `viam-server` flags and local hostname setup.
+
+## `viam module local-app-testing` CLI
+
+The `local-app-testing` CLI proxies your local dev server and injects the same cookies that the Viam Applications hosting platform injects in production. This lets you test an app that reads credentials from cookies without deploying to the registry on every change.
+
+The CLI has two modes, matching the two Viam Application types:
+
+- **Single-machine mode** (pass `--machine-id`). The CLI fetches an API key for the specified machine from the Viam backend and writes a machine-specific cookie that your app reads.
+- **Multi-machine mode** (omit `--machine-id`). The CLI uses the user access token from your current `viam login` session and writes it as a cookie, so your app sees the same credential shape it would see in a deployed multi-machine Viam Application.
+
+### Start your dev server
+
+Run your app's dev server as you normally would. For a Vite-based web app:
+
+```sh {class="command-line" data-prompt="$"}
+npx vite
+```
+
+Vite prints a URL, typically `http://localhost:5173`. Leave this running.
+
+### Start the local-app-testing server
+
+In a second terminal, run the CLI:
+
+{{< tabs >}}
+{{% tab name="Single-machine" %}}
+
+```sh {class="command-line" data-prompt="$"}
+viam login
+viam module local-app-testing \
+  --app-url http://localhost:5173 \
+  --machine-id YOUR-MACHINE-ID
+```
+
+Get `YOUR-MACHINE-ID` from the machine's page in the Viam app. The CLI:
+
+1. Fetches an API key for the machine from the Viam backend.
+2. Fetches the machine's FQDN from its main part.
+3. Starts an HTTP server on `http://localhost:8012`.
+4. Opens your browser to `http://localhost:8012/start`, which sets the cookies and redirects to your dev server through the proxy.
+
+{{% /tab %}}
+{{% tab name="Multi-machine" %}}
+
+```sh {class="command-line" data-prompt="$"}
+viam login
+viam module local-app-testing --app-url http://localhost:5173
+```
+
+Without `--machine-id`, the CLI runs in multi-machine mode and uses the access token from your `viam login` session. Do not pass an API key profile for multi-machine mode; the CLI needs a user access token, not a service-identity API key. The CLI:
+
+1. Reads your current access token from the local CLI config.
+2. Starts an HTTP server on `http://localhost:8012`.
+3. Opens your browser to `http://localhost:8012/start`, which sets the user-token cookie and redirects to your dev server.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Develop against the running machine
+
+Edit your source files in the dev server project. Hot reload, browser refresh, and all the development features of your chosen tooling work the same way they would without the proxy. The cookies persist across reloads, so you do not need to re-run the CLI after every source change.
+
+Stop the local-app-testing server with `Ctrl+C` when you are done. The dev server can keep running.
+
+## Firefox WebRTC localhost workaround
+
+Firefox blocks WebRTC connections from `localhost` due to a network interface enumeration restriction. If you use Firefox for development, you have two options.
+
+The simplest option is to use Chrome, Edge, or another Chromium-based browser for local testing. WebRTC works from `localhost` in those browsers without any configuration.
+
+If you need Firefox specifically, add a local hostname to your `/etc/hosts` file and run your dev server bound to that hostname instead of `localhost`:
+
+```sh {class="command-line" data-prompt="$"}
+sudo bash -c 'echo "127.0.0.1  dev.local" >> /etc/hosts'
+```
+
+Then start your dev server with the hostname. For Vite:
+
+```sh {class="command-line" data-prompt="$"}
+npx vite --host dev.local
+```
+
+Open `http://dev.local:5173` in Firefox. WebRTC works because the URL is no longer `localhost`.
+
+To remove the hostname later:
+
+```sh {class="command-line" data-prompt="$"}
+sudo sed -i '' '/dev.local/d' /etc/hosts
+```
+
+(On Linux, drop the empty `''` argument to `sed -i`.)
+
+## Troubleshooting
+
+- **Port 8012 already in use.** The CLI hardcodes port 8012. If another process owns it, stop that process first.
+- **"No access token found" in multi-machine mode.** Run `viam login` (not `viam login api-key`) to obtain a user access token. Service-identity API keys do not grant user-level access.
+- **Cookies not set in the browser.** The CLI redirects the browser to `/start` on first run, which is where the cookies are written. If you navigate directly to a proxied path before visiting `/start`, the cookies are missing. Close the tab and reopen from the terminal link, or navigate to `http://localhost:8012/` manually.
+
+## Next
+
+- [Deploy a Viam application](/build-apps/hosting/deploy/) for packaging and uploading your app once local testing is complete
+- [Connectivity reference](/reference/sdks/connectivity/) for local-network and offline connection details
diff --git a/docs/build-modules/_index.md b/docs/build-modules/_index.md
new file mode 100644
index 0000000000..d998147d99
--- /dev/null
+++ b/docs/build-modules/_index.md
@@ -0,0 +1,16 @@
+---
+linkTitle: "Build and deploy modules"
+title: "Build and deploy modules"
+weight: 60
+layout: "docs"
+type: "docs"
+no_list: true
+description: "Understand the two kinds of modules, then write, test, and deploy your own."
+manualLink: "/build-modules/overview/"
+aliases:
+  - /build/development/
+  - /development/
+  - /hardware-components/hardware-to-logic/
+  - /hardware/hardware-to-logic/
+  - /build/
+---
diff --git a/docs/build-modules/dependencies.md b/docs/build-modules/dependencies.md
new file mode 100644
index 0000000000..de8f03a745
--- /dev/null
+++ b/docs/build-modules/dependencies.md
@@ -0,0 +1,247 @@
+---
+title: "Access machine resources from within a module"
+linkTitle: "Module dependencies"
+weight: 36
+layout: "docs"
+type: "docs"
+description: "From within a modular resource, you can access other machine resources using dependencies."
+aliases:
+date: "2025-11-11"
+---
+
+From within a modular resource, you can access other machine {{< glossary_tooltip term_id="resource" text="resources" >}} using dependencies.
+For background on required and optional dependencies, see the
+[overview](/build-modules/overview/#dependencies).
+
+## The dependency pattern
+
+Every dependency follows three steps: declare it in validation, resolve it in your constructor or reconfigure method, then call its API methods.
+
+The examples below show a base that depends on two motors -- a required left motor and an optional right motor (for a base that can operate in single-motor mode).
+
+### 1. Declare dependencies in validation
+
+Dependency names come from your resource's configuration attributes, keeping the module flexible:
+
+```json {class="line-numbers linkable-line-numbers"}
+{
+  "name": "my-base",
+  "api": "rdk:component:base",
+  "model": "myorg:mymodule:mybase",
+  "attributes": {
+    "left_motor": "motor-1",
+    "right_motor": "motor-2"
+  }
+}
+```
+
+Your validation method parses these names and returns them as required or optional dependencies:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python {class="line-numbers linkable-line-numbers"}
+@classmethod
+def validate_config(
+    cls, config: ComponentConfig
+) -> Tuple[Sequence[str], Sequence[str]]:
+    req_deps = []
+    opt_deps = []
+    fields = config.attributes.fields
+
+    # Required dependency
+    if "left_motor" not in fields:
+        raise Exception("missing required left_motor attribute")
+    req_deps.append(fields["left_motor"].string_value)
+
+    # Optional dependency
+    if "right_motor" in fields:
+        opt_deps.append(fields["right_motor"].string_value)
+
+    return req_deps, opt_deps
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+Define your config struct with fields for each dependency name:
+
+```go {class="line-numbers linkable-line-numbers"}
+type Config struct {
+    LeftMotor  string `json:"left_motor"`
+    RightMotor string `json:"right_motor"`
+}
+
+func (cfg *Config) Validate(path string) ([]string, []string, error) {
+    // Required dependency
+    if cfg.LeftMotor == "" {
+        return nil, nil,
+            resource.NewConfigValidationFieldRequiredError(
+                path, "left_motor")
+    }
+    reqDeps := []string{cfg.LeftMotor}
+
+    // Optional dependency
+    var optDeps []string
+    if cfg.RightMotor != "" {
+        optDeps = append(optDeps, cfg.RightMotor)
+    }
+
+    return reqDeps, optDeps, nil
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 2. Resolve dependencies
+
+In Python, resolve dependencies in the `reconfigure` method. In Go, resolve them in your constructor (or `Reconfigure` method if you are not using `AlwaysRebuild`).
+
+Use the dependency name to look up the resource, then cast it to the correct type.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python {class="line-numbers linkable-line-numbers"}
+from typing import cast
+from viam.components.motor import Motor
+
+
+def reconfigure(
+    self, config: ComponentConfig,
+    dependencies: Mapping[ResourceName, ResourceBase]
+):
+    fields = config.attributes.fields
+
+    # Required dependency -- direct lookup
+    left_name = fields["left_motor"].string_value
+    self.left = cast(
+        Motor,
+        dependencies[Motor.get_resource_name(left_name)])
+
+    # Optional dependency -- use .get() and handle None
+    self.right = None
+    if "right_motor" in fields:
+        right_name = fields["right_motor"].string_value
+        right_resource = dependencies.get(
+            Motor.get_resource_name(right_name))
+        if right_resource is not None:
+            self.right = cast(Motor, right_resource)
+
+    return super().reconfigure(config, dependencies)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go {class="line-numbers linkable-line-numbers"}
+import (
+    "go.viam.com/rdk/components/motor"
+)
+
+func newMyBase(ctx context.Context, deps resource.Dependencies,
+    conf resource.Config, logger logging.Logger,
+) (base.Base, error) {
+    baseConfig, err := resource.NativeConfig[*Config](conf)
+    if err != nil {
+        return nil, err
+    }
+
+    b := &myBase{
+        Named:  conf.ResourceName().AsNamed(),
+        logger: logger,
+    }
+
+    // Required dependency
+    b.left, err = motor.FromProvider(deps, baseConfig.LeftMotor)
+    if err != nil {
+        return nil, err
+    }
+
+    // Optional dependency -- check config, ignore error
+    if baseConfig.RightMotor != "" {
+        b.right, err = motor.FromProvider(
+            deps, baseConfig.RightMotor)
+        if err != nil {
+            logger.Infow("right motor not available, "+
+                "running in single-motor mode",
+                "error", err)
+        }
+    }
+
+    return b, nil
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+{{% alert title="Note" color="note" %}}
+Go modules that use `resource.AlwaysRebuild` resolve dependencies in the constructor, which runs on every reconfiguration.
+If you need to maintain state across reconfigurations, see [Handle reconfiguration](/build-modules/write-a-driver-module/#6-handle-reconfiguration-optional).
+{{% /alert %}}
+
+### 3. Use dependencies
+
+Once resolved, call API methods on your dependencies like any other resource:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python {class="line-numbers linkable-line-numbers"}
+async def set_power(
+    self,
+    linear: Vector3,
+    angular: Vector3,
+    *,
+    extra: Optional[Dict[str, Any]] = None,
+    timeout: Optional[float] = None,
+    **kwargs
+):
+    await self.left.set_power(linear.y + angular.z)
+    if self.right:
+        await self.right.set_power(linear.y - angular.z)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go {class="line-numbers linkable-line-numbers"}
+func (b *myBase) SetPower(
+    ctx context.Context,
+    linear, angular r3.Vector,
+    extra map[string]interface{},
+) error {
+    err := b.left.SetPower(
+        ctx, linear.Y+angular.Z, extra)
+    if err != nil {
+        return err
+    }
+    if b.right != nil {
+        return b.right.SetPower(
+            ctx, linear.Y-angular.Z, extra)
+    }
+    return nil
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+{{% alert title="Accessing built-in services" color="tip" %}}
+Some services like the motion service are available by default as part of `viam-server` even though they don't appear in your machine config. To depend on one, use its full resource name in your validation method:
+
+**Python:** `req_deps.append("rdk:service:motion/builtin")`
+
+**Go:** `deps := []string{motion.Named("builtin").String()}`
+
+Then resolve it the same way as any other dependency.
+{{% /alert %}}
+
+## What's next
+
+- [Write a Driver Module](/build-modules/write-a-driver-module/) -- full walkthrough including dependency handling in context.
+- [Write a Logic Module](/build-modules/write-a-logic-module/) -- build a module that coordinates multiple resources.
+- [Access platform APIs](/build-modules/platform-apis/) -- access fleet management, data, and ML training APIs from within a module.
+- For full examples, see the [Desk Safari tutorial](/operate/hello-world/tutorial-desk-safari/) or [complex module examples on GitHub](https://github.com/viamrobotics/viam-python-sdk/tree/main/examples/complex_module/src).
diff --git a/docs/build-modules/deploy-a-module.md b/docs/build-modules/deploy-a-module.md
new file mode 100644
index 0000000000..0aa5c7c3b3
--- /dev/null
+++ b/docs/build-modules/deploy-a-module.md
@@ -0,0 +1,547 @@
+---
+linkTitle: "Deploy a module"
+title: "Deploy a module"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "Package, upload, and distribute a module through the Viam registry."
+date: "2025-01-30"
+aliases:
+  - /build/development/deploy-a-module/
+  - /development/deploy-a-module/
+  - /extend/modular-resources/upload/
+  - /modular-resources/upload/
+  - /registry/upload/
+  - /how-tos/upload-module/
+---
+
+A module that only runs locally on your development machine is useful for testing
+but limits what you can do. Deploying through the Viam module registry lets you:
+
+- **Install on any machine** in your organization (or publicly) through the
+  Viam app -- no SSH or manual file copying.
+- **Update over the air** -- release a new version and machines pick it up
+  automatically within minutes.
+- **Target multiple platforms** -- cloud build compiles for every architecture
+  you need so you don't have to cross-compile locally.
+
+For background on the module registry, versioning, and cloud builds, see the
+[overview](/build-modules/overview/#the-module-registry).
+
+## Steps
+
+### 1. Review meta.json
+
+The generator creates a `meta.json` file in your module directory. Open it and
+review each field:
+
+```json
+{
+  "module_id": "my-org:my-sensor-module",
+  "visibility": "private",
+  "url": "https://github.com/my-org/my-sensor-module",
+  "description": "A custom sensor module that reads temperature and humidity from an HTTP endpoint.",
+  "models": [
+    {
+      "api": "rdk:component:sensor",
+      "model": "my-org:my-sensor-module:my-sensor"
+    }
+  ],
+  "entrypoint": "run.sh",
+  "build": {
+    "setup": "./setup.sh",
+    "build": "./build.sh",
+    "path": "dist/archive.tar.gz",
+    "arch": ["linux/amd64", "linux/arm64"]
+  }
+}
+```
+
+| Field               | Required | Purpose                                                                                                                                                                                              |
+| ------------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `$schema`           | No       | JSON Schema URL for editor validation. Set to `https://dl.viam.dev/module.schema.json`.                                                                                                              |
+| `module_id`         | Yes      | Unique ID in the registry. Format: `namespace:name`.                                                                                                                                                 |
+| `visibility`        | Yes      | Who can see and install the module: `private`, `public`, or `public_unlisted`.                                                                                                                       |
+| `url`               | No       | Link to the source code repository. Required for cloud builds.                                                                                                                                       |
+| `description`       | Yes      | Shown in the registry UI and search results.                                                                                                                                                         |
+| `models`            | No       | List of resource models the module provides. Each has `api`, `model`, and optionally `short_description` and `markdown_link`. Models can be auto-detected with `viam module update-models --binary`. |
+| `entrypoint`        | Yes      | The path to the command that starts the module inside the archive.                                                                                                                                   |
+| `first_run`         | No       | Path to a setup script that runs once after first install (default timeout: 1 hour).                                                                                                                 |
+| `markdown_link`     | No       | Path to a README file (or `README.md#section` anchor) used as the registry description.                                                                                                              |
+| `build.setup`       | No       | Script that installs build dependencies (runs once).                                                                                                                                                 |
+| `build.build`       | No       | Script that compiles and packages the module.                                                                                                                                                        |
+| `build.path`        | No       | Path to the packaged output archive (default: `module.tar.gz`).                                                                                                                                      |
+| `build.arch`        | No       | Target platforms to build for (default: `["linux/amd64", "linux/arm64"]`).                                                                                                                           |
+| `build.darwin_deps` | No       | Homebrew dependencies for macOS builds (for example, `["go", "pkg-config"]`).                                                                                                                        |
+
+Visibility options:
+
+- **`private`** -- only your organization can see and use the module.
+- **`public`** -- all Viam users can see and use it. Requires your organization
+  to have a public namespace.
+- **`public_unlisted`** -- any user can use the module if they know the ID, but
+  it does not appear in registry search results.
+
+Common `api` values:
+
+- `rdk:component:sensor` for sensors
+- `rdk:component:camera` for cameras
+- `rdk:component:motor` for motors
+- `rdk:component:generic` for generic components
+- `rdk:service:vision` for vision services
+
+### 2. Review the generated build scripts
+
+The generator creates build and setup scripts for your module. Review them
+and customize if needed:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+| File       | Purpose                                              |
+| ---------- | ---------------------------------------------------- |
+| `setup.sh` | Installs Python dependencies from `requirements.txt` |
+| `build.sh` | Packages the module into a `.tar.gz` archive         |
+| `run.sh`   | Entrypoint script that starts the module             |
+
+If your module has additional build steps (for example, compiling native extensions),
+add them to `build.sh`.
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+| File       | Purpose                                                               |
+| ---------- | --------------------------------------------------------------------- |
+| `setup.sh` | Installs build dependencies (Go modules are typically self-contained) |
+| `build.sh` | Cross-compiles the binary and packages it into a `.tar.gz` archive    |
+| `Makefile` | Local build targets                                                   |
+
+The generated `build.sh` uses `GOOS` and `GOARCH` environment variables to
+cross-compile for the target platform. Cloud build sets these automatically.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Make sure all scripts are executable:
+
+```bash
+chmod +x setup.sh build.sh run.sh
+```
+
+### 3. Write a README (recommended)
+
+Document your module and its models so users know how to configure and use
+them. If you plan to make your module public, a good README is essential.
+
+{{< expand "Module README template" >}}
+
+```md
+# `my-sensor-module`
+
+This module implements the [Viam sensor API](https://docs.viam.com/reference/apis/components/sensor/) in a `my-org:my-sensor-module:my-sensor` model.
+With this model, you can gather temperature and humidity data from a custom HTTP endpoint.
+
+Navigate to the **CONFIGURE** tab of your machine's page.
+Click the **+** button, select **Configuration block**, then select the `sensor / my-sensor-module:my-sensor` model provided by the [`my-sensor-module` module](https://app.viam.com/module/my-org/my-sensor-module).
+Click **Add module**, enter a name for your sensor, and click **Create**.
+
+## Models
+
+This module provides the following model(s):
+
+- [`my-org:my-sensor-module:my-sensor`](#my-sensor) - A custom sensor that reads temperature and humidity from an HTTP endpoint
+```
+
+{{< /expand >}}
+
+{{< expand "Model README template" >}}
+
+````md
+# Model `my-org:my-sensor-module:my-sensor`
+
+A description of what this model does and what hardware or services it supports.
+
+## Configuration
+
+The following attribute template can be used to configure this model:
+
+```json
+{
+  "source_url": "<string>",
+  "poll_interval": <float>
+}
+```
+
+### Attributes
+
+| Name            | Type   | Required | Description                                 |
+| --------------- | ------ | -------- | ------------------------------------------- |
+| `source_url`    | string | Yes      | The HTTP endpoint to read sensor data from  |
+| `poll_interval` | float  | No       | Polling interval in seconds (default: 10.0) |
+
+### Example Configuration
+
+```json
+{
+  "source_url": "https://api.example.com/sensor/data",
+  "poll_interval": 5.0
+}
+```
+
+## DoCommand
+
+If your model implements DoCommand, document each supported command.
+
+### Example DoCommand
+
+```json
+{
+  "command": "calibrate",
+  "offset": 1.5
+}
+```
+````
+
+{{< /expand >}}
+
+You can point your module's registry page to a README by setting the
+`markdown_link` field in `meta.json` to a file path (for example, `README.md`) or a
+section anchor (for example, `README.md#my-sensor`).
+
+### 4. Deploy with cloud build (recommended)
+
+Cloud build is the recommended way to deploy modules. It uses GitHub Actions to
+compile your module for every target platform automatically, so you don't need
+to cross-compile locally.
+
+The generator creates the workflow file at
+`.github/workflows/deploy.yml`. To use it:
+
+**Push your code to GitHub:**
+
+```bash
+cd my-sensor-module
+git init
+git add .
+git commit -m "Initial module code"
+git remote add origin https://github.com/my-org/my-sensor-module.git
+git push -u origin main
+```
+
+**Add Viam credentials as GitHub secrets:**
+
+1. In the [Viam app](https://app.viam.com), go to your organization's settings.
+2. Create an API key with organization-level access (or use an existing one).
+3. In your GitHub repository, go to **Settings > Secrets and variables >
+   Actions**.
+4. Add two secrets:
+   - `VIAM_KEY_ID` -- your API key ID
+   - `VIAM_KEY_VALUE` -- your API key
+
+**Tag a release to trigger the build:**
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+The GitHub Action runs automatically. Monitor progress in the **Actions** tab
+of your GitHub repository. When it completes, your module is in the registry
+and ready to install on any machine.
+
+You can also trigger a cloud build from the CLI:
+
+```bash
+viam module build start
+```
+
+{{< alert title="Non-main default branches" color="tip" >}}
+Cloud build expects your repository's default branch to be `main`. If your
+repository uses a different default branch (for example, `master`), use the `--ref`
+flag:
+
+```bash
+viam module build start --ref master
+```
+
+{{< /alert >}}
+
+### 5. Deploy manually (alternative)
+
+If you cannot use cloud build, you can build and upload from the command line.
+
+{{< alert title="You must build for the target platform" color="caution" >}}
+When you upload manually, the binary in your archive must already be compiled
+for the target machine's OS and architecture. If you build on an x86 laptop
+and upload for `linux/arm64` without cross-compiling, the module will fail
+with an exec format error on ARM machines (like Raspberry Pi).
+
+Cloud build handles this automatically. If you deploy manually, you must
+cross-compile yourself or build on a machine with the target architecture.
+{{< /alert >}}
+
+**Build locally:**
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```bash
+cd my-sensor-module
+bash build.sh
+```
+
+The generated `build.sh` uses [PyInstaller](https://pypi.org/project/pyinstaller/)
+to compile your module into a standalone executable containing the Python
+interpreter and all dependencies.
+
+{{< alert title="PyInstaller limitations" color="note" >}}
+
+- PyInstaller does not support relative imports in entrypoints (imports
+  starting with `.`). If you get `"ImportError: attempted relative import with
+no known parent package"`, see the
+  [PyInstaller workaround](https://github.com/pyinstaller/pyinstaller/issues/2560).
+- PyInstaller does not support cross-compilation. Use
+  [cloud build](#4-deploy-with-cloud-build-recommended) to build for multiple
+  architectures automatically.
+  {{< /alert >}}
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```bash
+cd my-sensor-module
+# Cross-compile for the target platform
+GOOS=linux GOARCH=arm64 go build -o dist/module cmd/module/main.go
+tar -czf dist/archive.tar.gz -C dist module
+```
+
+Set `GOARCH` to match your target machine: `amd64` for x86_64, `arm64` for
+ARM (Raspberry Pi 4, Jetson, etc.).
+
+{{% /tab %}}
+{{< /tabs >}}
+
+**Upload to the registry:**
+
+```bash
+viam module upload \
+    --version=0.1.0 \
+    --platform=linux/arm64 \
+    dist/archive.tar.gz
+```
+
+To support multiple platforms, cross-compile and upload once per platform:
+
+```bash
+# Build and upload for amd64
+GOOS=linux GOARCH=amd64 go build -o dist/module cmd/module/main.go
+tar -czf dist/archive.tar.gz -C dist module
+viam module upload --version=0.1.0 --platform=linux/amd64 dist/archive.tar.gz
+
+# Build and upload for arm64
+GOOS=linux GOARCH=arm64 go build -o dist/module cmd/module/main.go
+tar -czf dist/archive.tar.gz -C dist module
+viam module upload --version=0.1.0 --platform=linux/arm64 dist/archive.tar.gz
+```
+
+### 6. Configure the module on a machine
+
+Once your module is in the registry, any machine in your organization can use it.
+
+1. In the [Viam app](https://app.viam.com), navigate to your machine's
+   **CONFIGURE** tab.
+2. Click **+** and select **Configuration block**.
+3. Search for your module by name or browse the registry.
+4. Add the module and create a component (or service) instance.
+5. Name the component and configure the attributes your module expects:
+
+```json
+{
+  "source_url": "https://api.example.com/sensor/data"
+}
+```
+
+7. Click **Save**.
+
+`viam-server` downloads the module from the registry, starts it, and makes the
+component available. Test it from the **CONTROL** tab.
+
+### 7. Manage versions
+
+**Release a new version:**
+
+```bash
+git add .
+git commit -m "Add humidity calibration offset"
+git tag v0.2.0
+git push origin main v0.2.0
+```
+
+If using cloud build, the workflow runs automatically. For manual upload:
+
+```bash
+viam module upload --version=0.2.0 --platform=linux/amd64 dist/archive.tar.gz
+```
+
+**Automatic updates:** By default, machines track the latest version. When you
+upload `v0.2.0`, all machines update automatically within a few minutes.
+
+**Pin to a specific version:**
+
+1. In the Viam app, go to the machine's **CONFIGURE** tab.
+2. Find the module in the configuration.
+3. Set the **Version** field to the specific version (for example, `0.1.0`).
+4. Click **Save**.
+
+**View module details:**
+
+You can view version history and details for your module in the
+[Viam registry](https://app.viam.com/registry).
+
+### 8. Keep meta.json in sync with your code
+
+As you add models to your module, you can auto-detect them from a built binary
+instead of editing `meta.json` by hand:
+
+```bash
+viam module update-models --binary ./bin/module
+```
+
+This inspects the binary, discovers registered models, and updates the `models`
+array in `meta.json`.
+
+Then push the updated metadata to the registry:
+
+```bash
+viam module update
+```
+
+### 9. Download a module
+
+To download a module from the registry (for testing or inspection):
+
+```bash
+viam module download --id my-org:my-sensor-module --version 0.1.0 --platform linux/amd64 --destination ./downloaded-module
+```
+
+### Platform constraints
+
+When uploading, you can attach platform constraint tags that restrict which
+machines can use a particular upload. For example, to require Debian:
+
+```bash
+viam module upload \
+    --version=0.1.0 \
+    --platform=linux/amd64 \
+    --tags=distro:debian \
+    dist/archive.tar.gz
+```
+
+The machine must report matching platform tags for the constrained upload to be
+selected. If no constraints are specified, the upload is available to all
+machines on that platform.
+
+### Upload limits
+
+The registry enforces these size limits:
+
+| Limit                          | Value  |
+| ------------------------------ | ------ |
+| Compressed package (`.tar.gz`) | 50 GB  |
+| Decompressed contents          | 250 GB |
+| Single file within package     | 25 GB  |
+
+Before uploading, the CLI validates that:
+
+- The entrypoint executable exists in the archive
+- The entrypoint has execute permissions
+- No symlinks escape the archive boundaries
+
+Use `--force` to skip these checks (not recommended for production uploads).
+
+## Try It
+
+1. Review the generated `meta.json` and build scripts in your module directory.
+2. Push your code to GitHub and add the Viam API key secrets.
+3. Tag a release (`v0.1.0`) to trigger a cloud build.
+4. Navigate to a machine in the Viam app and add your module from the registry.
+5. Configure a component and set the required attributes.
+6. Open the **CONTROL** tab and verify the component works.
+7. Tag a new release (`v0.2.0`) and verify the machine picks it up
+   automatically within a few minutes.
+
+## Troubleshooting
+
+{{< expand "Upload fails with \"not authenticated\"" >}}
+
+- Log in to the Viam CLI: `viam login`.
+- If using an API key, verify it has organization-level access.
+- Check that `VIAM_KEY_ID` and `VIAM_KEY_VALUE` are set correctly in your GitHub
+  secrets (for cloud build).
+
+{{< /expand >}}
+
+{{< expand "Upload fails with \"invalid meta.json\"" >}}
+
+- Verify `meta.json` is valid JSON. Run `python -m json.tool meta.json` or
+  `jq . meta.json` to check.
+- Confirm the `module_id` matches the format `namespace:module-name`.
+- Ensure all model entries have both `api` and `model` fields.
+
+{{< /expand >}}
+
+{{< expand "Module not appearing in the registry" >}}
+
+- Check the module's visibility. If it is `private`, it only appears for users
+  in your organization.
+- Verify the upload completed successfully.
+- The module may take a minute to propagate. Refresh the page and try again.
+
+{{< /expand >}}
+
+{{< expand "Machine cannot find the module" >}}
+
+- Verify the module version supports the machine's platform. If your machine
+  runs `linux/arm64` but you only uploaded for `linux/amd64`, the machine
+  cannot use it.
+- Check the module version. If the machine is pinned to a nonexistent version,
+  it will fail.
+- Confirm the machine is online and connected to the cloud.
+
+{{< /expand >}}
+
+{{< expand "Cloud build fails in GitHub Actions" >}}
+
+- Check the Actions tab in your GitHub repository for the build log.
+- If your repository's default branch is not `main` (for example, it uses `master`),
+  use `viam module build start --ref master`. The cloud build system expects
+  `main` by default.
+- Verify your `setup.sh` and `build.sh` scripts work locally.
+- Confirm the `build.path` in `meta.json` matches the actual output location.
+- Ensure the GitHub secrets are set and not expired.
+
+{{< /expand >}}
+
+{{< expand "Exec format error on target machine" >}}
+
+This means the binary was compiled for the wrong architecture. For example,
+you built on an x86 laptop but the target machine is ARM (Raspberry Pi).
+
+- Use [cloud build](#4-deploy-with-cloud-build-recommended) to compile for all
+  target platforms automatically.
+- If deploying manually, cross-compile with the correct `GOOS` and `GOARCH`
+  before uploading. See [Deploy manually](#5-deploy-manually-alternative).
+- Verify the platform flag in your `upload` command matches the binary's
+  architecture (for example, `--platform=linux/arm64` for Raspberry Pi 4).
+
+{{< /expand >}}
+
+{{< expand "Module works locally but fails after deployment" >}}
+
+- Check for hard-coded paths, missing environment variables, or dependencies
+  installed on your machine but not in the build environment.
+- For Python, verify all dependencies are in `requirements.txt`.
+- For Go, verify the binary is compiled for the correct target architecture.
+- Check the module logs in the **LOGS** tab.
+
+{{< /expand >}}
diff --git a/docs/build-modules/manage-modules.md b/docs/build-modules/manage-modules.md
new file mode 100644
index 0000000000..d13e9d127a
--- /dev/null
+++ b/docs/build-modules/manage-modules.md
@@ -0,0 +1,450 @@
+---
+title: "Update and manage modules you created"
+linkTitle: "Update and manage modules"
+type: "docs"
+weight: 32
+images: ["/registry/create-module.svg"]
+icon: true
+tags: ["modular resources", "components", "services", "registry"]
+description: "Update or delete your existing modules, or change their privacy settings."
+aliases:
+  - /use-cases/deploy-code/
+  - /use-cases/manage-modules/
+  - /how-tos/manage-modules/
+languages: []
+viamresources: []
+platformarea: ["registry"]
+level: "Beginner"
+date: "2024-06-30"
+# updated: ""  # When the tutorial was last entirely checked
+cost: "0"
+---
+
+After you [create and upload a module](/build-modules/write-a-driver-module/), you can update, delete, or change its visibility settings.
+
+For information on pinning module deployments to versions, see [Module versioning](/build-modules/deploy-a-module/#7-manage-versions).
+
+## Update a module
+
+Once your module is in the [registry](https://app.viam.com/registry), there are two ways to update it:
+
+- [Update automatically](#update-automatically-from-a-github-repo-with-cloud-build) using GitHub Actions: Recommended for ongoing projects with continuous integration (CI) workflows, or if you want to build for multiple platforms.
+
+  - If you enabled cloud build when you generated your module, the GitHub Actions are already set up for you.
+
+- [Update manually](#update-manually) using the [Viam CLI](/cli/): Fine for small projects with one contributor.
+
+### Update automatically from a GitHub repo with cloud build
+
+Use [GitHub Actions](https://docs.github.com/actions) to automatically build and deploy your new module version when you create a new release in GitHub:
+
+1. Edit your module code and update the [`meta.json`](/build-modules/module-reference/) file if needed.
+   For example, if you've changed the module's functionality, update the description in the `meta.json` file.
+
+   {{% alert title="Important" color="note" %}}
+   Make sure the `url` field contains the URL of the GitHub repo that contains your module code.
+   This field is required for cloud build to work.
+   {{% /alert %}}
+
+1. Push your changes to your module GitHub repository.
+
+   {{% alert title="Tip" color="tip" %}}
+
+   If you used `viam module generate` to create your module and enabled cloud build, and you followed all the [steps to deploy with cloud build](/build-modules/deploy-a-module/#4-deploy-with-cloud-build-recommended) including adding API keys for the build action, all you need to do to trigger a new build is publish a release in GitHub as you did when you first published the module.
+
+   {{% /alert %}}
+
+1. If you did not use the Viam CLI generator and enable cloud build, you can set up one of the following GitHub Actions up manually:
+
+   {{< tabs >}}
+   {{% tab name="build-action (Recommended)" %}}
+
+   The `build-action` GitHub action provides a cross-platform build setup for multiple platforms: x86, ARM Linux, and macOS.
+
+   In your repository, create a workflow file called <FILE>build.yml</FILE> in the <FILE>.github/workflows<FILE> directory:
+
+   ```yaml
+   on:
+     release:
+       types: [published]
+
+   jobs:
+     publish:
+       runs-on: ubuntu-latest
+       steps:
+         - uses: actions/checkout@v3
+         - uses: viamrobotics/build-action@v1
+           with:
+             version: ${{ github.ref_name }}
+             ref: ${{ github.sha }}
+             key-id: ${{ secrets.viam_key_id }}
+             key-value: ${{ secrets.viam_key_value }}
+             token: ${{ github.token }} # only required for private git repos
+   ```
+
+The `build-action` GitHub action relies on a build command that you need to specify in the <file>meta.json</file> file.
+At the end of your <file>meta.json</file>, add the build configuration:
+
+<!-- { {< tabs >}}
+{ {% tab name="Single Build File" %}} -->
+
+```json {class="line-numbers linkable-line-numbers" data-line="5-9"}
+{
+  "module_id": "example-module",
+  ...
+  "build": {
+    "setup": "./setup.sh", // optional - command for one-time setup
+    "build": "./build.sh", // command that will build your module's tarball
+    "path" : "dist/archive.tar.gz", // optional - path to your built module tarball
+    "arch" : ["linux/amd64", "linux/arm64", "darwin/arm64"], // architecture(s) to build for
+    "darwin_deps" : ["go", "x264", "nlopt-static"] // optional - Homebrew dependencies for Darwin builds. Explicitly pass `[]` for empty.
+  }
+}
+```
+
+{{% expand "Cloud build configuration attributes" %}}
+
+<!-- prettier-ignore -->
+| Attribute | Inclusion | Description |
+| --------- | --------- | ----------- |
+| `"setup"` | Optional | Command to run for setting up the build environment. |
+| `"build"` | **Required** | Command to run to build the module tarball. |
+| `"path"` | Optional | Path to the build module tarball. |
+| `"arch"` | **Required** | Array of architectures to build for. For more information see [Supported platforms for automatic updates](#supported-platforms-for-automatic-updates). |
+| `"darwin_deps"` | **Required** | Array of homebrew dependencies for Darwin builds. Explicitly pass `[]` for empty. Default: `["go", "pkg-config", "nlopt-static", "x264", "jpeg-turbo", "ffmpeg"]` |
+
+{{% /expand %}}
+
+{{< expand "Python module script examples" >}}
+
+The following code snippet demonstrates an example `setup.sh` for a Python module:
+
+```bash {class="line-numbers linkable-line-numbers"}
+#!/bin/sh
+cd `dirname $0`
+
+# Create a virtual environment to run our code
+VENV_NAME="venv"
+PYTHON="$VENV_NAME/bin/python"
+ENV_ERROR="This module requires Python >=3.8, pip, and virtualenv to be installed."
+
+if ! python3 -m venv $VENV_NAME >/dev/null 2>&1; then
+  echo "Failed to create virtualenv."
+  if command -v apt-get >/dev/null; then
+    echo "Detected Debian/Ubuntu, attempting to install python3-venv automatically."
+    SUDO="sudo"
+    if ! command -v $SUDO >/dev/null; then
+      SUDO=""
+    fi
+  if ! apt info python3-venv >/dev/null 2>&1; then
+    echo "Package info not found, trying apt update"
+    $SUDO apt -qq update >/dev/null
+  fi
+  $SUDO apt install -qqy python3-venv >/dev/null 2>&1
+  if ! python3 -m venv $VENV_NAME >/dev/null 2>&1; then
+    echo $ENV_ERROR >&2
+    exit 1
+  fi
+  else
+    echo $ENV_ERROR >&2
+    exit 1
+  fi
+fi
+
+# remove -U if viam-sdk should not be upgraded whenever possible
+# -qq suppresses extraneous output from pip
+echo "Virtualenv found/created. Installing/upgrading Python packages..."
+if ! [ -f .installed ]; then
+  if ! $PYTHON -m pip install -r requirements.txt -Uqq; then
+    exit 1
+  else
+    touch .installed
+  fi
+fi
+```
+
+The following code snippet demonstrates an example `build.sh` for a Python module:
+
+```bash {class="line-numbers linkable-line-numbers"}
+#!/bin/sh
+cd `dirname $0`
+
+# Create a virtual environment to run our code
+VENV_NAME="venv"
+PYTHON="$VENV_NAME/bin/python"
+
+if ! $PYTHON -m pip install pyinstaller -Uqq; then
+    exit 1
+fi
+
+$PYTHON -m PyInstaller --onefile --hidden-import="googleapiclient" src/main.py
+tar -czvf dist/archive.tar.gz ./dist/main
+```
+
+{{< /expand >}}
+
+You can test this build configuration by running the Viam CLI's [`build local` command](/cli/#using-the-build-subcommand) on your development machine:
+
+```sh {class="command-line" data-prompt="$"}
+viam module build local
+```
+
+The command will run your build instructions locally without running a cloud build job.
+
+For more details, see the [`build-action` GitHub Action documentation](https://github.com/viamrobotics/build-action), or take a look through one of the following example repositories that show how to package and deploy modules using the Viam SDKs:
+
+- [Golang CI yaml](https://github.com/viam-labs/wifi-sensor/blob/main/.github/workflows/build.yml)
+- [Golang Example CI meta.json](https://github.com/viam-labs/wifi-sensor/blob/main/meta.json)
+<!-- - [C++ Example CI yaml](https://github.com/viamrobotics/module-example-cpp/blob/main/.github/workflows/build2.yml)
+- [C++ Example CI meta.json](https://github.com/viamrobotics/module-example-cpp/blob/main/meta.json) -->
+
+  {{% /tab %}}
+  {{% tab name="upload-module" %}}
+
+  If you already have your own CI with access to arm runners or only intend to build on `x86` or `mac`, you can use the `upload-module` GitHub action instead which allows you to define the exact build steps.
+
+  Add this to your GitHub workflow:
+
+  ```yaml {class="line-numbers linkable-line-numbers"}
+  on:
+    push:
+    release:
+      types: [released]
+
+  jobs:
+    publish:
+      runs-on: ubuntu-latest
+      steps:
+        - uses: actions/checkout@v3
+        - name: build
+          run: echo "your build command goes here" && false # <-- replace this with the command that builds your module's tar.gz
+        - uses: viamrobotics/upload-module@v1
+          # if: github.event_name == 'release' # <-- once the action is working, uncomment this so you only upload on release
+          with:
+            module-path: module.tar.gz
+            platform: linux/amd64 # <-- replace with your target architecture, or your module will not deploy
+            version: ${{ github.event_name == 'release' && github.ref_name || format('0.0.0-{0}.{1}', github.ref_name, github.run_number) }} # <-- see 'Versioning' section below for explanation
+            key-id: ${{ secrets.viam_key_id }}
+            key-value: ${{ secrets.viam_key_value }}
+  ```
+
+Set `run` to the command you use to build and package your module, such as invoking a makefile or running a shell script.
+When you are ready to test the action, uncomment `if: github.event_name == 'release'` to enable the action to trigger a run when you [issue a release](https://docs.github.com/en/repositories/releasing-projects-on-github).
+
+For guidance on configuring the other parameters, see the documentation for each:
+
+- [`org-id`](/cli/#using-the---org-id-and---public-namespace-arguments): Not required if your module is public.
+- [`platform`](/cli/#using-the---platform-argument): You can only upload one platform at a time.
+- [`version`](https://github.com/viamrobotics/upload-module/blob/main/README.md#versioning): See [Using the --version argument](/cli/#using-the---version-argument) for more details on the types of versioning supported.
+
+For more details, see the [`upload-module` GitHub Action documentation](https://github.com/viamrobotics/upload-module), or take a look through one of the following example repositories that show how to package and deploy modules using the Viam SDKs:
+
+- [Python with virtualenv](https://github.com/viam-labs/python-example-module)
+- [Python with docker](https://github.com/viamrobotics/python-container-module)
+- [Golang](https://github.com/viam-labs/wifi-sensor)
+- [C++](https://github.com/viamrobotics/module-example-cpp)
+
+  {{% /tab %}}
+  {{< /tabs >}}
+
+3. [Create an organization API key](/cli/#create-an-organization-api-key) with owner role:
+
+   ```sh {class="command-line" data-prompt="$"}
+   viam organizations api-key create --org-id <org-id> --name <key-name>
+   ```
+
+1. Add the key ID and value as GitHub repository secrets named `viam_key_id` and `viam_key_value`.
+
+1. Create a [release](https://docs.github.com/en/repositories/releasing-projects-on-github) in GitHub to trigger the build.
+   The build can be quick or take over 15 minutes to complete, depending on factors including the size of the module.
+
+   Once the build is complete, the module will automatically update in the [registry](https://app.viam.com/registry), and the machines set to use the latest [version](/build-modules/deploy-a-module/#7-manage-versions) of the module will automatically update to the new version.
+
+#### Supported platforms for automatic updates
+
+When using cloud build, you can specify which platforms you want to build your module for in the `arch` field of your `meta.json` file.
+The following table lists all available platforms:
+
+<!-- prettier-ignore -->
+| Platform | Supported in cloud build | Container used by cloud build | Notes |
+| -------- | ------------------------ | ----------------------------- | ----- |
+| `linux/amd64` | ✅ | Ubuntu | Standard x86_64 Linux platform. |
+| `linux/arm64` | ✅ | Ubuntu | For ARM64 Linux devices like Raspberry Pi 4. |
+| `darwin/arm64` | ✅ | macOS | For Apple Silicon Macs (M1/M2/M3). |
+| `linux/arm32v6` | ❌ | N/A | For older ARM devices; must be built manually. |
+| `linux/arm32v7` | ❌ | N/A | For 32-bit ARM devices; must be built manually. |
+| `windows/amd64` | ⚠️ | N/A | <ul><li>Cloud builds work for Go modules but have issues linking to C libraries.</li><li>Windows support is still in development.</li></ul> |
+| `darwin/amd64` | ❌ | N/A | Intel Macs; must be built manually. You can choose to support it, though many modules do not since Apple is phasing out this platform. |
+
+{{% alert title="Note" color="note" %}}
+While the registry supports additional platforms like `windows/amd64`, `linux/arm32v6`, and `linux/arm32v7`, these are not currently supported by cloud build and must be [built and uploaded manually](#update-manually).
+{{% /alert %}}
+
+### Update manually
+
+Use the [Viam CLI](/cli/) to manually update your module:
+
+1. Edit your module code and update the [`meta.json`](/build-modules/module-reference/) file if needed.
+   For example, if you've changed the module's functionality, update the description in the `meta.json` file.
+
+2. Package your module files as an archive:
+
+   ```sh {class="command-line" data-prompt="$"}
+   tar -czf module.tar.gz run.sh requirements.txt src meta.json
+   ```
+
+   For Go modules, build the binary first, then package it:
+
+   ```sh {class="command-line" data-prompt="$"}
+   tar -czf module.tar.gz my-module meta.json
+   ```
+
+   Supply the path to the resulting archive file in the next step.
+
+3. Upload to the Viam Registry:
+
+   ```sh {class="command-line" data-prompt="$"}
+   viam module upload --version <version> --platform <platform> <module-path>
+   ```
+
+   For example, `viam module upload --version 1.0.1 --platform darwin/arm64 my-module.tar.gz`.
+
+When you `upload` a module, the command performs basic [validation](/cli/#upload-validation) of your module to check for common errors.
+
+For more information, see the [`viam module` command](/cli/#module).
+
+## Change module visibility
+
+You can change the visibility of a module from public to private if:
+
+- you are an [owner](/organization/rbac/) of the {{< glossary_tooltip term_id="organization" text="organization" >}} that owns the module, AND
+- no machines outside of the organization that owns the module have the module configured (no other orgs are using it).
+
+To change the visibility:
+
+1. Navigate to your module's page in the [registry](https://app.viam.com/registry).
+2. Hover to the right of the visibility indicator near the right side of the page until an **Edit** button appears, and click it to make changes.
+
+   {{<imgproc src="/registry/upload/edit-module-visibility.png" resize="x150" declaredimensions=true alt="A module page with a Visibility heading on the right side. Under it, an Edit button has appeared." class="shadow" >}}
+
+   The options are:
+
+   - **Private**: Only users inside your organization can view, use, and edit the module.
+   - **Public**: Any user inside or outside of your organization can view, use, and edit the module.
+   - **Unlisted**: Any user inside or outside of your organization, with a direct link, can view and use the module.
+     Only organization members can edit the module.
+     Not listed in the registry for users outside of your organization.
+
+You can also edit the visibility by editing the [meta.json](/build-modules/module-reference/) file and then running the following [CLI](/cli/#module) command:
+
+```sh {id="terminal-prompt" class="command-line" data-prompt="$"}
+viam module update
+```
+
+{{% hiddencontent %}}
+If you don't see a private module of yours in the registry, make sure that you have the correct organization selected in the upper right corner of the page.
+{{% /hiddencontent %}}
+
+## Delete a module
+
+You can delete a module if:
+
+- you are an [owner](/organization/rbac/) in the {{< glossary_tooltip term_id="organization" text="organization" >}} that owns the module, AND
+- no machines have the module configured.
+
+To delete a module:
+
+1. Navigate to its page in the [registry](https://app.viam.com/registry).
+2. Click the **...** menu in the upper-right corner of the page, and click **Delete**.
+
+   {{<imgproc src="/registry/upload/delete-module.png" resize="x200" declaredimensions=true alt="A module page with the ... menu open. Delete is the only option in the menu." class="shadow" >}}
+
+{{% alert title="Note" color="note" %}}
+
+If you need to delete a module and the delete option is unavailable to you, please [contact our support team](mailto:contact@viam.com) for assistance.
+
+{{% /alert %}}
+
+{{% hiddencontent %}}
+Other registry items such as training scripts and ML models can be deleted in the same way as modules.
+{{% /hiddencontent %}}
+
+### Delete just one version of a module
+
+Deleting a version of a module requires the same org owner permissions as deleting the entire module, and similarly, you cannot delete a version if any machines are using it.
+To delete just one version of a module:
+
+1. Navigate to its page in the [registry](https://app.viam.com/registry).
+
+1. Click **Show previous versions** under the **Latest version** heading.
+
+1. Hover on the architecture pill next to the version you'd like to delete and click the trash icon.
+
+You cannot upload a new file with the same version number as the deleted one.
+To upload another version, you must increment the version number to a later version number.
+
+## Transfer ownership of a module
+
+To transfer ownership of a module from one organization to another:
+
+1. You must be an [owner](/organization/rbac/) in both the current and new organizations.
+
+1. Navigate to the module's page in the [registry](https://app.viam.com/registry).
+
+1. Make sure the visibility of the module is set to **Public**.
+
+1. Click the **...** menu in the upper-right corner of the page, and click **Transfer ownership**.
+
+1. Select the new organization from the dropdown menu, then click **Transfer module**.
+
+1. (Recommended) Transfer the GitHub repository containing the module code to the new owner.
+   Be sure to remove the existing secrets from the repository's settings before transferring.
+   If the repository is using Viam's cloud build, the secrets contain an organization API key that will be exposed to the new owner after the repository transfer.
+
+1. Update the `meta.json` file to reflect the new organization:
+
+   - Change the first part of the `module_id` field to the new organization's [namespace](/build-modules/module-reference/#organization-namespace).
+   - For each model, change the first part of the `model` field to the new organization's namespace.
+   - Update the `url` field to point to the new code repository if it has moved.
+
+1. Update the module code:
+
+   - Throughout your module implementation code, change the model names in your component or service classes to match the changes you made to the `meta.json` file.
+
+1. Publish a new version of the module to the registry by following either set of update steps on this page.
+   This ensures that the model names in the module code match the registered model names in the registry.
+
+1. (Recommended) Update the `model` field in the configuration of any machines that use the module to use the new organization's namespace.
+   Viam maintains backwards compatibility with the old namespace, but you should update the configuration to use the new namespace to avoid confusion.
+
+## Rename a module
+
+You can rename a module that your organization owns through the Viam web interface.
+To rename a module:
+
+1. Navigate to your module page at `app.viam.com/module/<namespace>/<module-name>`.
+1. Click the **...** menu in the top right corner of the module page.
+1. Select **Rename** from the dropdown menu.
+1. Enter the new module name in the modal that appears.
+1. Click **Rename** to confirm the change.
+
+When you rename a module, Viam reserves the old module name for backwards compatibility and you cannot reuse it.
+
+Existing machine configurations containing the old module name will continue to work.
+
+{{% hiddencontent %}}
+
+## Rename a model
+
+If you need to change the name of a model that a module implements, do the following:
+
+1. Update the `model` field in the `meta.json` file to the new model name.
+
+1. Update the model name in the module code to match the new model name.
+
+1. Publish a new version of the module to the registry by following either set of update steps on this page.
+
+1. (Recommended) Update the configuration of any machines that use the module to use the new model name.
+   Viam maintains backwards compatibility with the old model name, but updating the configuration is recommended to avoid confusion.
+
+{{% /hiddencontent %}}
diff --git a/docs/build-modules/module-anatomy.md b/docs/build-modules/module-anatomy.md
new file mode 100644
index 0000000000..ca8fe793e6
--- /dev/null
+++ b/docs/build-modules/module-anatomy.md
@@ -0,0 +1,483 @@
+---
+linkTitle: "Anatomy of a module"
+title: "Anatomy of a module"
+weight: 5
+layout: "docs"
+type: "docs"
+description: "Understand the directory structure and key files that make up a Viam module."
+---
+
+When you run `viam module generate`, the CLI creates a complete project with
+everything you need to build, test, and deploy a module. This page explains
+the purpose of each file and when you need to edit it.
+
+The examples on this page use a logic module called `temp-monitor` that
+monitors a temperature sensor and logs a warning when readings exceed a
+threshold. It depends on one sensor and uses `DoCommand` to report its
+current state.
+
+## Directory structure
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```text
+temp-monitor/
+├── .github/
+│   └── workflows/
+│       └── deploy.yml            # CI workflow for cloud builds
+├── src/
+│   ├── main.py                   # Entry point
+│   └── models/
+│       └── temp_monitor.py       # Resource implementation
+├── build.sh                      # Packages the module for upload
+├── meta.json                     # Module metadata for the registry
+├── requirements.txt              # Python dependencies
+├── run.sh                        # Entrypoint script for viam-server
+└── setup.sh                      # Installs dependencies into a virtualenv
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```text
+temp-monitor/
+├── .github/
+│   └── workflows/
+│       └── deploy.yml            # CI workflow for cloud builds
+├── cmd/
+│   └── module/
+│       └── main.go               # Entry point
+├── temp_monitor.go               # Resource implementation
+├── go.mod                        # Go module definition
+├── go.sum                        # Dependency checksums
+├── Makefile                      # Build targets
+├── meta.json                     # Module metadata for the registry
+├── build.sh                      # Packages the module for upload
+└── setup.sh                      # Installs build dependencies
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Resource implementation
+
+This is the main file you work in. The generator names it after the model you are implementing. A model implements a Viam API.
+In this example, that is `src/models/temp_monitor.py` in Python and
+`temp_monitor.go` in Go. The sections below walk through each section of this file.
+
+### Model definition
+
+The model definition identifies your resource in the registry as a triplet
+of namespace, module name, and model name. Some examples from built-in Viam
+modules: `viam:camera:webcam`, `viam:motor:gpio`, `viam:sensor:ultrasonic`.
+In our example, the triplet is `my-org:temp-monitor:temp-monitor`.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+class TempMonitor(Generic, EasyResource):
+    MODEL: ClassVar[Model] = Model(
+        ModelFamily("my-org", "temp-monitor"), "temp-monitor"
+    )
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+var Model = resource.NewModel("my-org", "temp-monitor", "temp-monitor")
+
+func init() {
+    resource.RegisterService(generic.API, Model, resource.Registration[
+        resource.Resource, *Config,
+    ]{
+        Constructor: newTempMonitor,
+    })
+}
+```
+
+In Go, the `init()` function registers the model with `viam-server` when
+the package is imported. The registration binds the model to the generic
+service API and points to the constructor function.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Config and attributes
+
+Config attributes are the fields a user sets when they add the service this model implements to a
+machine. Each field maps to a key in the `attributes` block of the JSON
+config:
+
+```json
+"attributes": {
+  "sensor_name": "temp-1",
+  "threshold": 40.0
+}
+```
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+    sensor_name: str
+    threshold: float
+    sensor: Sensor
+    exceeded: bool
+```
+
+In Python, declare config attributes, resolved dependencies, and runtime
+state as instance variables on the class. This pattern is the same for any
+module you write. Only the specific variables change.
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+type Config struct {
+    SensorName string  `json:"sensor_name"`
+    Threshold  float64 `json:"threshold"`
+}
+
+type TempMonitor struct {
+    resource.Named
+    logger   logging.Logger
+    cfg      *Config
+    sensor   sensor.Sensor
+    mu       sync.Mutex
+    exceeded bool
+    cancelFn func()
+}
+```
+
+In Go, the `Config` struct defines the attributes. The `json` tags map each
+field to its key in the JSON config. The resource struct holds the parsed
+config, resolved dependencies, and runtime state. This pattern is the same
+for any module you write. Only the specific fields change.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Validation
+
+The validation method checks that attributes are valid and declares
+dependencies on other resources. `viam-server` calls this before creating or
+reconfiguring the resource. It returns two lists: required dependencies and
+optional dependencies.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+    @classmethod
+    def validate_config(
+        cls, config: ComponentConfig
+    ) -> Tuple[Sequence[str], Sequence[str]]:
+        fields = config.attributes.fields
+        if "sensor_name" not in fields:
+            raise Exception("sensor_name is required")
+        return [fields["sensor_name"].string_value], []
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+func (cfg *Config) Validate(path string) ([]string, []string, error) {
+    if cfg.SensorName == "" {
+        return nil, nil, fmt.Errorf("sensor_name is required")
+    }
+    return []string{cfg.SensorName}, nil, nil
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Constructor
+
+`viam-server` calls the constructor when it creates your resource. The
+constructor receives the config (containing the attributes the user set), a dependencies
+map (containing running instances of the resources you declared in your
+validation method), and in Go, a context and a logger.
+
+If your resource uses `AlwaysRebuild` (the generated default in Go),
+`viam-server` destroys and re-creates the resource on every config change,
+calling the constructor again. If you implement a `Reconfigure` method
+instead, `viam-server` calls that method in place without re-creating the
+resource.
+
+The constructor's job is to:
+
+1. **Parse the config** into typed fields you can use (for example, extract
+   `sensor_name` as a string and `threshold` as a float).
+2. **Resolve dependencies** by looking up each one by name from the
+   dependencies map. Each entry is a ready-to-use resource instance that
+   `viam-server` has already started.
+3. **Store everything on the struct or instance** so your API methods and
+   background tasks can use them.
+4. **Start background work** if your module runs continuously (for example,
+   a goroutine or async task that polls a sensor on an interval).
+
+To resolve a dependency, you look it up by name from the dependencies map.
+In Go, every resource type in the SDK provides a `FromDependencies` helper
+that does this and returns a typed interface (for example,
+`sensor.FromDependencies` returns a `sensor.Sensor`). In Python, you build
+the key with `Sensor.get_resource_name(name)` and index into the
+dependencies map directly.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+    @classmethod
+    async def new(cls, config, dependencies) -> Self:
+        monitor = cls(config.name)
+        monitor.exceeded = False
+        monitor.reconfigure(config, dependencies)
+        return monitor
+
+    def reconfigure(self, config, dependencies) -> None:
+        fields = config.attributes.fields
+        self.sensor_name = fields["sensor_name"].string_value
+        self.threshold = (
+            fields["threshold"].number_value
+            if "threshold" in fields
+            else 100.0
+        )
+
+        self.sensor = dependencies[
+            Sensor.get_resource_name(self.sensor_name)
+        ]
+
+        ...
+```
+
+In Python, the common pattern is for `new` to call `reconfigure` so that
+config-reading and dependency resolution logic lives in one place.
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+func newTempMonitor(
+    ctx context.Context,
+    deps resource.Dependencies,
+    conf resource.Config,
+    logger logging.Logger,
+) (resource.Resource, error) {
+    cfg, err := resource.NativeConfig[*Config](conf)
+    if err != nil {
+        return nil, err
+    }
+    if cfg.Threshold == 0 {
+        cfg.Threshold = 100.0
+    }
+
+    s, err := sensor.FromDependencies(deps, cfg.SensorName)
+    if err != nil {
+        return nil, err
+    }
+
+    monitorCtx, cancelFn := context.WithCancel(context.Background())
+    tm := &TempMonitor{
+        Named:    conf.ResourceName().AsNamed(),
+        logger:   logger,
+        cfg:      cfg,
+        sensor:   s,
+        cancelFn: cancelFn,
+    }
+    go tm.monitor(monitorCtx)
+    return tm, nil
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### API methods
+
+API methods are how external code interacts with your resource. For a logic
+module using the generic service API, the method is `DoCommand`. It accepts
+and returns arbitrary key-value maps, so you define your own command
+vocabulary.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+    async def do_command(self, command, **kwargs):
+        if command.get("command") == "status":
+            return {
+                "exceeded": self.exceeded,
+                "threshold": self.threshold,
+            }
+        return {"error": f"unknown command: {command.get('command')}"}
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+func (tm *TempMonitor) DoCommand(
+    ctx context.Context, cmd map[string]interface{},
+) (map[string]interface{}, error) {
+    if cmd["command"] == "status" {
+        tm.mu.Lock()
+        defer tm.mu.Unlock()
+        return map[string]interface{}{
+            "exceeded":  tm.exceeded,
+            "threshold": tm.cfg.Threshold,
+        }, nil
+    }
+    return nil, fmt.Errorf("unknown command: %v", cmd["command"])
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Close
+
+`viam-server` calls `Close` when it shuts down or removes the resource. Stop
+background tasks and release any resources here.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+    async def close(self):
+        self._stop_event.set()
+        if self._monitor_task is not None:
+            await self._monitor_task
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+func (tm *TempMonitor) Close(ctx context.Context) error {
+    tm.cancelFn()
+    return nil
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+For complete working examples, see
+[Write a logic module](/build-modules/write-a-logic-module/) and
+[Write a driver module](/build-modules/write-a-driver-module/).
+
+## meta.json
+
+Module metadata used by the Viam registry. The generator creates this file
+and populates it from your answers to the generator prompts.
+
+```json
+{
+  "module_id": "my-org:temp-monitor",
+  "visibility": "private",
+  "url": "https://github.com/my-org/temp-monitor",
+  "description": "Logs a warning when a temperature sensor exceeds a threshold.",
+  "models": [
+    {
+      "api": "rdk:service:generic",
+      "model": "my-org:temp-monitor:temp-monitor"
+    }
+  ],
+  "entrypoint": "run.sh",
+  "build": {
+    "setup": "./setup.sh",
+    "build": "./build.sh",
+    "path": "dist/archive.tar.gz",
+    "arch": ["linux/amd64", "linux/arm64"]
+  }
+}
+```
+
+| Field         | Purpose                                                             |
+| ------------- | ------------------------------------------------------------------- |
+| `module_id`   | Unique ID in the registry. Format: `namespace:name`.                |
+| `visibility`  | Who can install the module: `private`, `public`, `public_unlisted`. |
+| `url`         | Link to the source repository. Required for cloud builds.           |
+| `description` | Shown in registry search results.                                   |
+| `models`      | Resource models the module provides, each with `api` and `model`.   |
+| `entrypoint`  | Command that starts the module inside the archive.                  |
+| `build.setup` | Script that installs build dependencies (runs once).                |
+| `build.build` | Script that compiles and packages the module.                       |
+| `build.path`  | Path to the packaged output archive.                                |
+| `build.arch`  | Target platforms to build for.                                      |
+
+For the full schema, see
+[Module developer reference](/build-modules/module-reference/#metajson-schema).
+
+## Files you rarely edit
+
+### Entry point
+
+The entry point starts the module server and registers your models with
+`viam-server`. You only edit this file when you add a second model to the
+module.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+**`src/main.py`**
+
+```python
+import asyncio
+from viam.module.module import Module
+from models.temp_monitor import TempMonitor  # noqa: F401
+
+if __name__ == "__main__":
+    asyncio.run(Module.run_from_registry())
+```
+
+`run_from_registry()` discovers all imported resource classes and registers
+them. To add another model, import its class here.
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+**`cmd/module/main.go`**
+
+```go
+package main
+
+import (
+    tempmonitor "my-org/temp-monitor"
+    "go.viam.com/rdk/module"
+    "go.viam.com/rdk/resource"
+    "go.viam.com/rdk/services/generic"
+)
+
+func main() {
+    module.ModularMain(
+        resource.APIModel{generic.API, tempmonitor.Model},
+    )
+}
+```
+
+`ModularMain` handles socket parsing, signal handling, and graceful shutdown.
+The import of the resource package triggers its `init()` function, which
+registers the model. To add another model, add another `resource.APIModel`
+entry.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Build and deploy scripts
+
+These scripts handle packaging and deployment. The generator creates working
+defaults. You only need to edit them if your module has unusual build
+requirements.
+
+| File         | Purpose                                                                                        |
+| ------------ | ---------------------------------------------------------------------------------------------- |
+| `build.sh`   | Compiles (Go) or packages (Python) the module into a `.tar.gz` archive.                        |
+| `setup.sh`   | Installs build dependencies. For Python, creates a virtualenv and installs `requirements.txt`. |
+| `run.sh`     | (Python only) Entrypoint script that activates the virtualenv and runs `main.py`.              |
+| `deploy.yml` | GitHub Actions workflow that triggers cloud builds on tagged releases.                         |
diff --git a/docs/build-modules/module-reference.md b/docs/build-modules/module-reference.md
new file mode 100644
index 0000000000..be43563eda
--- /dev/null
+++ b/docs/build-modules/module-reference.md
@@ -0,0 +1,587 @@
+---
+linkTitle: "Module reference"
+title: "Module developer reference"
+weight: 40
+layout: "docs"
+type: "docs"
+description: "Reference for module developers: lifecycle, interfaces, meta.json schema, CLI commands, environment variables, and registry rules."
+date: "2025-03-05"
+aliases:
+  - /development/module-reference/
+---
+
+This page is a reference for module developers. For step-by-step
+instructions, see [Write a Module](/build-modules/write-a-driver-module/) and
+[Deploy a Module](/build-modules/deploy-a-module/).
+
+## Module lifecycle
+
+Every module, local or registry, runs as a separate child process alongside
+`viam-server`, communicating over [gRPC](#module-protocol).
+
+1. `viam-server` starts and checks for configuration updates (if online).
+2. If the module has a [`first_run`](#first-run-scripts) script that hasn't
+   succeeded yet, `viam-server` runs it before starting the module.
+3. `viam-server` starts each configured module as a child process, passing it a
+   socket address.
+4. The module registers its models and APIs with `viam-server` through the
+   [`Ready` RPC](#module-protocol).
+5. For each configured resource, `viam-server` calls `ValidateConfig` to check
+   attributes and discover dependencies.
+6. `viam-server` starts required dependencies first. If a required dependency
+   fails, the resource that depends on it does not start.
+7. `viam-server` calls `AddResource` to create each resource. The module's
+   constructor runs, typically calling `Reconfigure` to read config.
+8. The resource is available for use.
+9. When the user changes configuration, `viam-server` calls
+   `ReconfigureResource`. Your `Reconfigure` method should complete
+   within the per-resource configuration timeout (default: 2 minutes,
+   configurable with `VIAM_RESOURCE_CONFIGURATION_TIMEOUT`).
+10. On shutdown, `viam-server` sends `RemoveResource` for each resource, then
+    terminates the module process.
+
+### First-run scripts
+
+If your module needs one-time setup (installing system packages, downloading
+models, etc.), set the `first_run` field in [`meta.json`](#metajson-schema) to
+the path of a setup script inside your archive.
+
+- The script runs **before** the module entrypoint, with the same
+  [environment variables](#environment-variables) available to the module.
+- If the script exits with a non-zero status, reconfiguration is aborted.
+  Currently running modules continue with their previous configuration.
+- On success, a `.first_run_succeeded` marker file is created next to the
+  module binary. The script will not re-run unless this marker is deleted
+  or a new module version is installed.
+- The default timeout is 1 hour, configurable through `first_run_timeout` in the
+  module config.
+
+### Crash recovery
+
+If a module process crashes, `viam-server` automatically restarts it:
+
+1. `viam-server` detects the exit and marks the module as failed.
+2. The machine's status changes to **initializing**.
+3. `viam-server` retries every 5 seconds.
+4. On success, `viam-server` re-adds all resources in dependency order.
+5. The machine returns to **running**.
+
+If the module keeps crashing, `viam-server` retries indefinitely. Check the
+**LOGS** tab for crash tracebacks.
+
+### Communication
+
+By default, modules communicate with `viam-server` over a Unix domain socket
+with a randomized name.
+
+TCP mode is used automatically on Windows or when the Unix socket path would
+exceed the OS limit (103 characters on macOS). Force TCP mode by setting
+`"tcp_mode": true` in the module config or setting `VIAM_TCP_SOCKETS=true`.
+
+### Data directory
+
+Every module receives a persistent data directory at
+`~/.viam/module-data/<robot-id>/<module-name>/`. The path is available inside
+the module through the `VIAM_MODULE_DATA` environment variable. This directory
+persists across module restarts and reconfigurations.
+
+### Timeouts
+
+| Event                                   | Timeout                                                        | Behavior on timeout                       |
+| --------------------------------------- | -------------------------------------------------------------- | ----------------------------------------- |
+| Module startup (ready check)            | 5 minutes (configurable through `VIAM_MODULE_STARTUP_TIMEOUT`) | Module marked as failed; retry begins     |
+| Config validation                       | 5 seconds                                                      | Validation fails; resource does not start |
+| Resource removal during shutdown        | 20 seconds (all resources combined)                            | Resources orphaned                        |
+| Module closure (removal + process stop) | ~30 seconds total                                              | Process killed                            |
+| First-run setup script                  | 1 hour (configurable through `first_run_timeout`)              | Module startup fails                      |
+| Crash restart retry interval            | 5 seconds                                                      | Next attempt after delay                  |
+
+## Resource interfaces (Go)
+
+### Config validation
+
+```go
+type ConfigValidator interface {
+    Validate(path string) (requiredDependencies, optionalDependencies []string, err error)
+}
+```
+
+Return required dependency names in the first slice. `viam-server` ensures they
+are ready before calling your constructor. Return optional dependency names in
+the second slice. These are passed to the constructor if available, but their
+absence does not block startup.
+
+### Resource interface
+
+Every resource must implement:
+
+```go
+type Resource interface {
+    Name() Name
+    Reconfigure(ctx context.Context, deps Dependencies, conf Config) error
+    DoCommand(ctx context.Context, cmd map[string]interface{}) (map[string]interface{}, error)
+    Close(ctx context.Context) error
+}
+```
+
+Plus the methods defined by the specific API (for example, `Readings` for sensor,
+`GetImages` for camera).
+
+### Constructor signature
+
+```go
+func(ctx context.Context, deps resource.Dependencies,
+    conf resource.Config, logger logging.Logger) (ResourceT, error)
+```
+
+### Helper traits
+
+Embed these in your resource struct to get default implementations:
+
+| Trait                              | Effect                                                                                           |
+| ---------------------------------- | ------------------------------------------------------------------------------------------------ |
+| `resource.Named`                   | Interface for `Name()` and `DoCommand()`. Embed and set through `conf.ResourceName().AsNamed()`. |
+| `resource.TriviallyCloseable`      | `Close()` returns nil.                                                                           |
+| `resource.TriviallyReconfigurable` | `Reconfigure()` returns nil (no-op).                                                             |
+| `resource.AlwaysRebuild`           | `Reconfigure()` returns `MustRebuildError` (always re-create).                                   |
+| `resource.TriviallyValidateConfig` | `Validate()` returns no deps and no error.                                                       |
+
+### Useful functions
+
+| Function                          | Description                                                                          |
+| --------------------------------- | ------------------------------------------------------------------------------------ |
+| `resource.NativeConfig[*T](conf)` | Convert config attributes to a typed struct.                                         |
+| `<api>.FromProvider(deps, name)`  | Type-safe dependency lookup (for example, `sensor.FromProvider(deps, "my-sensor")`). |
+| `conf.ResourceName().AsNamed()`   | Create a `Named` implementation from config.                                         |
+| `module.ModularMain(models...)`   | Convenience entry point for simple modules.                                          |
+| `module.NewModuleFromArgs(ctx)`   | Create a module from CLI args (for custom entry points).                             |
+| `module.NewLoggerFromArgs(name)`  | Create a logger that routes to `viam-server`.                                        |
+
+## Resource interfaces (Python)
+
+### Config validation
+
+```python
+@classmethod
+def validate_config(cls, config: ComponentConfig) -> Tuple[Sequence[str], Sequence[str]]:
+    # Return (required_deps, optional_deps)
+    return [], []
+```
+
+### Constructor
+
+```python
+@classmethod
+def new(cls, config: ComponentConfig,
+        dependencies: Mapping[ResourceName, ResourceBase]) -> Self:
+    instance = cls(config.name)
+    instance.reconfigure(config, dependencies)
+    return instance
+```
+
+### Reconfigure
+
+```python
+def reconfigure(self, config: ComponentConfig,
+                dependencies: Mapping[ResourceName, ResourceBase]) -> None:
+    # Update internal state from new config
+    pass
+```
+
+### Close
+
+```python
+async def close(self):
+    # Clean up connections, stop background tasks, release hardware.
+    # Must be idempotent (safe to call multiple times).
+    pass
+```
+
+The default `close()` on `ResourceBase` is a no-op.
+
+### EasyResource base class
+
+For simple modules, inherit from both the API base class and `EasyResource` to
+get default `new()`, `validate_config()`, and automatic model registration:
+
+```python
+from viam.components.sensor import Sensor
+from viam.resource.easy_resource import EasyResource
+from viam.module.module import Module
+
+
+class MySensor(Sensor, EasyResource):
+    MODEL = "my-org:my-module:my-sensor"
+
+    async def get_readings(self, **kwargs):
+        return {"temperature": 23.5}
+
+
+if __name__ == '__main__':
+    import asyncio
+    asyncio.run(Module.run_from_registry())
+```
+
+### Useful functions
+
+| Function                          | Description                                                      |
+| --------------------------------- | ---------------------------------------------------------------- |
+| `Module.from_args()`              | Create a module from CLI args.                                   |
+| `Module.run_from_registry()`      | Discover and register all imported resource classes, then start. |
+| `Module.run_with_models(*models)` | Register explicit model classes, then start.                     |
+| `getLogger(name)`                 | Create a logger (`from viam.logging import getLogger`).          |
+| `config.attributes.fields`        | Access raw config attributes (no typed config equivalent to Go). |
+
+### Python and Go defaults
+
+In Python, the default behavior when you don't implement a method differs from Go:
+
+| Behavior                 | Go                                       | Python                                                                                   |
+| ------------------------ | ---------------------------------------- | ---------------------------------------------------------------------------------------- |
+| Seamless reconfigure     | Implement `Reconfigure()`                | Implement `reconfigure()` (called if your class satisfies the `Reconfigurable` protocol) |
+| Rebuild on config change | Embed `resource.AlwaysRebuild`           | Omit `reconfigure()` (default: module destroys and re-creates the resource)              |
+| No-op reconfigure        | Embed `resource.TriviallyReconfigurable` | No equivalent: implement an empty `reconfigure()` instead                                |
+| No-op close              | Embed `resource.TriviallyCloseable`      | Default on `ResourceBase`                                                                |
+| Skip config validation   | Embed `resource.TriviallyValidateConfig` | Default on `EasyResource`                                                                |
+
+## Logging
+
+From modules you can log at the resource level or at the machine level.
+Resource-level logging is recommended because it makes it easier to identify
+which component or service produced a message. Resource-level error logs also
+appear in the **Error logs** section of each resource's configuration card.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+# Resource-level logging (recommended):
+self.logger.debug("debug info")
+self.logger.info("info")
+self.logger.warn("warning info")
+self.logger.error("error info")
+self.logger.exception("error info", exc_info=True)
+self.logger.critical("critical info")
+```
+
+For machine-level logging instead of resource-level:
+
+```python
+from viam.logging import getLogger
+
+LOGGER = getLogger(__name__)
+
+LOGGER.debug("debug info")
+LOGGER.info("info")
+LOGGER.warn("warning info")
+LOGGER.error("error info")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+func (c *component) someFunction(ctx context.Context, a int) {
+  // Log with severity info:
+  c.logger.CInfof(ctx, "performing some function with a=%v", a)
+  // Log with severity debug (using value wrapping):
+  c.logger.CDebugw(ctx, "performing some function", "a" ,a)
+  // Log with severity warn:
+  c.logger.CWarnw(ctx, "encountered warning for component", "name", c.Name())
+  // Log with severity error without a parameter:
+  c.logger.CError(ctx, "encountered an error")
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+To see debug-level logs, run `viam-server` with the `-debug` flag or
+[configure debug logging](/operate/reference/viam-server/#logging) for your
+machine or individual resource.
+
+## Common gotchas
+
+**Always call `Reconfigure` from your constructor.**
+Your constructor and `Reconfigure` should share the same config-reading logic.
+The typical pattern is for the constructor to create the struct, then call
+`Reconfigure` to populate it from config. This avoids duplicating config
+parsing and ensures a newly created resource is fully configured.
+
+**Clean up in `Close()`.**
+If your resource starts background goroutines, opens connections, or holds
+hardware handles, `Close()` must stop them. Leaked goroutines accumulate across
+reconfigurations and can cause instability.
+In Python, `close()` must be idempotent (it may be called more than once).
+
+**Return the right dependency names from `Validate`.**
+Dependencies listed as required in `Validate` (Go) or `validate_config`
+(Python) must match actual resource names in the machine config. If the name
+is wrong, `viam-server` waits for a resource that will never exist, and your
+resource will not start. Use optional dependencies for resources that improve
+functionality but aren't strictly needed.
+
+**Prefer `Reconfigure` over `AlwaysRebuild`.**
+`AlwaysRebuild` (Go) or omitting `reconfigure()` (Python) causes the resource
+to be destroyed and re-created on every config change. This is simpler but
+causes a brief availability gap. Implementing `Reconfigure` to update state
+in-place provides seamless reconfiguration.
+
+## Module protocol
+
+Modules communicate with `viam-server` over gRPC using the `ModuleService`
+defined in `proto/viam/module/v1/module.proto`:
+
+All RPCs are initiated by `viam-server` and handled by the module:
+
+| RPC                   | Purpose                                                  |
+| --------------------- | -------------------------------------------------------- |
+| `Ready`               | Handshake: module returns its supported API/model pairs. |
+| `AddResource`         | Create a new resource instance from config.              |
+| `ReconfigureResource` | Update an existing resource with new config.             |
+| `RemoveResource`      | Destroy a resource instance.                             |
+| `ValidateConfig`      | Validate config and return implicit dependencies.        |
+
+The module also connects back to the parent `viam-server` to access other
+resources (dependencies) on the machine.
+
+## meta.json schema
+
+Every module has a `meta.json` file that describes the module to the registry.
+The full schema is available at `https://dl.viam.dev/module.schema.json`.
+
+```json
+{
+  "$schema": "https://dl.viam.dev/module.schema.json",
+  "module_id": "my-org:my-module",
+  "visibility": "private",
+  "url": "https://github.com/my-org/my-module",
+  "description": "Short description of the module.",
+  "models": [
+    {
+      "api": "rdk:component:sensor",
+      "model": "my-org:my-module:my-sensor",
+      "short_description": "A short description of this model.",
+      "markdown_link": "README.md#my-sensor"
+    }
+  ],
+  "entrypoint": "run.sh",
+  "first_run": "setup.sh",
+  "markdown_link": "README.md",
+  "build": {
+    "setup": "./setup.sh",
+    "build": "./build.sh",
+    "path": "module.tar.gz",
+    "arch": ["linux/amd64", "linux/arm64"]
+  }
+}
+```
+
+| Field                        | Type   | Required | Description                                                                                                                                          |
+| ---------------------------- | ------ | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `$schema`                    | string | No       | JSON Schema URL for editor validation.                                                                                                               |
+| `module_id`                  | string | Yes      | `namespace:name` or `org-id:name`.                                                                                                                   |
+| `visibility`                 | string | Yes      | `private`, `public`, or `public_unlisted`.                                                                                                           |
+| `url`                        | string | No       | Source repo URL. Required for cloud builds.                                                                                                          |
+| `description`                | string | Yes      | Short description shown in the registry.                                                                                                             |
+| `models`                     | array  | No       | List of API/model pairs the module provides. Deprecated: models are now inferred from the module binary.                                             |
+| `models[].api`               | string | Yes      | Resource API (for example, `rdk:component:sensor`).                                                                                                  |
+| `models[].model`             | string | Yes      | Model triplet (for example, `my-org:my-module:my-sensor`).                                                                                           |
+| `models[].short_description` | string | No       | Short model description (max 100 chars).                                                                                                             |
+| `models[].markdown_link`     | string | No       | Path to model docs within the repo.                                                                                                                  |
+| `entrypoint`                 | string | Yes      | Path to the executable inside the archive.                                                                                                           |
+| `first_run`                  | string | No       | Path to a one-time setup script. Runs before the entrypoint on first install and after version updates. See [First-run scripts](#first-run-scripts). |
+| `markdown_link`              | string | No       | Path to README used as registry description.                                                                                                         |
+| `build`                      | object | No       | Build configuration for local and cloud builds.                                                                                                      |
+| `build.setup`                | string | No       | One-time setup command (for example, install dependencies).                                                                                          |
+| `build.build`                | string | No       | Build command (for example, `make module.tar.gz`).                                                                                                   |
+| `build.path`                 | string | No       | Path to built artifact. Default: `module.tar.gz`.                                                                                                    |
+| `build.arch`                 | array  | No       | Target platforms. Default: `["linux/amd64", "linux/arm64"]`.                                                                                         |
+| `build.darwin_deps`          | array  | No       | Homebrew dependencies for macOS builds (for example, `["go", "pkg-config"]`).                                                                        |
+| `applications`               | array  | No       | Viam applications provided by the module. See [Applications](#applications).                                                                         |
+
+### Applications
+
+If your module provides a [Viam application](/operate/control/viam-applications/),
+define it in the `applications` array in `meta.json`.
+
+Each application object has the following properties:
+
+| Property         | Type     | Description                                                                                                                                                                                                                                  |
+| ---------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `name`           | string   | The application name, used in the application's URL (`name_publicnamespace.viamapps.com`). Must be all-lowercase, alphanumeric and hyphens only, cannot start or end with a hyphen, and must be unique within your organization's namespace. |
+| `type`           | string   | `"single_machine"` or `"multi_machine"`. Whether the application can access one machine or multiple machines.                                                                                                                                |
+| `entrypoint`     | string   | Path to the HTML entry point (for example, `"dist/index.html"`).                                                                                                                                                                             |
+| `fragmentIds`    | []string | Fragment IDs a machine must contain to be selectable from the machine picker. Single-machine applications only.                                                                                                                              |
+| `logoPath`       | string   | URL or relative path to the logo for the machine picker screen. Single-machine applications only.                                                                                                                                            |
+| `customizations` | object   | Override branding on the authentication screen. Contains a `machinePicker` object with properties: `heading` (max 60 chars), `subheading` (max 256 chars).                                                                                   |
+
+For example, if your organization namespace is `acme` and your application name
+is `dashboard`, your application is accessible at:
+
+```txt
+https://dashboard_acme.viamapps.com
+```
+
+### Organization namespace
+
+When uploading modules to the Viam Registry, you must set a unique namespace
+for your organization.
+
+**Create a namespace:** In the Viam app, click your organization name in the
+top navigation bar, then click **Settings**, then click **Set a public namespace**. Enter a
+name and click **Set namespace**. Namespaces may only contain letters, numbers,
+and hyphens (`-`).
+
+**Rename a namespace:**
+
+1. Navigate to your organization settings page.
+2. Click **Rename** next to your current namespace.
+3. Enter the new namespace name and click **Rename**.
+4. Update the module code and `meta.json` for each module your organization owns
+   to reflect the new namespace.
+5. (Recommended) Update the `model` field in machine configurations that
+   reference the old namespace. Old references continue to work, but updating
+   avoids confusion.
+
+When you rename a namespace, Viam reserves the old namespace for backwards
+compatibility: it cannot be reused.
+
+## CLI commands
+
+All module CLI commands are under `viam module`. You must be logged in
+(`viam login`) to use commands that interact with the registry.
+
+### Create and generate
+
+| Command                            | Description                                                              |
+| ---------------------------------- | ------------------------------------------------------------------------ |
+| `viam module create --name <name>` | Register a module in the registry and generate `meta.json`.              |
+| `viam module generate`             | Scaffold a complete module project with templates (interactive prompts). |
+
+`generate` flags: `--name`, `--language` (`python` or `go`), `--visibility`,
+`--public-namespace`, `--resource-subtype`, `--model-name`, `--register`,
+`--dry-run`.
+
+### Build
+
+| Command                                      | Description                                       |
+| -------------------------------------------- | ------------------------------------------------- |
+| `viam module build local`                    | Run the build command from `meta.json` locally.   |
+| `viam module build start --version <semver>` | Start a cloud build for all configured platforms. |
+| `viam module build list`                     | List cloud build jobs and their status.           |
+| `viam module build logs --id <build-id>`     | Stream logs from a cloud build job.               |
+
+`build start` flags: `--ref` (git ref, default: `main`), `--platforms`,
+`--token` (for private repos), `--workdir`.
+
+During builds, the environment variables `VIAM_BUILD_OS` and `VIAM_BUILD_ARCH`
+are set to the target platform. See [Environment variables](#environment-variables).
+
+### Upload and update
+
+| Command                                                       | Description                                              |
+| ------------------------------------------------------------- | -------------------------------------------------------- |
+| `viam module upload --version <semver> --platform <platform>` | Upload a built archive to the registry.                  |
+| `viam module update`                                          | Push updated `meta.json` to the registry.                |
+| `viam module update-models --binary <path>`                   | Auto-detect models from a binary and update `meta.json`. |
+| `viam module download --id <module-id>`                       | Download a module from the registry.                     |
+
+`upload` flags: `--tags` (platform constraints), `--force` (skip validation),
+`--upload` (path to archive).
+
+### Development loop
+
+| Command                                   | Description                                                 |
+| ----------------------------------------- | ----------------------------------------------------------- |
+| `viam module reload-local --part-id <id>` | Build locally, transfer to machine, configure, and restart. |
+| `viam module reload --part-id <id>`       | Build in cloud; machine downloads the package directly.     |
+| `viam module restart --part-id <id>`      | Restart a running module without rebuilding.                |
+
+`reload-local` flags: `--part-id` (target machine part), `--no-build` (skip
+build), `--local` (run entrypoint directly on localhost instead of bundling),
+`--model-name` (add a resource to config with this model triple),
+`--name` (name the added resource), `--resource-name` (name the resource
+instance), `--id` (module ID, alternative to `--name`),
+`--cloud-config` (path to `viam.json`, alternative to `--part-id`),
+`--workdir` (subdirectory containing `meta.json`), `--home-dir` (remote
+user's home directory), `--no-progress` (hide transfer progress).
+
+## Environment variables
+
+### Runtime
+
+These environment variables are available inside a running module process
+(including [first-run scripts](#first-run-scripts)):
+
+| Variable           | Description                                     |
+| ------------------ | ----------------------------------------------- |
+| `VIAM_MODULE_NAME` | The module's name from config.                  |
+| `VIAM_MODULE_DATA` | Path to the module's persistent data directory. |
+| `VIAM_MODULE_ROOT` | Parent directory of the module executable.      |
+| `VIAM_MODULE_ID`   | Registry module ID (registry modules only).     |
+| `VIAM_HOME`        | Path to the Viam home directory (`~/.viam`).    |
+
+### Cloud-connected
+
+When the machine is connected to Viam Cloud, these additional variables are
+available inside the module process:
+
+| Variable               | Description                                            |
+| ---------------------- | ------------------------------------------------------ |
+| `VIAM_API_KEY`         | API key (if an API key auth handler is configured).    |
+| `VIAM_API_KEY_ID`      | API key ID (if an API key auth handler is configured). |
+| `VIAM_MACHINE_ID`      | Cloud machine ID.                                      |
+| `VIAM_MACHINE_PART_ID` | Cloud machine part ID.                                 |
+| `VIAM_MACHINE_FQDN`    | Machine's fully qualified domain name.                 |
+| `VIAM_LOCATION_ID`     | Cloud location ID.                                     |
+| `VIAM_PRIMARY_ORG_ID`  | Primary organization ID.                               |
+
+Custom environment variables can be added in the module's machine config under
+the `env` field.
+
+### Build-time
+
+The following variables are set during [cloud builds](#build), not at runtime:
+
+| Variable          | Description                                               |
+| ----------------- | --------------------------------------------------------- |
+| `VIAM_BUILD_OS`   | Target operating system (for example, `linux`, `darwin`). |
+| `VIAM_BUILD_ARCH` | Target architecture (for example, `amd64`, `arm64`).      |
+
+### Server-side
+
+The following variables control `viam-server` startup behavior (not passed to modules):
+
+| Variable                              | Description                                                                |
+| ------------------------------------- | -------------------------------------------------------------------------- |
+| `VIAM_MODULE_STARTUP_TIMEOUT`         | Override the default 5-minute startup timeout (for example, `10m`, `30s`). |
+| `VIAM_RESOURCE_CONFIGURATION_TIMEOUT` | Override the default 2-minute per-resource configuration timeout.          |
+
+## Supported platforms
+
+| Platform        | Cloud build support                       |
+| --------------- | ----------------------------------------- |
+| `linux/amd64`   | Yes                                       |
+| `linux/arm64`   | Yes                                       |
+| `linux/arm32v6` | No                                        |
+| `linux/arm32v7` | No                                        |
+| `darwin/amd64`  | No                                        |
+| `darwin/arm64`  | Yes                                       |
+| `windows/amd64` | Yes                                       |
+| `any`           | No (use for platform-independent modules) |
+
+## Registry validation rules
+
+| Rule                    | Constraint                                                                                                                |
+| ----------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Module name             | 1-200 characters, `^[a-zA-Z0-9][-\w]*$` (must start with alphanumeric; may contain hyphens, underscores, letters, digits) |
+| Module version          | Semantic versioning 2.0.0 (for example, `1.2.3`)                                                                          |
+| Package name            | `^[\w-]+$`                                                                                                                |
+| Metadata fields         | Max 16 key-value pairs                                                                                                    |
+| Metadata key/value size | Max 500 KB each                                                                                                           |
+| Compressed package      | Max 50 GB                                                                                                                 |
+| Decompressed contents   | Max 250 GB                                                                                                                |
+| Single file in package  | Max 25 GB                                                                                                                 |
+| Model namespace         | Must match org namespace if org has one. Cannot use reserved namespace `rdk`.                                             |
+| Public modules          | Require org to have a public namespace. Cannot use `public_unlisted` → `private` if external orgs are using the module.   |
diff --git a/docs/build-modules/overview.md b/docs/build-modules/overview.md
new file mode 100644
index 0000000000..ca9b4c71fe
--- /dev/null
+++ b/docs/build-modules/overview.md
@@ -0,0 +1,208 @@
+---
+linkTitle: "Overview"
+title: "Build and deploy modules"
+weight: 1
+layout: "docs"
+type: "docs"
+description: "Understand the two kinds of modules and how to extend your machine with custom hardware drivers and application logic."
+aliases:
+  - /build-modules/from-hardware-to-logic/
+---
+
+Modules extend what your machine can do. They come in two varieties: driver
+modules that add support for new hardware, and logic modules that tie
+components together with decision-making code. You can develop modules in your
+own IDE or write them directly in the browser using
+[inline modules](#inline-and-externally-managed-modules).
+
+If you have already [configured components](/hardware/configure-hardware/) on
+your machine, each one works individually: you can test it from the Viam app,
+capture its data, and call its API from a script. The next step is making
+them work **together**. A camera detects an object, and a motor responds. A
+temperature sensor crosses a threshold, and a notification fires. A movement
+sensor reports position, and an arm adjusts.
+
+## Two kinds of modules
+
+### Driver modules: add hardware support
+
+A [driver module](/build-modules/write-a-driver-module/) teaches Viam how to
+talk to a specific piece of hardware. Every module implements one of Viam's
+resource APIs. For a driver module, you pick the component API that matches
+your hardware:
+
+| API      | Use when your hardware...                           | Key methods                              |
+| -------- | --------------------------------------------------- | ---------------------------------------- |
+| `sensor` | Produces readings (temperature, distance, humidity) | `GetReadings`                            |
+| `camera` | Produces images or point clouds                     | `GetImage`, `GetPointCloud`              |
+| `motor`  | Drives rotational or linear motion                  | `SetPower`, `GoFor`, `Stop`              |
+| `arm`    | Has joints and moves to poses                       | `MoveToPosition`, `MoveToJointPositions` |
+| `base`   | Is a mobile platform (wheeled, tracked, legged)     | `MoveStraight`, `Spin`, `SetVelocity`    |
+
+Viam defines over 15 component APIs and 10 service APIs. For the full list,
+see [Resource APIs](/reference/apis/).
+
+Each implementation of a resource API is called a **model**. For example,
+the `camera` API has models for USB cameras, CSI cameras, RTSP streams, and
+others. When no existing model supports your hardware,
+you write a driver module to add one. Once it exists, the hardware behaves
+like any built-in component. Data capture, test panels, and the SDKs work
+automatically.
+
+### Logic modules: sense and act
+
+A [logic module](/build-modules/write-a-logic-module/) controls your machine's
+behavior. It declares dependencies on the resources it needs and implements
+your application's decision-making. Many logic modules run continuously on
+your machine, reading from sensors, evaluating conditions, and commanding
+actuators.
+
+Use a logic module when you need your machine to:
+
+- **React to sensor data**: trigger an alert or an actuator when a reading
+  crosses a threshold.
+- **Coordinate multiple components**: read from a camera and command an arm
+  based on what the camera sees.
+- **Run continuous processes**: monitor, aggregate, or transform data from
+  multiple sources.
+- **Schedule actions**: perform operations at specific intervals or times.
+
+Logic modules typically implement the `generic` service API. The generic API
+has a single method, `DoCommand`, which accepts and returns arbitrary key-value
+maps. Use it to check status, adjust parameters, or send commands to your
+running module from external scripts or the Viam app:
+
+```json
+// Request
+{"command": "get_alerts", "severity": "critical"}
+
+// Response
+{"alerts": [{"sensor": "temp-1", "value": 42.5, "threshold": 40.0}]}
+```
+
+Use `generic` when your module's interface does not map to an existing service
+API (like `vision` or `mlmodel`).
+
+## Inline and externally managed modules
+
+There are two ways to develop and deploy modules:
+
+**Inline modules** let you write code directly in the Viam app's
+browser-based editor. Viam manages source code, builds, versioning, and
+deployment. When you click **Save & Deploy**, the module builds in the cloud
+and deploys to your machine automatically. Inline modules are the fastest way
+to get started, especially for prototyping and simple control logic.
+
+**Externally managed modules** are modules you develop in your own IDE, manage
+in your own git repository, and deploy through the Viam CLI or GitHub Actions.
+Use externally managed modules when you need your own source control, public
+distribution, or custom build pipelines.
+
+|                          | Inline                            | Externally managed                           |
+| ------------------------ | --------------------------------- | -------------------------------------------- |
+| **Where you write code** | Browser editor in the Viam app    | Your own IDE, locally or in a repo           |
+| **Source control**       | Managed by Viam                   | Your own git repository                      |
+| **Build system**         | Automatic cloud builds on save    | Cloud build (GitHub Actions) or local builds |
+| **Versioning**           | Automatic (`0.0.1`, `0.0.2`, ...) | You choose semantic versions                 |
+| **Visibility**           | Private to your organization      | Private or public                            |
+
+Both types run identically at runtime, as child processes communicating with
+`viam-server` over gRPC.
+
+## Module lifecycle
+
+Every module goes through a defined lifecycle:
+
+1. **Startup** -- `viam-server` launches the module as a separate process. The
+   module registers its models and opens a gRPC connection back to the server.
+2. **Validation** -- For each configured resource, `viam-server` calls the
+   model's config validation method to check attributes and declare
+   dependencies.
+3. **Creation** -- If validation passes, `viam-server` calls the model's
+   constructor with the resolved dependencies.
+4. **Reconfiguration** -- If the user changes the configuration, `viam-server`
+   calls the validation method again, then the reconfiguration method.
+5. **Shutdown** -- `viam-server` calls the resource's close method. Clean up
+   resources here.
+
+For the full lifecycle reference including crash recovery, first-run scripts,
+and timeouts, see [Module developer reference](/build-modules/module-reference/#module-lifecycle).
+
+## Attributes
+
+Attributes are the user-provided configuration for your resource. When someone
+adds your module to a machine, they set attributes in the Viam app or in the
+machine's JSON config. Examples include a device address for a driver module,
+or a polling interval and threshold for a logic module.
+
+Your module defines which attributes it expects and validates them in its
+config validation method. If validation fails, `viam-server` reports the error
+and does not create the resource. Attributes are passed to your constructor
+when the resource is created and again to your reconfiguration method when
+the configuration changes.
+
+For code examples, see the attribute definitions in
+[Write a driver module](/build-modules/write-a-driver-module/#define-your-config-attributes)
+and [Write a logic module](/build-modules/write-a-logic-module/).
+
+## Dependencies
+
+Dependencies let your resource use other resources on the same machine. You
+declare dependencies in your config validation method by returning the names of
+resources your module needs. `viam-server` resolves these, ensures the
+depended-on resources are ready, and passes them to your constructor.
+
+- **Required** dependencies must be running before your resource starts.
+- **Optional** dependencies let your resource start immediately; `viam-server`
+  retries every 5 seconds and reconfigures your resource when the dependency
+  becomes available.
+
+The pattern has three steps:
+
+1. **Declare** -- return dependency names from your validation method.
+2. **Resolve** -- look up each dependency from the map in your constructor.
+3. **Use** -- call methods on the resolved dependencies in your logic.
+
+For detailed code examples, see
+[Module dependencies](/build-modules/dependencies/).
+
+## The module registry
+
+The Viam module registry stores versioned module packages and serves them to
+machines on demand. When you configure a module on a machine, `viam-server`
+downloads the correct version for the machine's platform (OS and architecture).
+
+Modules can be:
+
+- **Private** -- visible only to your organization.
+- **Public** -- visible to all Viam users.
+- **Unlisted** -- usable by anyone who knows the module ID, but not shown in
+  registry search results.
+
+The registry uses semantic versioning. Machines can track the latest version
+(automatic updates) or pin to a specific version.
+
+## Background tasks
+
+Logic modules often need to run continuously: polling sensors, checking
+thresholds, updating state. You can spawn background tasks (goroutines in Go,
+async tasks in Python) from your constructor or reconfiguration method.
+
+The key requirement: your background task must stop cleanly when the module
+shuts down or reconfigures. Use a cancellation signal (a context cancellation
+in Go, an `asyncio.Event` in Python) to coordinate this.
+
+## How it fits together
+
+1. **Configure components** ([Configure hardware](/hardware/configure-hardware/)).
+   Your machine can sense and act through individual hardware.
+2. **Test interactively**. Use test panels in the Viam app and SDK scripts
+   to verify each component works.
+3. **Capture data** ([Capture and sync data](/data/capture-sync/capture-and-sync-data/)).
+   Start recording what your sensors observe.
+4. **Write a module**. Tie components together with decision-making code, or
+   add support for new hardware.
+5. **Deploy** ([Deploy a module](/build-modules/deploy-a-module/)).
+   Package your module and deploy it to one machine or a fleet.
+
+If you want to build a client app that talks to a machine from outside `viam-server` rather than extending the server itself, see [Build apps](/build-apps/).
diff --git a/docs/build-modules/platform-apis.md b/docs/build-modules/platform-apis.md
new file mode 100644
index 0000000000..76a04e5643
--- /dev/null
+++ b/docs/build-modules/platform-apis.md
@@ -0,0 +1,284 @@
+---
+title: "Access platform APIs from within a module"
+linkTitle: "Use platform APIs"
+weight: 35
+layout: "docs"
+type: "docs"
+description: "Write your validate and reconfigure functions to handle dependencies in your custom modular resource."
+aliases:
+date: "2025-11-05"
+---
+
+To use the platform or machine APIs, you must authenticate using API keys.
+
+- [Use platform APIs from a module](#use-platform-apis-from-a-module)
+- [Use the machine management API from a module](#use-the-machine-management-api-from-a-module)
+
+## Use platform APIs from a module
+
+The following steps show you how to use the following APIs from a module:
+
+- [Fleet management (`app_client`)](/reference/apis/fleet/)
+- [Data client (`data_client`)](/reference/apis/data-client/)
+- [ML training (`ml_training_client`)](/reference/apis/ml-training-client/)
+- [Billing (`billing_client`)](/reference/apis/billing-client/)
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+1. Add the following imports:
+
+   ```python {class="line-numbers linkable-line-numbers"}
+   import os
+   from viam.app.viam_client import ViamClient
+   from viam.app.app_client import AppClient
+   from viam.app.data_client import DataClient
+   from viam.app.ml_training_client import MLTrainingClient
+   from viam.app.billing_client import BillingClient
+   ```
+
+1. Add the `viam_client` and other clients to the resource class:
+
+   ```python {class="line-numbers linkable-line-numbers"}
+   class TestSensor(Sensor, EasyResource):
+       viam_client: Optional[ViamClient] = None
+       app_client: Optional[AppClient] = None
+       data_client: Optional[DataClient] = None
+       ml_training_client: Optional[MLTrainingClient] = None
+       billing_client: Optional[BillingClient] = None
+
+       # ...
+   ```
+
+1. Initialize the clients and use them:
+
+   ```python {class="line-numbers linkable-line-numbers"}
+   async def some_module_function(self):
+      # Ensure there is only one viam_client connection
+      if not self.viam_client:
+          self.viam_client = await ViamClient.create_from_env_vars()
+
+      self.app_client = self.viam_client.app_client
+      self.data_client = self.viam_client.data_client
+      self.ml_training_client = self.viam_client.ml_training_client
+      self.billing_client = self.viam_client.billing_client
+      # Use the clients in your module
+      locations = await self.app_client.list_locations(os.environ.get("VIAM_PRIMARY_ORG_ID"))
+   ```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+1. Add the following imports:
+
+   ```go {class="line-numbers linkable-line-numbers"}
+   "os"
+   "go.viam.com/rdk/app"
+   ```
+
+1. Add the `viam_client` and other clients to the resource class:
+
+   ```go {class="line-numbers linkable-line-numbers"}
+   type testPlatformApisGoModuleTestDataClient struct {
+     resource.AlwaysRebuild
+
+     name resource.Name
+
+     logger logging.Logger
+     cfg    *Config
+
+     cancelCtx  context.Context
+     cancelFunc func()
+
+     viamClient *app.ViamClient
+     appClient *app.AppClient
+     dataClient *app.DataClient
+     mlTrainingClient *app.MLTrainingClient
+     billingClient *app.BillingClient
+   }
+   ```
+
+1. Initialize the clients and use them:
+
+   ```go {class="line-numbers linkable-line-numbers"}
+   func (s *exampleModuleResource) SomeModuleFunction(ctx context.Context, extra map[string]interface{}) (map[string]interface{}, error) {
+      if s.viamClient == nil {
+        var err error
+        s.viamClient, err = app.CreateViamClientFromEnvVars(ctx, &app.Options{}, s.logger)
+        if err != nil {
+          return nil, err
+        }
+        s.appClient = s.viamClient.AppClient()
+        s.dataClient = s.viamClient.DataClient()
+        s.mlTrainingClient = s.viamClient.MLTrainingClient()
+        s.billingClient = s.viamClient.BillingClient()
+      }
+      locations, err := s.appClient.ListLocations(ctx, os.Getenv("VIAM_PRIMARY_ORG_ID"))
+      if err != nil {
+        return nil, err
+      }
+
+      // Use locations...
+      return map[string]interface{}{"location_count": len(locations)}, nil
+
+   }
+   ```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Elevate access
+
+The [module environment variables](/reference/) `VIAM_API_KEY` and `VIAM_API_KEY_ID` provide [machine owner access](/organization/rbac/) for the machine the module is running on.
+
+If you need a higher level of access, you can pass API keys as part of the module configuration:
+
+1. Create an API key with the appropriate [permissions](/organization/rbac/) from your organization settings page.
+1. Add the API key and API key ID values to the module configuration:
+
+   ```json
+   {
+     "modules": [
+       {
+         "type": "registry",
+         "name": "example-module",
+         "module_id": "naomi:example-module",
+         "version": "latest",
+         "env": {
+           "VIAM_API_KEY": "abcdefg987654321abcdefghi",
+           "VIAM_API_KEY_ID": "1234abcd-123a-987b-1234567890abc"
+         }
+       }
+     ]
+   }
+   ```
+
+   This changes the environment variables `VIAM_API_KEY` and `VIAM_API_KEY_ID` from the default to the provided ones.
+
+## Use the machine management API from a module
+
+To use the [machine management (`robot_client`) API](/reference/apis/robot/), you must get the machine's FQDN and API keys from the module environment variables.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+1. Add the following imports and the `create_robot_client_from_module` method:
+
+   ```python {class="line-numbers linkable-line-numbers"}
+   # Add imports
+   import os
+   from viam.robot.client import RobotClient
+
+   # For robot client, you can also use the machine's FQDN:
+   async def create_robot_client_from_module():
+       # Get API credentials from module environment variables
+       api_key = os.environ.get("VIAM_API_KEY")
+       api_key_id = os.environ.get("VIAM_API_KEY_ID")
+       machine_fqdn = os.environ.get("VIAM_MACHINE_FQDN")
+
+       if not api_key or not api_key_id or not machine_fqdn:
+           raise Exception("VIAM_API_KEY, VIAM_API_KEY_ID, and " +
+                           "VIAM_MACHINE_FQDN " +
+                           "environment variables are required")
+
+       # Create robot client options with API key authentication
+       opts = RobotClient.Options.with_api_key(
+           api_key=api_key,
+           api_key_id=api_key_id
+       )
+
+       # Create RobotClient using the machine's FQDN
+       robot_client = await RobotClient.at_address(machine_fqdn, opts)
+
+       return robot_client
+   ```
+
+1. Add the `robot_client` or other clients to the resource class:
+
+   ```python {class="line-numbers linkable-line-numbers"}
+   class TestSensor(Sensor, EasyResource):
+       robot_client: Optional[RobotClient] = None
+       # ...
+   ```
+
+1. Initialize the client and use it:
+
+   ```python {class="line-numbers linkable-line-numbers"}
+   async def some_module_function(self):
+       # Ensure there is only one robot client
+       if not self.robot_client:
+           self.robot_client = await create_robot_client_from_module()
+       # Use the robot client
+       resources = [str(name) for name in self.robot_client.resource_names]
+   ```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+1. Add the following imports and the `createRobotClientFromModule` function:
+
+   ```go {class="line-numbers linkable-line-numbers"}
+   "os"
+   "go.viam.com/rdk/robot/client"
+   "go.viam.com/utils/rpc"
+
+   func createRobotClientFromModule(ctx context.Context, logger logging.Logger) (*client.RobotClient, error) {
+     robotClient, err := client.New(
+           ctx,
+           os.Getenv("VIAM_MACHINE_FQDN"),
+           logger,
+           client.WithDialOptions(rpc.WithEntityCredentials(
+               os.Getenv("VIAM_API_KEY_ID"),
+               rpc.Credentials{
+                   Type:    rpc.CredentialsTypeAPIKey,
+                   Payload: os.Getenv("VIAM_API_KEY"),
+               })),
+       )
+       if err != nil {
+           return nil, err
+       }
+     return robotClient, nil
+   }
+   ```
+
+1. Add the `viam_client` and other clients to the resource class:
+
+   ```go {class="line-numbers linkable-line-numbers"}
+   type testPlatformApisGoModuleTestDataClient struct {
+     resource.AlwaysRebuild
+
+     name resource.Name
+
+     logger logging.Logger
+     cfg    *Config
+
+     cancelCtx  context.Context
+     cancelFunc func()
+
+     machine *client.RobotClient
+   }
+   ```
+
+1. Initialize the clients and use them:
+
+```go {class="line-numbers linkable-line-numbers"}
+func (s *exampleModuleResource) SomeModuleFunction(ctx context.Context, extra map[string]interface{}) (map[string]interface{}, error) {
+  if s.machine == nil {
+    var err error
+    s.machine, err = createRobotClientFromModule(ctx, s.logger)
+    if err != nil {
+      return nil, err
+    }
+  }
+  resources := s.machine.ResourceNames()
+
+  // Use resources...
+  return map[string]interface{}{"resource_count": len(resources)}, nil
+
+}
+```
+
+{{% /tab %}}
+{{% /tabs %}}
+
+To elevate access for the machine management API, follow the same steps described in [Elevate access](#elevate-access) above.
diff --git a/docs/build-modules/write-a-cpp-module.md b/docs/build-modules/write-a-cpp-module.md
new file mode 100644
index 0000000000..2b875d645f
--- /dev/null
+++ b/docs/build-modules/write-a-cpp-module.md
@@ -0,0 +1,1685 @@
+---
+title: "Create a new module with C++"
+linkTitle: "Create a C++ module"
+type: "docs"
+weight: 27
+images: ["/registry/module-puzzle-piece.svg"]
+tags: ["modular resources", "components", "services", "registry"]
+description: "Add support for a new component or service model by writing a module in C++."
+languages: ["c++"]
+viamresources: []
+platformarea: ["registry"]
+level: "Intermediate"
+date: "2024-07-30"
+# updated: ""  # When the tutorial was last entirely checked
+cost: "0"
+draft: true # Take out Go and Python, and check updatedness before un-drafting.
+---
+
+Viam provides built-in support for a variety of different {{< glossary_tooltip term_id="component" text="components" >}} and {{< glossary_tooltip term_id="service" text="services" >}}, as well as a registry full of {{< glossary_tooltip term_id="module" text="modules" >}} created by other users.
+If no [existing modules](/hardware/configure-hardware/) support your specific use case, you can write your own custom modular {{< glossary_tooltip term_id="resource" text="resources" >}} by creating a module, and either upload it to the [registry](https://app.viam.com/registry) to share it publicly, or deploy it to your machine as a local module without uploading it to the registry.
+
+Follow the instructions below to learn how to write a new module using your preferred language and its corresponding [Viam SDK](/reference/sdks/), and then deploy it to your machines.
+
+{{< alert title="Note: viam-micro-server modules" color="note" >}}
+[`viam-micro-server`](/operate/reference/viam-micro-server/) works differently from the RDK (and `viam-server`), so creating modular resources for it is different from the process described on this page.
+Refer to the [Micro-RDK Module Template on GitHub](https://github.com/viamrobotics/micro-rdk/tree/main/templates/module) for information on how to create custom resources for your `viam-micro-server` machine.
+You will need to [recompile and flash your ESP32 yourself](/operate/install/setup/) instead of using Viam's prebuilt binary and installer.
+{{< /alert >}}
+
+{{% alert title="Tip" color="tip" %}}
+For a simplified step-by-step guide, see [Create a Hello World module](/build-modules/write-a-driver-module/).
+{{% /alert %}}
+
+You can also watch this guide to creating a vision service module:
+
+{{<youtube embed_url="https://www.youtube-nocookie.com/embed/Yz6E07To9Mc">}}
+
+## Write a module
+
+Generally, to write a module, you will complete the following steps:
+
+1. Choose a Viam API to implement in your model.
+1. Write your new model definition code to map all the capabilities of your model to the API.
+1. Write an entry point (main program) file that registers your model with the Viam SDK and starts it up.
+1. Compile or package the model definition file or files, main program file, and any supporting files into a single executable file (a module) that can be run by `viam-server`.
+
+While you can certainly combine the resource model definition and the main program code into a single file if desired (for example, a single `main.py` program that includes both the model definition and the `main()` program that uses it), this guide will use separate files for each.
+
+### Choose an API to implement in your model
+
+Look through the [component APIs](/reference/apis/#component-apis) and [service API](/reference/apis/#service-apis) and find the API that best fits your use case.
+Each API contains various methods which you will need to define in your module:
+
+- One or more methods specific to that API, such as the servo component's `Move` and `GetPosition` methods.
+- Inherited `ResourceBase` methods such as `DoCommand` and `Close`, common to all Viam {{< glossary_tooltip term_id="resource" text="resource" >}} APIs.
+- (For some APIs) Other inherited methods, for example all actuator APIs such as the motor API and servo API inherit `IsMoving` and `Stop`.
+
+{{< expand "Click for more guidance" >}}
+Think about what functionality you want your module to provide, what methods you need, and choose an API to implement accordingly.
+For example, the [sensor API](/reference/apis/components/sensor/) has a `GetReadings` method, so if you create a module for a model of sensor, you'll need to write code to provide a response to the `GetReadings` method.
+If instead of just getting readings, you actually have an encoder and need to be able to reset the zero position, use the [encoder API](/reference/apis/components/encoder/) so you can define functionality behind the `GetPosition` and `ResetPosition` methods.
+
+In addition to the list of methods, another reason to choose one API over another is how certain APIs fit into the Viam ecosystem.
+For example, though you could technically implement a GPS as a sensor with just the `GetReadings` method, if you implement it as a movement sensor then you have access to methods like `GetCompassHeading` which allow you to use your GPS module with the [navigation service](/operate/reference/services/navigation/).
+For this reason, it's generally best to choose the API that most closely matches your hardware or software.
+{{< /expand >}}
+
+{{% alert title=Note color="note" %}}
+If you want to write a module to add support to a new type of component or service that is relatively unique, consider using the generic API for your resource type to build your own API:
+
+- If you are working with a component that doesn't fit into any of the existing component APIs, you can use the [generic component](/operate/reference/components/generic/) to build your own component API.
+- If you are designing a service that doesn't fit into any of the existing service APIs, you can use the [generic service](/operate/reference/components/generic/) to build your own service API.
+- It is also possible to [define an entirely new API](/operate/reference/create-subtype/), but this is even more advanced than using `generic`.
+
+Most module use cases, however, benefit from implementing an existing API instead of `generic`.
+{{% /alert %}}
+
+#### Valid API identifiers
+
+Each existing component or service API has a unique identifier in the form of a colon-delimited triplet.
+You will use this {{< glossary_tooltip term_id="api-namespace-triplet" text="API namespace triplet" >}} when creating your new model, to indicate which API it uses.
+
+The API namespace triplet is the same for all built-in and modular models that implement a given API.
+For example, every model of motor built into Viam, as well as every custom model of motor provided by a module, all use the same API namespace triplet `rdk:component:motor` to indicate that they implement the [motor API](/operate/reference/components/motor/#api).
+
+The three pieces of the API namespace triplet are as follows:
+
+{{< tabs >}}
+{{% tab name="Component" %}}
+
+- `namespace`: `rdk`
+- `type`: `component`
+- `subtype`: any one of [these component proto files](https://github.com/viamrobotics/api/tree/main/proto/viam/component), for example `motor` if you are creating a new model of motor
+
+{{% /tab %}}
+{{% tab name="Service" %}}
+
+- `namespace`: `rdk`
+- `type`: `service`
+- `subtype`: any one of [these service proto files](https://github.com/viamrobotics/api/tree/main/proto/viam/service), for example `vision` if you are creating a new model of vision service
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Name your new resource model
+
+In addition to determining which existing API namespace triplet to use when creating your module, you need to decide on a separate triplet unique to your model.
+
+{{< expand "API namespace triplet and model namespace triplet example" >}}
+
+The `rand:yahboom:arm` model and the `rand:yahboom:gripper` model use the module name (and matching repo name) [yahboom](https://github.com/viam-labs/yahboom).
+The models implement the `rdk:component:arm` and the `rdk:component:gripper` API to support the Yahboom DOFBOT arm and gripper, respectively:
+
+```json
+{
+    "api": "rdk:component:arm",
+    "model": "rand:yahboom:arm"
+},
+{
+    "api": "rdk:component:gripper",
+    "model": "rand:yahboom:gripper"
+}
+```
+
+{{< /expand >}}
+
+A resource model is identified by a unique name, called the {{< glossary_tooltip term_id="model-namespace-triplet" text="model namespace triplet" >}}, using the format: `namespace:module-name:model-name`, where:
+
+- `namespace` is the [namespace of your organization](/build-modules/module-reference/#organization-namespace).
+  - For example, if your organization uses the `acme` namespace, your models must all begin with `acme`, like `acme:module-name:mybase`.
+    If you do not intend to [upload your module](#upload-your-module-to-the-modular-resource-registry) to the [registry](https://app.viam.com/registry), you do not need to use your organization's namespace as your model's namespace.
+  - The `viam` namespace is reserved for models provided by Viam.
+- `module-name` is the name of your module.
+  Your `module-name` should describe the common functionality provided across the model or models provided by that module.
+  - Many people also choose to use the module name as the name of the code repository (GitHub repo) that houses the module code.
+- `model-name` is the name of the new resource model that your module will provide.
+
+For example, if your organization namespace is `acme`, and you have written a new base implementation named `mybase` which you have supported with a module named `my-custom-base-module`, you would use the namespace `acme:my-custom-base-module:mybase` for your model.
+
+More requirements:
+
+- Your model triplet must be all-lowercase.
+- Your model triplet may only use alphanumeric (`a-z` and `0-9`), hyphen (`-`), and underscore (`_`) characters.
+
+Determine the model name you want to use based on these requirements, then proceed to the next section.
+
+### Write your new resource model definition
+
+In this step, you will code the logic that is unique to your model.
+
+{{% alert title="Tip (optional)" color="tip" %}}
+
+If you are using Golang, use the [Golang Module templates](https://github.com/viam-labs/module-templates-golang) which contain detailed instructions for creating your module.
+
+If you are using Python, you can use the [Viam module generator](https://github.com/viam-labs/generator-viam-module/) to generate the scaffolding for a module with one resource model.
+
+{{% /alert %}}
+
+{{< expand "Additional example modules" >}}
+
+Browse additional example modules by language:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+<!-- prettier-ignore -->
+| Module | Repository | Description |
+| ------ | ---------- | ----------- |
+| [berryimu](https://app.viam.com/module/viam-labs/berryimu) | [viam-labs/berry-imu](https://github.com/viam-labs/berry-imu) | Extends the built-in [movement sensor API](/reference/apis/components/movement-sensor/) to support using the BerryIMU v3 accelerometer, gyroscope and magnetometer using an I2C connection on ARM64 systems. |
+| [oak](https://app.viam.com/module/viam/oak) | [viam-modules/viam-camera-oak](https://github.com/viam-modules/viam-camera-oak) | Extends the built-in [camera API](/reference/apis/components/camera/) to support OAK cameras. |
+| [odrive](https://app.viam.com/module/viam/odrive) | [viamrobotics/odrive](https://github.com/viamrobotics/odrive) | Extends the built-in [motor API](/operate/reference/components/motor/#api) to support the ODrive motor. This module provides two models, one for a `canbus`-connected ODrive motor, and one for a `serial`-connected ODrive motor. |
+| [yahboom](https://app.viam.com/module/rand/yahboom) | [viamlabs/yahboom](https://github.com/viam-labs/yahboom) | Extends the built-in [arm API](/reference/apis/components/arm/) and [gripper API](/reference/apis/components/gripper/) to support the Yahboom Dofbot robotic arm. |
+
+For more Python module examples:
+
+- See the [Python SDK `examples` directory](https://github.com/viamrobotics/viam-python-sdk/tree/main/examples) for sample module code of varying complexity.
+- For an example featuring a sensor, see [MCP300x](https://github.com/viam-labs/mcp300x-adc-sensor).
+- For additional examples use the [modular resources search](https://app.viam.com/registry) to search for examples of the model you are implementing, and click on the model's link to be able to browse its code.
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+<!-- prettier-ignore -->
+| Module | Repository | Description |
+| ------ | ---------- | ----------- |
+| [agilex-limo](https://app.viam.com/module/viam/agilex-limo) | [viamlabs/agilex](https://github.com/viam-labs/agilex/) | Extends the built-in [base API](/reference/apis/components/base/) to support the Agilex Limo base. |
+| [rplidar](https://app.viam.com/module/viam/rplidar) | [viamrobotics/rplidar](https://github.com/viamrobotics/rplidar) | Extends the built-in [camera API](/reference/apis/components/camera/) to support several models of the SLAMTEC RPlidar. |
+| [filtered-camera](https://app.viam.com/module/viam/filtered-camera) | [viamrobotics/filtered-camera](https://app.viam.com/module/viam/filtered-camera) | Extends the built-in [camera API](/reference/apis/components/camera/) to enable filtering captured images by comparing to a defined ML model, and only syncing matching images to Viam. See the [filtered-camera guide](/data/filter-at-the-edge/#use-a-filtered-camera-with-ml) for more information. |
+
+For more Go module examples:
+
+- See the [Go SDK `examples` directory](https://github.com/viamrobotics/rdk/blob/main/examples/) for sample module code of varying complexity.
+- For additional examples use the [modular resources search](https://app.viam.com/registry) to search for examples of the model you are implementing, and click on the model's link to be able to browse its code.
+
+{{% /tab %}}
+{{% tab name="C++" %}}
+
+<!-- prettier-ignore -->
+| Module | Repository | Description |
+| ------ | ---------- | ----------- |
+| [csi-cam](https://app.viam.com/module/viam/csi-cam) | [viamrobotics/csi-camera](https://github.com/viamrobotics/csi-camera/) | Extends the built-in [camera API](/reference/apis/components/camera/) to support the Intel CSI camera. |
+<!-- | [module-example-cpp](https://app.viam.com/module/viam/module-example-cpp) | [viamrobotics/module-example-cpp](https://github.com/viamrobotics/module-example-cpp) | Extends the built-in [sensor API](/operate/reference/components/sensor/#api) to report wifi statistics. | -->
+
+{{% /tab %}}
+{{% /tabs %}}
+
+Explore the full list of available modules in the [registry](https://app.viam.com/registry).
+{{< /expand >}}
+
+Follow the instructions below to define the capabilities provided by your model, for the language you are using to write your module code:
+
+{{% alert title="Note: Pin numbers" color="note" %}}
+
+If your module references {{< glossary_tooltip term_id="pin-number" text="pin numbers" >}}, you should use physical board pin numbers, _not_ GPIO (BCM) numbers, to maintain consistency across {{< glossary_tooltip term_id="resource" text="resources" >}} from different sources.
+
+{{% /alert %}}
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+First, inspect the built-in class provided by the resource API that you are extending.
+
+For example, if you wanted to add support for a new [base component](/operate/reference/components/base/) to Viam (the component that represents the central physical platform of your machine, to which all other components are connected), you would start by looking at the built-in `Base` component class, which is defined in the [Viam Python SDK](https://github.com/viamrobotics/viam-python-sdk) in the following file:
+
+<!-- prettier-ignore -->
+| Resource Model File | Description |
+| ------------------- | ----------- |
+| [src/viam/components/base/base.py](https://github.com/viamrobotics/viam-python-sdk/blob/main/src/viam/components/base/base.py) | Defines the built-in `Base` class, which includes several built-in methods such as `move_straight()`. |
+
+{{% alert title="Tip" color="tip" %}}
+You can view the other built-in component classes in similar fashion.
+For example, the `Camera` class is defined in [camera.py](https://github.com/viamrobotics/viam-python-sdk/blob/main/src/viam/components/camera/camera.py) and the `Sensor` class is defined in [sensor.py](https://github.com/viamrobotics/viam-python-sdk/blob/main/src/viam/components/sensor/sensor.py).
+The same applies to service APIs.
+For example, the `MLModel` class for the ML Model service is defined in [mlmodel.py](https://github.com/viamrobotics/viam-python-sdk/blob/main/src/viam/services/mlmodel/mlmodel.py).
+{{% /alert %}}
+
+Take note of the methods defined as part of the class API, such as `move_straight()` for the `Base` class.
+Your new resource model must either:
+
+- implement all of the methods that the corresponding resource API provides, or
+- explicitly raise a `NotImplementedError()` in the body of functions you do not want to implement or put `pass`.
+
+Otherwise, your new class will not instantiate.
+
+Next, create a file that will define your new resource model.
+This file will inherit from the existing class for your resource type, implement each built-in method for that class (or raise a `NotImplementedError()` for it), and define any new functionality you want to include as part of your model.
+
+For example, the following file, `my_base.py`:
+
+- defines a new model `acme:my-custom-base-module:mybase` by implementing a new `MyBase` class, which inherits from the built-in class `Base`.
+- defines a new constructor `new_base()` and a new method `validate_config()`.
+- does not implement several built-in methods, including `get_properties()` and `set_velocity()`, but instead raises a `NotImplementedError` error in the body of those functions.
+  This prevents these methods from being used by new base components that use this modular resource, but meets the requirement that all built-in methods either be defined or raise a `NotImplementedError()` error, to ensure that the new `MyBase` class successfully instantiates.
+
+{{< expand "Click to view sample code for my_base.py" >}}
+
+```python {class="line-numbers linkable-line-numbers"}
+from typing import ClassVar, Mapping, Sequence, Any, Dict, Optional, cast
+
+from typing_extensions import Self
+
+from viam.components.base import Base
+from viam.components.motor import Motor
+from viam.module.types import Reconfigurable
+from viam.module.module import Module
+from viam.proto.app.robot import ComponentConfig
+from viam.proto.common import ResourceName, Vector3
+from viam.resource.base import ResourceBase
+from viam.resource.registry import Registry, ResourceCreatorRegistration
+from viam.resource.types import Model, ModelFamily
+from viam.utils import ValueTypes
+from viam.logging import getLogger
+
+LOGGER = getLogger(__name__)
+
+
+class MyBase(Base, Reconfigurable):
+    """
+    MyBase implements a base that only supports set_power
+    (basic forward/back/turn controls) is_moving (check if in motion), and stop
+    (stop all motion).
+
+    It inherits from the built-in resource API Base and conforms to the
+    ``Reconfigurable`` protocol, which signifies that this component can be
+    reconfigured. Additionally, it specifies a constructor function
+    ``MyBase.new_base`` which confirms to the
+    ``resource.types.ResourceCreator`` type required for all models.
+    """
+
+    # Here is where we define our new model's colon-delimited-triplet:
+    # acme:my-custom-base-module:mybase
+    # acme = namespace, my-custom-base-module = module-name,
+    # mybase = model name
+    MODEL: ClassVar[Model] = Model(
+        ModelFamily("acme", "my-custom-base-module"), "mybase")
+
+    def __init__(self, name: str, left: str, right: str):
+        super().__init__(name, left, right)
+
+    # Constructor
+    @classmethod
+    def new_base(cls,
+                 config: ComponentConfig,
+                 dependencies: Mapping[ResourceName, ResourceBase]) -> Self:
+        base = cls(config.name)
+        base.reconfigure(config, dependencies)
+        return base
+
+    # Validates JSON Configuration
+    @classmethod
+    def validate_config(cls, config: ComponentConfig) -> Sequence[str]:
+        left_name = config.attributes.fields["motorL"].string_value
+        if left_name == "":
+            raise Exception(
+                "A motorL attribute is required for a MyBase component.")
+        right_name = [config.attributes.fields["motorR"].string_value]
+        if right_name == "":
+            raise Exception(
+                "A motorR attribute is required for a MyBase component.")
+        return [left_name, right_name]
+
+    # Handles attribute reconfiguration
+    def reconfigure(self,
+                    config: ComponentConfig,
+                    dependencies: Mapping[ResourceName, ResourceBase]):
+        left_name = config.attributes.fields["motorL"].string_value
+        right_name = config.attributes.fields["motorR"].string_value
+
+        left_motor = dependencies[Motor.get_resource_name(left_name)]
+        right_motor = dependencies[Motor.get_resource_name(right_name)]
+
+        self.left = cast(Motor, left_motor)
+        self.right = cast(Motor, right_motor)
+
+    """
+    Implement the methods the Viam RDK defines for the base API
+    (rdk:component:base)
+    """
+
+    # move_straight: unimplemented
+    async def move_straight(self,
+                            distance: int,
+                            velocity: float,
+                            *,
+                            extra: Optional[Dict[str, Any]] = None,
+                            timeout: Optional[float] = None,
+                            **kwargs):
+        raise NotImplementedError
+
+    # spin: unimplemented
+    async def spin(self,
+                   angle: float,
+                   velocity: float,
+                   *,
+                   extra: Optional[Dict[str, Any]] = None,
+                   timeout: Optional[float] = None,
+                   **kwargs):
+        raise NotImplementedError
+
+    # set_power: set the linear and angular velocity of the left and right
+    # motors on the base
+    async def set_power(self,
+                        linear: Vector3,
+                        angular: Vector3,
+                        *,
+                        extra: Optional[Dict[str, Any]] = None,
+                        timeout: Optional[float] = None,
+                        **kwargs):
+
+        # stop the base if absolute value of linear and angular velocity is
+        # less than .01
+        if abs(linear.y) < 0.01 and abs(angular.z) < 0.01:
+            return self.stop(extra=extra, timeout=timeout)
+
+        # use linear and angular velocity to calculate percentage of max power
+        # to pass to SetPower for left & right motors
+        sum = abs(linear.y) + abs(angular.z)
+
+        self.left.set_power(power=((linear.y - angular.z) / sum),
+                            extra=extra,
+                            timeout=timeout)
+        self.right.set_power(power=((linear.y + angular.z) / sum),
+                             extra=extra,
+                             timeout=timeout)
+
+    # set_velocity: unimplemented
+    async def set_velocity(self,
+                           linear: Vector3,
+                           angular: Vector3,
+                           *,
+                           extra: Optional[Dict[str, Any]] = None,
+                           timeout: Optional[float] = None,
+                           **kwargs):
+        raise NotImplementedError
+
+    # get_properties: unimplemented
+    async def get_properties(self,
+                             extra: Optional[Dict[str, Any]] = None,
+                             timeout: Optional[float] = None,
+                             **kwargs):
+        raise NotImplementedError
+
+    # stop: stop the base from moving by stopping both motors
+    async def stop(self,
+                   *,
+                   extra: Optional[Dict[str, Any]] = None,
+                   timeout: Optional[float] = None,
+                   **kwargs):
+        self.left.stop(extra=extra, timeout=timeout)
+        self.right.stop(extra=extra, timeout=timeout)
+
+    # is_moving: check if either motor on the base is moving with motors'
+    # is_powered
+    async def is_moving(self,
+                        *,
+                        extra: Optional[Dict[str, Any]] = None,
+                        timeout: Optional[float] = None,
+                        **kwargs) -> bool:
+        return self.left.is_powered(extra=extra, timeout=timeout)[0] or \
+            self.right.is_powered(extra=extra, timeout=timeout)[0]
+```
+
+{{< /expand >}}
+
+When implementing built-in methods from the Viam Python SDK in your model, be sure your implementation of those methods returns any values designated in the built-in function's return signature, typed correctly.
+For example, the `is_moving()` implementation in the example code above returns a `bool` value, which matches the return value of the built-in `is_moving()` function as defined in the Viam Python SDK in the file [`base.py`](https://github.com/viamrobotics/viam-python-sdk/blob/main/src/viam/components/base/base.py).
+
+For more information on the base component API methods used in this example, see the following resources:
+
+- [Python SDK documentation for the `Base` class](https://python.viam.dev/autoapi/viam/components/base/index.html)
+- [Base API methods](/reference/apis/components/base/)
+
+{{% /tab %}}
+{{% tab name="Go"%}}
+
+First, inspect the built-in package provided by the resource API that you are extending.
+
+For example, if you wanted to add support for a new [base component](/operate/reference/components/base/) to Viam (the component that represents the central physical platform of your machine, to which all other components are connected), you would start by looking at the built-in `base` component package, which is defined in the [Viam Go SDK](https://github.com/viamrobotics/rdk/) in the following file:
+
+<!-- prettier-ignore -->
+| Resource Model File | Description |
+| ------------------- | ----------- |
+| [components/base/base.go](https://github.com/viamrobotics/rdk/blob/main/components/base/base.go) | Defines the built-in `base` package, which includes several built-in methods such as `MoveStraight()`. |
+
+{{% alert title="Tip" color="tip" %}}
+You can view the other built-in component packages in similar fashion.
+For example, the `camera` package is defined in [camera.go](https://github.com/viamrobotics/rdk/blob/main/components/camera/camera.go) and the `sensor` package is defined in [sensor.go](https://github.com/viamrobotics/rdk/blob/main/components/sensor/sensor.go).
+The same applies to service APIs.
+For example, the `mlmodel` package for the ML Model service is defined in [mlmodel.go](https://github.com/viamrobotics/rdk/blob/main/services/mlmodel/mlmodel.go).
+{{% /alert %}}
+
+Take note of the methods defined as part of the package API, such as `MoveStraight()` for the `base` package.
+Your new resource model must either:
+
+- implement all of the methods that the corresponding resource API provides, or
+- explicitly return an `errUnimplemented` error in the body of functions you do not want to implement.
+
+Otherwise, your new package will not instantiate.
+
+Next, create a file that will define your new resource model.
+This file will inherit from the existing package for your resource type, implement - or return an `errUnimplemented` error for - each built-in method for that package, and define any new functionality you want to include as part of your model.
+
+For example, the following file, `mybase.go`:
+
+- defines a new model `acme:my-custom-base-module:mybase` by implementing a new `mybase` package, which inherits from the built-in package `base`.
+- defines a new constructor `newBase()` and a new method `Validate()`.
+- does not implement several built-in methods, including `MoveStraight()` and `SetVelocity()`, but instead returns an `errUnimplemented` error in the body of those methods.
+  This prevents these methods from being used by new base components that use this modular resource, but meets the requirement that all built-in methods either be defined or return an `errUnimplemented` error, to ensure that the new `mybase` package successfully instantiates.
+
+{{< expand "Click to view sample code for mybase.go" >}}
+
+```go {class="line-numbers linkable-line-numbers"}
+// Package mybase implements a base that only supports SetPower (basic forward/back/turn controls), IsMoving (check if in motion), and Stop (stop all motion).
+// It extends the built-in resource API Base and implements methods to handle resource construction, attribute configuration, and reconfiguration.
+
+package mybase
+
+import (
+    "context"
+    "fmt"
+    "math"
+
+    "github.com/golang/geo/r3"
+    "github.com/pkg/errors"
+    "go.uber.org/multierr"
+
+    "go.viam.com/rdk/components/base"
+    "go.viam.com/rdk/components/base/kinematicbase"
+    "go.viam.com/rdk/components/motor"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/resource"
+    "go.viam.com/rdk/spatialmath"
+)
+
+// Here is where we define your new model's colon-delimited-triplet (acme:my-custom-base-module:mybase)
+// acme = namespace, my-custom-base-module = module-name, mybase = model name.
+var (
+    Model            = resource.NewModel("acme", "my-custom-base-module", "mybase")
+    errUnimplemented = errors.New("unimplemented")
+)
+
+const (
+    myBaseWidthMm        = 500.0 // Base has a wheel tread of 500 millimeters
+    myBaseTurningRadiusM = 0.3   // Base turns around a circle of radius .3 meters
+)
+
+func init() {
+    resource.RegisterComponent(base.API, Model, resource.Registration[base.Base, *Config]{
+        Constructor: newBase,
+    })
+}
+
+func newBase(ctx context.Context, deps resource.Dependencies, conf resource.Config, logger logging.Logger) (base.Base, error) {
+    b := &myBase{
+        Named:  conf.ResourceName().AsNamed(),
+        logger: logger,
+    }
+    if err := b.Reconfigure(ctx, deps, conf); err != nil {
+        return nil, err
+    }
+    return b, nil
+}
+
+
+// Reconfigure reconfigures with new settings.
+func (b *myBase) Reconfigure(ctx context.Context, deps resource.Dependencies, conf resource.Config) error {
+    b.left = nil
+    b.right = nil
+
+    // This takes the generic resource.Config passed down from the parent and converts it to the
+    // model-specific (aka "native") Config structure defined, above making it easier to directly access attributes.
+    baseConfig, err := resource.NativeConfig[*Config](conf)
+    if err != nil {
+        return err
+    }
+
+    b.left, err = motor.FromDependencies(deps, baseConfig.LeftMotor)
+    if err != nil {
+        return errors.Wrapf(err, "unable to get motor %v for mybase", baseConfig.LeftMotor)
+    }
+
+    b.right, err = motor.FromDependencies(deps, baseConfig.RightMotor)
+    if err != nil {
+        return errors.Wrapf(err, "unable to get motor %v for mybase", baseConfig.RightMotor)
+    }
+
+    geometries, err := kinematicbase.CollisionGeometry(conf.Frame)
+    if err != nil {
+        b.logger.CWarnf(ctx, "base %v %s", b.Name(), err.Error())
+    }
+    b.geometries = geometries
+
+    // Stop motors when reconfiguring.
+    return multierr.Combine(b.left.Stop(context.Background(), nil), b.right.Stop(context.Background(), nil))
+}
+
+// DoCommand simply echos whatever was sent.
+func (b *myBase) DoCommand(ctx context.Context, cmd map[string]interface{}) (map[string]interface{}, error) {
+    return cmd, nil
+}
+
+// Config contains two component (motor) names.
+type Config struct {
+    LeftMotor  string `json:"motorL"`
+    RightMotor string `json:"motorR"`
+}
+
+// Validate validates the config and returns implicit dependencies,
+// this Validate checks if the left and right motors exist for the module's base model.
+func (cfg *Config) Validate(path string) ([]string, error) {
+    // check if the attribute fields for the right and left motors are non-empty
+    // this makes them required for the model to successfully build
+    if cfg.LeftMotor == "" {
+        return nil, fmt.Errorf(`expected "motorL" attribute for mybase %q`, path)
+    }
+    if cfg.RightMotor == "" {
+        return nil, fmt.Errorf(`expected "motorR" attribute for mybase %q`, path)
+    }
+
+    // Return the left and right motor names so that `newBase` can access them as dependencies.
+    return []string{cfg.LeftMotor, cfg.RightMotor}, nil
+}
+
+type myBase struct {
+    resource.Named
+    left       motor.Motor
+    right      motor.Motor
+    logger     logging.Logger
+    geometries []spatialmath.Geometry
+}
+
+// MoveStraight does nothing.
+func (b *myBase) MoveStraight(ctx context.Context, distanceMm int, mmPerSec float64, extra map[string]interface{}) error {
+    return errUnimplemented
+}
+
+// Spin does nothing.
+func (b *myBase) Spin(ctx context.Context, angleDeg, degsPerSec float64, extra map[string]interface{}) error {
+    return errUnimplemented
+}
+
+// SetVelocity does nothing.
+func (b *myBase) SetVelocity(ctx context.Context, linear, angular r3.Vector, extra map[string]interface{}) error {
+    return errUnimplemented
+}
+
+// SetPower computes relative power between the wheels and sets power for both motors.
+func (b *myBase) SetPower(ctx context.Context, linear, angular r3.Vector, extra map[string]interface{}) error {
+    b.logger.CDebugf(ctx, "SetPower Linear: %.2f Angular: %.2f", linear.Y, angular.Z)
+    if math.Abs(linear.Y) < 0.01 && math.Abs(angular.Z) < 0.01 {
+        return b.Stop(ctx, extra)
+    }
+    sum := math.Abs(linear.Y) + math.Abs(angular.Z)
+    err1 := b.left.SetPower(ctx, (linear.Y-angular.Z)/sum, extra)
+    err2 := b.right.SetPower(ctx, (linear.Y+angular.Z)/sum, extra)
+    return multierr.Combine(err1, err2)
+}
+
+// Stop halts motion.
+func (b *myBase) Stop(ctx context.Context, extra map[string]interface{}) error {
+    b.logger.CDebug(ctx, "Stop")
+    err1 := b.left.Stop(ctx, extra)
+    err2 := b.right.Stop(ctx, extra)
+    return multierr.Combine(err1, err2)
+}
+
+// IsMoving returns true if either motor is active.
+func (b *myBase) IsMoving(ctx context.Context) (bool, error) {
+    for _, m := range []motor.Motor{b.left, b.right} {
+        isMoving, _, err := m.IsPowered(ctx, nil)
+        if err != nil {
+            return false, err
+        }
+        if isMoving {
+            return true, err
+        }
+    }
+    return false, nil
+}
+
+// Properties returns details about the physics of the base.
+func (b *myBase) Properties(ctx context.Context, extra map[string]interface{}) (base.Properties, error) {
+    return base.Properties{
+        TurningRadiusMeters: myBaseTurningRadiusM,
+        WidthMeters:         myBaseWidthMm * 0.001, // converting millimeters to meters
+    }, nil
+}
+
+// Geometries returns physical dimensions.
+func (b *myBase) Geometries(ctx context.Context, extra map[string]interface{}) ([]spatialmath.Geometry, error) {
+    return b.geometries, nil
+}
+
+// Close stops motion during shutdown.
+func (b *myBase) Close(ctx context.Context) error {
+    return b.Stop(ctx, nil)
+}
+```
+
+{{< /expand >}}
+
+{{< alert title="Note" color="note" >}}
+For an example featuring a sensor, see [MCP3004-8](https://github.com/mestcihazal/mcp3004-8-go).
+
+For additional examples use the [modular resources search](https://app.viam.com/registry) to search for examples of the model you are implementing, and click on the model's link to be able to browse its code.
+{{< /alert >}}
+
+When implementing built-in methods from the Viam Go SDK in your model, be sure your implementation of those methods returns any values designated in the built-in method's return signature, typed correctly.
+For example, the `SetPower()` implementation in the example code above returns a `multierr` value (as provided by the [`multierr` package](https://pkg.go.dev/go.uber.org/multierr)), which allows for transparently combining multiple Go `error` return values together.
+This matches the `error` return type of the built-in `SetPower()` method as defined in the Viam Go SDK in the file [`base.go`](https://github.com/viamrobotics/rdk/blob/main/components/base/base.go).
+
+For more information on the base component API methods used in this example, see the following resources:
+
+- [Go SDK documentation for the `base` package](https://pkg.go.dev/go.viam.com/rdk/components/base#pkg-functions)
+- [Base API methods](/reference/apis/components/base/)
+
+{{% /tab %}}
+{{% tab name="C++" %}}
+
+First, inspect the built-in class provided by the resource API that you are extending.
+In the C++ SDK, all built-in classes are abstract classes.
+
+For example, if you wanted to add support for a new [base component](/operate/reference/components/base/) to Viam (the component that represents the central physical platform of your machine, to which all other components are connected), you would start by looking at the built-in `Base` component class, which is defined in the [Viam C++ SDK](https://cpp.viam.dev/) in the following files:
+
+<!-- prettier-ignore -->
+| Resource Model File | Description |
+| ------------------- | ----------- |
+| [components/base/base.hpp](https://github.com/viamrobotics/viam-cpp-sdk/blob/main/src/viam/sdk/components/base.hpp) | Defines the API of the built-in `Base` class, which includes the declaration of several purely virtual built-in functions such as `move_straight()`. |
+| [components/base/base.cpp](https://github.com/viamrobotics/viam-cpp-sdk/blob/main/src/viam/sdk/components/base.cpp) | Provides implementations of the non-purely virtual functionality defined in `base.hpp`. |
+
+{{% alert title="Tip" color="tip" %}}
+You can view the other built-in component classes in similar fashion.
+For example, the API of the built-in `Camera` class is defined in [camera.hpp](https://github.com/viamrobotics/viam-cpp-sdk/blob/main/src/viam/sdk/components/camera.hpp) and its non-purely virtual functions are declared in [camera.cpp](https://github.com/viamrobotics/viam-cpp-sdk/blob/main/src/viam/sdk/components/camera.cpp), while the API of the built-in `Sensor` class is defined in [sensor.hpp](https://github.com/viamrobotics/viam-cpp-sdk/blob/main/src/viam/sdk/components/sensor.hpp) and its non-purely virtual functions are declared in [sensor.cpp](https://github.com/viamrobotics/viam-cpp-sdk/blob/main/src/viam/sdk/components/sensor.cpp).
+The same applies to service APIs.
+For example, the API of the built-in `MLModelService` class for the ML Model service is defined in [mlmodel.hpp](https://github.com/viamrobotics/viam-cpp-sdk/blob/main/src/viam/sdk/services/mlmodel.hpp) and its non-purely virtual functions declared in [mlmodel.cpp](https://github.com/viamrobotics/viam-cpp-sdk/blob/main/src/viam/sdk/services/mlmodel.cpp).
+{{% /alert %}}
+
+Take note of the functions defined as part of the class API, such as `move_straight()` for the `Base` class.
+Your new resource model must either:
+
+- define all _pure virtual methods_ that the corresponding resource API provides, or
+- explicitly `throw` a `runtime_error` in the body of functions you do not want to implement.
+
+Otherwise, your new class will not instantiate.
+For example, if your model implements the `base` class, you would either need to implement the [`move_straight()` virtual method](https://github.com/viamrobotics/viam-cpp-sdk/blob/main/src/viam/sdk/components/base.hpp#L72), or `throw` a `runtime_error` in the body of that function.
+However, you would _not_ need to implement the [`resource_registration()`](https://github.com/viamrobotics/viam-cpp-sdk/blob/main/src/viam/sdk/components/base.hpp#L56) function, as it is not a virtual method.
+
+Next, create your header file (`.hpp`) and source file (`.cpp`), which together define your new resource model.
+The header file defines the API of your class, and includes the declaration of any purely virtual functions, while the source file includes implementations of the functionality of your class.
+
+For example, the files below define the new `MyBase` class and its constituent functions:
+
+- The `my_base.hpp` header file defines the API of the `MyBase` class, which inherits from the built-in `Base` class.
+  It defines a new method `validate()`, but does not implement several built-in functions, including `move_straight()` and `set_velocity()`, instead it raises a `runtime_error` in the body of those functions.
+  This prevents these functions from being used by new base components that use this modular resource, but meets the requirement that all built-in functions either be defined or `throw` a `runtime_error` error, to ensure that the new `MyBase` class successfully instantiates.
+- The `my_base.cpp` source file contains the function and object definitions used by the `MyBase` class.
+
+Note that the model triplet itself, `acme:my-custom-base-module:mybase` in this example, is defined in the entry point (main program) file `main.cpp`, which is described in the next section.
+
+{{< expand "Click to view sample code for the my_base.hpp header file" >}}
+
+```cpp {class="line-numbers linkable-line-numbers"}
+#pragma once
+
+#include <viam/sdk/components/base/base.hpp>
+#include <viam/sdk/components/component.hpp>
+#include <viam/sdk/components/motor/motor.hpp>
+#include <viam/sdk/config/resource.hpp>
+#include <viam/sdk/resource/resource.hpp>
+
+using namespace viam::sdk;
+
+// `MyBase` inherits from the `Base` class defined in the Viam C++ SDK and
+// implements some of the relevant methods along with `reconfigure`. It also
+// specifies a static `validate` method that checks configuration validity.
+class MyBase : public Base {
+   public:
+    MyBase(Dependencies deps, ResourceConfig cfg) : Base(cfg.name()) {
+        this->reconfigure(deps, cfg);
+    };
+    void reconfigure(Dependencies deps, ResourceConfig cfg) override;
+    static std::vector<std::string> validate(ResourceConfig cfg);
+
+    bool is_moving() override;
+    void stop(const AttributeMap& extra) override;
+    void set_power(const Vector3& linear,
+                   const Vector3& angular,
+                   const AttributeMap& extra) override;
+
+    AttributeMap do_command(const AttributeMap& command) override;
+    std::vector<GeometryConfig> get_geometries(const AttributeMap& extra) override;
+    Base::properties get_properties(const AttributeMap& extra) override;
+
+    void move_straight(int64_t distance_mm, double mm_per_sec, const AttributeMap& extra) override {
+        throw std::runtime_error("move_straight unimplemented");
+    }
+    void spin(double angle_deg, double degs_per_sec, const AttributeMap& extra) override {
+        throw std::runtime_error("spin unimplemented");
+    }
+    void set_velocity(const Vector3& linear,
+                      const Vector3& angular,
+                      const AttributeMap& extra) override {
+        throw std::runtime_error("set_velocity unimplemented");
+    }
+
+   private:
+    std::shared_ptr<Motor> left_;
+    std::shared_ptr<Motor> right_;
+};
+```
+
+{{< /expand >}}
+
+{{< expand "Click to view sample code for the my_base.cpp source file" >}}
+
+```cpp {class="line-numbers linkable-line-numbers"}
+#include "my_base.hpp"
+
+#include <exception>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+
+#include <grpcpp/support/status.h>
+
+#include <viam/sdk/components/base/base.hpp>
+#include <viam/sdk/components/component.hpp>
+#include <viam/sdk/config/resource.hpp>
+#include <viam/sdk/resource/resource.hpp>
+
+using namespace viam::sdk;
+
+std::string find_motor(ResourceConfig cfg, std::string motor_name) {
+    auto base_name = cfg.name();
+    auto motor = cfg.attributes()->find(motor_name);
+    if (motor == cfg.attributes()->end()) {
+        std::ostringstream buffer;
+        buffer << base_name << ": Required parameter `" << motor_name
+               << "` not found in configuration";
+        throw std::invalid_argument(buffer.str());
+    }
+    const auto* const motor_string = motor->second->get<std::string>();
+    if (!motor_string || motor_string->empty()) {
+        std::ostringstream buffer;
+        buffer << base_name << ": Required non-empty string parameter `" << motor_name
+               << "` is either not a string "
+                  "or is an empty string";
+        throw std::invalid_argument(buffer.str());
+    }
+    return *motor_string;
+}
+
+void MyBase::reconfigure(Dependencies deps, ResourceConfig cfg) {
+    // Downcast `left` and `right` dependencies to motors.
+    auto left = find_motor(cfg, "left");
+    auto right = find_motor(cfg, "right");
+    for (const auto& kv : deps) {
+        if (kv.first.short_name() == left) {
+            left_ = std::dynamic_pointer_cast<Motor>(kv.second);
+        }
+        if (kv.first.short_name() == right) {
+            right_ = std::dynamic_pointer_cast<Motor>(kv.second);
+        }
+    }
+}
+
+std::vector<std::string> MyBase::validate(ResourceConfig cfg) {
+    // Custom validation can be done by specifying a validate function at the
+    // time of resource registration (see main.cpp) like this one.
+    // Validate functions can `throw` exceptions that will be returned to the
+    // parent through gRPC. Validate functions can also return a vector of
+    // strings representing the implicit dependencies of the resource.
+    //
+    // Here, we return the names of the "left" and "right" motors as found in
+    // the attributes as implicit dependencies of the base.
+    return {find_motor(cfg, "left"), find_motor(cfg, "right")};
+}
+
+bool MyBase::is_moving() {
+    return left_->is_moving() || right_->is_moving();
+}
+
+void MyBase::stop(const AttributeMap& extra) {
+    std::string err_message;
+    bool throw_err = false;
+
+    // make sure we try to stop both motors, even if the first fails.
+    try {
+        left_->stop(extra);
+    } catch (const std::exception& err) {
+        throw_err = true;
+        err_message = err.what();
+    }
+
+    try {
+        right_->stop(extra);
+    } catch (const std::exception& err) {
+        throw_err = true;
+        err_message = err.what();
+    }
+
+    // if we received an err from either motor, throw it.
+    if (throw_err) {
+        throw std::runtime_error(err_message);
+    }
+}
+
+void MyBase::set_power(const Vector3& linear, const Vector3& angular, const AttributeMap& extra) {
+    // Stop the base if absolute value of linear and angular velocity is less
+    // than 0.01.
+    if (abs(linear.y()) < 0.01 && abs(angular.z()) < 0.01) {
+        stop(extra);  // ignore returned status code from stop
+        return;
+    }
+
+    // Use linear and angular velocity to calculate percentage of max power to
+    // pass to set_power for left & right motors
+    auto sum = abs(linear.y()) + abs(angular.z());
+    left_->set_power(((linear.y() - angular.z()) / sum), extra);
+    right_->set_power(((linear.y() + angular.z()) / sum), extra);
+}
+
+AttributeMap MyBase::do_command(const AttributeMap& command) {
+    std::cout << "Received DoCommand request for MyBase " << Resource::name() << std::endl;
+    return command;
+}
+
+std::vector<GeometryConfig> MyBase::get_geometries(const AttributeMap& extra) {
+    auto left_geometries = left_->get_geometries(extra);
+    auto right_geometries = right_->get_geometries(extra);
+    std::vector<GeometryConfig> geometries(left_geometries);
+    geometries.insert(geometries.end(), right_geometries.begin(), right_geometries.end());
+    return geometries;
+}
+
+Base::properties MyBase::get_properties(const AttributeMap& extra) {
+    // Return fake properties.
+    return {2, 4, 8};
+}
+```
+
+{{< /expand >}}
+
+When implementing built-in functions from the Viam C++ SDK in your model, be sure your implementation of those functions returns any values designated in the built-in function's return signature, typed correctly.
+For example, the `set_power()` implementation in the example code above returns three values of type `Vector3`, `Vector3`, `AttributeMap`, which matches the return values of the built-in `set_power()` function as defined in the Viam C++ SDK in the file [`base.hpp`](https://github.com/viamrobotics/viam-cpp-sdk/blob/main/src/viam/sdk/components/base.hpp).
+
+For more information on the base component API methods used in these examples, see the following resources:
+
+- [C++ SDK documentation for the `Base` class](https://cpp.viam.dev/classviam_1_1sdk_1_1Base.html)
+- [Base API methods](/reference/apis/components/base/)
+
+For more C++ module examples of varying complexity,see the [C++ SDK `examples` directory](https://github.com/viamrobotics/viam-cpp-sdk/tree/main/src/viam/examples/modules/).
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Write an entry point (main program) file
+
+A main entry point file starts the module, and adds the resource model.
+
+Follow the instructions below for the language you are using to write your module code:
+
+{{< tabs name="Sample SDK Main Program Code">}}
+{{% tab name="Python"%}}
+
+Create a <file>main.py</file> file to serve as the module's entry point file, which:
+
+- imports the custom model
+- defines a `main()` function that registers the model with the Python SDK
+- creates and starts the module
+
+For example, the following `main.py` file serves as the entry point file for the `MyBase` custom model.
+It imports the `MyBase` model from the `my_base.py` file that provides it, and defines a `main()` function that registers it.
+
+{{< expand "Click to view sample code for main.py" >}}
+
+```python {class="line-numbers linkable-line-numbers"}
+import asyncio
+
+from viam.components.base import Base
+from viam.module.module import Module
+from viam.resource.registry import Registry, ResourceCreatorRegistration
+from my_base import MyBase
+
+
+async def main():
+    """
+    This function creates and starts a new module, after adding all desired
+    resource models. Resource creators must be registered to the resource
+    registry before the module adds the resource model.
+    """
+    Registry.register_resource_creator(
+        Base.API,
+        MyBase.MODEL,
+        ResourceCreatorRegistration(MyBase.new_base, MyBase.validate_config))
+    module = Module.from_args()
+
+    module.add_model_from_registry(Base.API, MyBase.MODEL)
+    await module.start()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+{{< /expand >}}
+
+{{% /tab %}}
+{{% tab name="Go"%}}
+
+Create a <file>main.go</file> file to serve as the module's entry point file, which:
+
+- imports the custom model
+- defines a `main()` function that registers the model with the Viam Go SDK
+- creates and starts the module
+
+For example, the following `main.go` file serves as the entry point file for the `mybase` custom model.
+It imports the `mybase` model from the `my_base.go` file that provides it, and defines a `main()` function that registers it.
+
+{{< expand "Click to view sample code for main.go" >}}
+
+```go {class="line-numbers linkable-line-numbers"}
+// Package main is a module which serves the mybase custom model.
+package main
+
+import (
+    "context"
+
+    "go.viam.com/rdk/components/base"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/module"
+    "go.viam.com/rdk/utils"
+
+    // Import your local package "mybase"
+    // NOTE: Update this path if your custom resource is in a different location,
+    // or has a different name:
+    "go.viam.com/rdk/examples/customresources/models/mybase"
+)
+
+func main() {
+    // NewLoggerFromArgs will create a logging.Logger at "DebugLevel" if
+    // "--log-level=debug" is an argument in os.Args and at "InfoLevel" otherwise.
+    utils.ContextualMain(mainWithArgs, module.NewLoggerFromArgs("mybase"))
+}
+
+func mainWithArgs(ctx context.Context, args []string, logger logging.Logger) (err error) {
+    myMod, err := module.NewModuleFromArgs(ctx, logger)
+    if err != nil {
+        return err
+    }
+
+    // Models and APIs add helpers to the registry during their init().
+    // They can then be added to the module here.
+    err = myMod.AddModelFromRegistry(ctx, base.API, mybase.Model)
+    if err != nil {
+        return err
+    }
+
+    err = myMod.Start(ctx)
+    defer myMod.Close(ctx)
+    if err != nil {
+        return err
+    }
+    <-ctx.Done()
+    return nil
+}
+```
+
+{{< /expand >}}
+
+{{% /tab %}}
+{{% tab name="C++" %}}
+
+Create a <file>main.cpp</file> file to serve as the module's entry point file, which:
+
+- imports the custom model implementation and definitions
+- includes a `main()` function that registers the model with the Viam C++ SDK
+- creates and starts the module
+
+For example, the following `main.cpp` file serves as the entry point file for the `mybase` custom model.
+It imports the `mybase` model implementation from the `my_base.hpp` file that provides it, declares the model triplet `acme:my-custom-base-module:mybase`, and defines a `main()` function that registers it.
+
+{{< expand "Click to view sample code for main.cpp" >}}
+
+```cpp {class="line-numbers linkable-line-numbers"}
+#include <memory>
+#include <signal.h>
+
+#include <boost/log/trivial.hpp>
+#include <grpcpp/grpcpp.h>
+#include <grpcpp/server_context.h>
+
+#include <viam/api/common/v1/common.grpc.pb.h>
+#include <viam/api/component/generic/v1/generic.grpc.pb.h>
+#include <viam/api/robot/v1/robot.pb.h>
+
+#include <viam/sdk/components/base/base.hpp>
+#include <viam/sdk/components/component.hpp>
+#include <viam/sdk/config/resource.hpp>
+#include <viam/sdk/module/module.hpp>
+#include <viam/sdk/module/service.hpp>
+#include <viam/sdk/registry/registry.hpp>
+#include <viam/sdk/resource/resource.hpp>
+#include <viam/sdk/rpc/dial.hpp>
+#include <viam/sdk/rpc/server.hpp>
+
+#include "my_base.hpp"
+
+using namespace viam::sdk;
+
+int main(int argc, char** argv) {
+    API base_api = Base::static_api();
+    Model mybase_model("acme", "my-custom-base-module", "mybase");
+
+    std::shared_ptr<ModelRegistration> mybase_mr = std::make_shared<ModelRegistration>(
+        base_api,
+        mybase_model,
+        [](Dependencies deps, ResourceConfig cfg) { return std::make_unique<MyBase>(deps, cfg); },
+        MyBase::validate);
+
+    std::vector<std::shared_ptr<ModelRegistration>> mrs = {mybase_mr};
+    auto my_mod = std::make_shared<ModuleService>(argc, argv, mrs);
+    my_mod->serve();
+
+    return EXIT_SUCCESS;
+};
+```
+
+{{< /expand >}}
+
+{{% /tab %}}
+{{< /tabs >}}
+
+#### (Optional) Configure logging
+
+If desired, you can configure your module to output log messages.
+Log messages appear on the [**LOGS** tab](/monitor/troubleshoot/#check-logs) for your machine in an easily-parsable and searchable manner.
+
+Log messages generated when your machine is offline are queued, and sent together when your machine connects to the internet once more.
+
+Add the following code to your module code to enable logging to Viam, depending on the language you using to code your module. You can log in this fashion from the model definition file or files, the entry point (main program) file, or both, depending on your logging needs:
+
+{{% alert title="Tip" color="tip" %}}
+The example code shown above under [Write your new resource model definition](#write-your-new-resource-model-definition) includes the requisite logging code already.
+{{% /alert %}}
+
+{{< tabs name="Configure logging">}}
+{{% tab name="Python"%}}
+
+To enable your Python module to write resource-level log messages to Viam, add the following lines to your code:
+
+```python {class="line-numbers linkable-line-numbers"}
+# Within some method, log information:
+self.logger.debug("debug info")
+self.logger.info("info")
+self.logger.warn("warning info")
+self.logger.error("error info")
+self.logger.exception("error info", exc_info=True)
+self.logger.critical("critical info")
+```
+
+Resource-level logs are recommended instead of global logs for modular resources, because they make it easier to determine which component or service an error is coming from.
+Resource-level error logs appear in the **Error logs** section of each resource's configuration card in the app.
+
+{{% alert title="Note" color="note" %}}
+In order to see resource-level debug logs when using your modular resource, you'll either need to run `viam-server` with the `-debug` option or [configure your machine or individual resource to display debug logs](/operate/reference/viam-server/#logging).
+{{% /alert %}}
+
+{{< expand "Click to see global logging" >}}
+
+If you need to publish to the global machine-level logs instead of using the recommended resource-level logging, you can follow this example:
+
+```python {class="line-numbers linkable-line-numbers" data-line="2,5"}
+# In your import block, import the logging package:
+from viam.logging import getLogger
+
+# Before your first class or function, define the LOGGER variable:
+LOGGER = getLogger(__name__)
+
+# in some method, log information
+LOGGER.debug("debug info")
+LOGGER.info("info info")
+LOGGER.warn("warn info")
+LOGGER.error("error info")
+LOGGER.exception("error info", exc_info=True)
+LOGGER.critical("critical info")
+```
+
+{{< /expand >}}
+
+{{% /tab %}}
+{{% tab name="Go"%}}
+
+To enable your Go module to write log messages to Viam, add the following lines to your code:
+
+```go {class="line-numbers linkable-line-numbers"}
+// In your import() block, import the logging package:
+import(
+       ...
+       "go.viam.com/rdk/logging"
+)
+// Alter your component to hold a logger
+type component struct {
+    ...
+ logger logging.Logger
+}
+// Then, alter your component's constructor to save the logger:
+func init() {
+ registration := resource.Registration[resource.Resource, *Config]{
+  Constructor: func(ctx context.Context, deps resource.Dependencies, conf resource.Config, logger logging.Logger) (resource.Resource, error) {
+     ...
+     return &component {
+         ...
+         logger: logger
+     }, nil
+  },
+ }
+ resource.RegisterComponent(...)
+}
+// Finally, when you need to log, use the functions on your component's logger:
+fn (c *component) someFunction(ctx context.Context, a int) {
+  // Log with severity info:
+  c.logger.CInfof(ctx, "performing some function with a=%v", a)
+  // Log with severity debug (using value wrapping):
+  c.logger.CDebugw(ctx, "performing some function", "a" ,a)
+  // Log with severity warn:
+  c.logger.CWarnw(ctx, "encountered warning for component", "name", c.Name())
+  // Log with severity error without a parameter:
+  c.logger.CError(ctx, "encountered an error")
+}
+```
+
+{{% /tab %}}
+{{% tab name="C++" %}}
+
+`viam-server` automatically gathers all output sent to the standard output (`STDOUT`) in your C++ code and forwards it to Viam when a network connection is available.
+
+We recommend that you use a C++ logging library to assist with log message format and creation, such as the [Boost trivial logger](https://www.boost.org/doc/libs/1_84_0/libs/log/doc/html/log/tutorial/trivial_filtering.html):
+
+```cpp {class="line-numbers linkable-line-numbers"}
+#include <boost/log/trivial.hpp>
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Compile or package your module
+
+The final step to creating a new module is to create an executable file that `viam-server` can use to run your module on demand.
+
+This executable file:
+
+- runs your module when executed
+- takes a local UNIX socket as a command line argument
+- exits cleanly when sent a termination signal
+
+Depending on the language you are using to code your module, you may have options for how you create your executable file:
+{{% tabs %}}
+{{% tab name="Python: pyinstaller (recommended)" %}}
+
+The recommended approach for Python is to use [`PyInstaller`](https://pypi.org/project/pyinstaller/) to compile your module into a packaged executable: a standalone file containing your program, the Python interpreter, and all of its dependencies.
+When packaged in this fashion, you can run the resulting executable on your desired target platform or platforms without needing to install additional software or manage dependencies manually.
+
+To create a packaged executable:
+
+1. First, [create a Python virtual environment](/reference/sdks/python/python-venv/) in your module's directory to ensure your module has access to any required libraries.
+   Be sure you are within your Python virtual environment for the rest of these steps: your terminal prompt should include the name of your virtual environment in parentheses.
+
+1. Create a `requirements.txt` file containing a list of all the dependencies your module requires.
+   For example, a `requirements.txt` file with the following contents ensures that the Viam Python SDK (`viam-sdk`), PyInstaller (`pyinstaller`), and the Google API Python client (`google-api-python-client`) are installed:
+
+   ```sh { class="command-line" data-prompt="$"}
+   viam-sdk
+   pyinstaller
+   google-api-python-client
+   ```
+
+   Add additional dependencies for your module as needed.
+   See the [pip `requirements.txt` file documentation](https://pip.pypa.io/en/stable/reference/requirements-file-format/) for more information.
+
+1. Install the dependencies listed in your `requirements.txt` file within your Python virtual environment using the following command:
+
+   ```sh { class="command-line" data-prompt="$"}
+   python -m pip install -r requirements.txt -U
+   ```
+
+1. Then compile your module, adding the Google API Python client as a hidden import:
+
+   ```sh { class="command-line" data-prompt="$"}
+   python -m PyInstaller --onefile --hidden-import="googleapiclient" src/main.py
+   ```
+
+   If you need to include any additional data files to support your module, specify them using the `--add-data` flag:
+
+   ```sh { class="command-line" data-prompt="$"}
+   python -m PyInstaller --onefile --hidden-import="googleapiclient" --add-data src/arm/my_arm_kinematics.json:src/arm/ src/main.py
+   ```
+
+   By default, the output directory for the packaged executable is <file>dist</file>, and the name of the executable is derived from the name of the input script (in this case, main).
+
+We recommend you use PyInstaller with the [`build-action` GitHub action](https://github.com/viamrobotics/build-action) which provides a simple cross-platform build setup for multiple platforms: x86 and Arm Linux distributions, and macOS.
+Follow the instructions to [Update an existing module using a GitHub action](/build-modules/manage-modules/#update-automatically-from-a-github-repo-with-cloud-build) to add the build configuration to your machine.
+
+With this approach, you can make a build script like the following to
+build your module, and configure the resulting executable (<file>dist/main</file>) as your module `"entrypoint"`:
+
+```sh { class="command-line"}
+#!/bin/bash
+set -e
+
+sudo apt-get install -y python3-venv
+python3 -m venv .venv
+. .venv/bin/activate
+pip3 install -r requirements.txt
+python3 -m PyInstaller --onefile --hidden-import="googleapiclient" src/main.py
+tar -czvf dist/archive.tar.gz dist/main
+```
+
+This script automates the process of setting up a Python virtual environment on a Linux arm64 machine, installing dependencies, packaging the Python module into a standalone executable using PyInstaller, and then compressing the resulting executable into a tarball.
+For more examples of build scripts see [Update an existing module using a GitHub action](/build-modules/manage-modules/#update-automatically-from-a-github-repo-with-cloud-build).
+
+{{% alert title="Note" color="note" %}}
+
+PyInstaller does not support relative imports in entrypoints (imports starting with `.`).
+If you get `"ImportError: attempted relative import with no known parent package"`, set up a stub entrypoint as described on [GitHub](https://github.com/pyinstaller/pyinstaller/issues/2560).
+
+In addition, PyInstaller does not support cross-compiling: you must compile your module on the target architecture you wish to support.
+For example, you cannot run a module on a Linux `arm64` system if you compiled it using PyInstaller on a Linux `amd64` system.
+Viam makes this easy to manage by providing a build system for modules.
+Follow [these instructions](/cli/#using-the-build-subcommand) to automatically build for each system your module can support using Viam's [CLI](/cli/).
+
+{{% /alert %}}
+
+{{% /tab %}}
+{{% tab name="Python: venv" %}}
+
+Create a `run.sh` shell script that creates a new Python virtual environment, ensures that the package dependencies your module requires are installed, and runs your module.
+This is the recommended approach for modules written in Python:
+
+1. Create a `requirements.txt` file containing a list of all the dependencies your module requires.
+   For example, a `requirements.txt` file with the following contents ensures that the Viam Python SDK (`viam-sdk`) is installed:
+
+   ```sh { class="command-line" data-prompt="$"}
+   viam-sdk
+   ```
+
+   Add additional dependencies for your module as needed.
+   See the [pip `requirements.txt` file documentation](https://pip.pypa.io/en/stable/reference/requirements-file-format/) for more information.
+
+1. Add a shell script that creates a new virtual environment, installs the dependencies listed in `requirements.txt`, and runs the module entry point file `main.py`:
+
+   ```sh { class="command-line" data-prompt="$"}
+   #!/bin/sh
+   cd `dirname $0`
+
+   # Create a virtual environment to run our code
+   VENV_NAME="venv"
+   PYTHON="$VENV_NAME/bin/python"
+
+   python3 -m venv $VENV_NAME
+   $PYTHON -m pip install -r requirements.txt -U # remove -U if viam-sdk should not be upgraded whenever possible
+
+   # Be sure to use `exec` so that termination signals reach the python process,
+   # or handle forwarding termination signals manually
+   exec $PYTHON <your-src-dir-if-inside>/main.py $@
+   ```
+
+1. Make your shell script executable by running the following command in your terminal:
+
+   ```sh { class="command-line" data-prompt="$"}
+   sudo chmod +x <your-file-path-to>/run.sh
+   ```
+
+Using a virtual environment together with a `requirements.txt` file and a `run.sh` file that references it ensures that your module has access to any packages it requires during runtime.
+If you intend to share your module with other users, or to deploy it to a fleet of machines, this approach handles dependency resolution for each deployment automatically, meaning that there is no need to explicitly determine and install the Python packages your module requires to run on each machine that installs your module.
+See [prepare a Python virtual environment](/reference/sdks/python/python-venv/) for more information.
+
+{{% /tab %}}
+{{% tab name="Python: nuitka" %}}
+
+Use the [`nuitka` Python compiler](https://pypi.org/project/Nuitka/) to compile your module into a single executable file:
+
+1. In order to use Nuitka, you must install a [supported C compiler](https://github.com/Nuitka/Nuitka#c-compiler) on your machine.
+
+1. Then, [create a Python virtual environment](/reference/sdks/python/python-venv/) in your module's directory to ensure your module has access to any required libraries.
+   Be sure you are within your Python virtual environment for the rest of these steps: your terminal prompt should include the name of your virtual environment in parentheses.
+
+1. Create a `requirements.txt` file containing a list of all the dependencies your module requires.
+   For example, a `requirements.txt` file with the following contents ensures that the Viam Python SDK (`viam-sdk`) and Nuitka (`nuitka`) are installed:
+
+   ```sh { class="command-line" data-prompt="$"}
+   viam-sdk
+   nuitka
+   ```
+
+   Add additional dependencies for your module as needed.
+   See the [pip `requirements.txt` file documentation](https://pip.pypa.io/en/stable/reference/requirements-file-format/) for more information.
+
+1. Install the dependencies listed in your `requirements.txt` file within your Python virtual environment using the following command:
+
+   ```sh { class="command-line" data-prompt="$"}
+   python -m pip install -r requirements.txt -U
+   ```
+
+1. Then, compile your module using Nuitka with the following command:
+
+   ```sh { class="command-line" data-prompt="$"}
+   python -m nuitka --onefile src/main.py
+   ```
+
+   If you need to include any additional data files to support your module, specify them using the `--include-data-files` flag:
+
+   ```sh { class="command-line" data-prompt="$"}
+   python -m nuitka --onefile --include-data-files=src/arm/my_arm_kinematics.json src/main.py
+   ```
+
+Compiling your Python module in this fashion ensures that your module has access to any packages it requires during runtime.
+If you intend to share your module with other users, or to deploy it to a fleet of machines, this approach "bundles" your module code together with its required dependencies, making your module highly-portable across like architectures.
+
+However, used in this manner, Nuitka does not support relative imports (imports starting with `.`).
+In addition, Nuitka does not support cross-compiling: you can only compile your module on the target architecture you wish to support if using the Nutika approach.
+If you want to cross-compile your module, consider using a different local compilation method, or the [`module build start` command](/cli/#using-the-build-subcommand) to build your module on a cloud build host, which supports building for multiple platforms.
+For example, you cannot run a module on a Linux `arm64` system if you compiled it using Nuitka on a Linux `amd64` system.
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+Use Go to compile your module into a single executable:
+
+- Navigate to your module directory in your terminal.
+- Run `go build` to compile your entry point (main program) file <file>main.go</file> and all other <file>.go</file> files in the directory, building your module and all dependencies into a single executable file.
+- Run `ls` in your module directory to find the executable, which should have the same name as the module directory.
+
+Compiling your Go module also generates the `go.mod` and `go.sum` files that define dependency resolution in Go.
+
+See the [Go compilation documentation](https://pkg.go.dev/cmd/go#hdr-Compile_packages_and_dependencies) for more information.
+
+{{% /tab %}}
+{{% tab name="C++" %}}
+
+Create a <file>CMakeLists.txt</file> file to define how to compile your module and a <file>run.sh</file> file to wrap your executable, and then use C++ to compile your source files into a single executable:
+
+1. Create a <file>CMakeLists.txt</file> file in your module directory to instruct the compiler how to compile your module.
+   For example, the following basic configuration downloads the C++ SDK and handles compile-time linking for a module named `my-base`:
+
+   ```sh {class="line-numbers linkable-line-numbers"}
+   cmake_minimum_required(VERSION 3.7 FATAL_ERROR)
+
+   project(my-base LANGUAGES CXX)
+
+   set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+
+   include(FetchContent)
+   FetchContent_Declare(
+     viam-cpp-sdk
+     GIT_REPOSITORY https://github.com/viamrobotics/viam-cpp-sdk.git
+     GIT_TAG main
+     # SOURCE_DIR ${CMAKE_SOURCE_DIR}/../viam-cpp-sdk
+     CMAKE_ARGS -DVIAMCPPSDK_USE_DYNAMIC_PROTOS=ON
+     FIND_PACKAGE_ARGS
+   )
+   FetchContent_MakeAvailable(viam-cpp-sdk)
+
+   FILE(GLOB sources *.cpp)
+   add_executable(my-base ${sources})
+   target_link_libraries(my-base PRIVATE viam-cpp-sdk::viamsdk)
+   ```
+
+1. Create a <file>run.sh</file> file in your module directory to wrap the executable and perform basic sanity checks at runtime.
+
+   The following example shows a simple configuration that runs a module named `my-base`:
+
+   ```sh {class="line-numbers linkable-line-numbers"}
+   #!/usr/bin/env bash
+
+   # bash safe mode
+   set -euo pipefail
+
+   cd $(dirname $0)
+   exec ./my-base $@
+   ```
+
+1. Use C++ to compile and obtain a single executable for your module:
+
+   1. Create a new <file>build</file> directory within your module directory:
+
+      ```sh { class="command-line"}
+      mkdir build
+      cd build
+      ```
+
+   1. Build and compile your module:
+
+      ```sh { class="command-line"}
+      cmake .. -G Ninja
+      ninja all
+      ninja install
+      ```
+
+   1. Run `ls` in your module's <file>build</file> directory to find the compiled executable, which should have the same name as the module directory (`my-base` in these examples):
+
+For more information on building a module in C++, see the [C++ SDK Build Documentation](https://github.com/viamrobotics/viam-cpp-sdk/blob/main/BUILDING.md).
+
+{{% /tab %}}
+{{% /tabs %}}
+
+### (Optional) Create a README
+
+To provide usage instructions for any modular resources in your module, you should create a <file>README.md</file> file following this template:
+
+{{< expand "Click to view template" >}}
+
+Strings of the form `<INSERT X>` indicate placeholders that you need to replace with your values.
+
+{{< tabs >}}
+{{% tab name="Template" %}}
+
+````md
+# [`<INSERT MODULE NAME>` module](<INSERT LINK TO MODULE REPO>)
+
+This [module](/hardware/configure-hardware/) implements the [`<INSERT API TRIPLET>` API]<INSERT LINK TO DOCS (if applicable)> in an <INSERT MODEL> model.
+With this model, you can...
+
+## Requirements
+
+_Add instructions here for any requirements._
+
+```bash
+
+```
+
+## Configure your <INSERT MODEL NAME> <INSERT API NAME>
+
+Navigate to your machine's **CONFIGURE** tab.
+[Add <INSERT COMPONENT TYPE / INSERT RESOURCE NAME> to your machine](/hardware/configure-hardware/).
+
+On the new component panel, copy and paste the following attribute template into your <INSERT API NAME>'s attributes field:
+
+```json
+{
+  <INSERT SAMPLE ATTRIBUTES>
+}
+```
+
+### Attributes
+
+The following attributes are available for `<INSERT MODEL TRIPLET>` <INSERT API NAME>s:
+
+| Name    | Type   | Required?    | Description |
+| ------- | ------ | ------------ | ----------- |
+| `todo1` | string | **Required** | TODO        |
+| `todo2` | string | Optional     | TODO        |
+
+### Example configuration
+
+```json
+{
+  <INSERT SAMPLE CONFIGURATION(S)>
+}
+```
+
+### Next steps
+
+_Add any additional information you want readers to know and direct them towards what to do next with this module._
+_For example:_
+
+- To test your...
+- To write code against your...
+
+## Troubleshooting
+
+_Add troubleshooting notes here._
+````
+
+{{% /tab %}}
+{{% tab name="Example" %}}
+
+````md
+# [`agilex-limo` module](https://app.viam.com/module/viam/agilex-limo)
+
+This module implements the [`rdk:component:base` API](https://docs.viam.com/reference/apis/components/base/) in an `agilex` model for the [AgileX LIMO](https://global.agilex.ai/products/limo-pro) base to be used with `viam-server`.
+This driver supports differential, ackermann, and omni directional steering modes over the serial port.
+
+## Configure your `agilex-limo` base
+
+> [!NOTE]
+> Before configuring your base, you must add a machine on [Viam](https://app.viam.com).
+
+Navigate to the **CONFIGURE** tab of your machine's page.
+[Add `base` / `agilex-limo` to your machine](/hardware/configure-hardware/).
+
+On the new component panel, copy and paste the following attribute template into your base's attributes field:
+
+```json
+{
+  "drive_mode": "<ackermann|differential|omni>",
+  "serial_path": "<your-serial-path>"
+}
+```
+
+> [!NOTE]
+> For more information, see [Configure hardware on your machine](/hardware/configure-hardware/).
+
+### Attributes
+
+The following attributes are available for `viam:base:agilex-limo` bases:
+
+<!-- prettier-ignore -->
+| Name          | Type   | Required?    | Description |
+| ------------- | ------ | ------------ | ----------- |
+| `drive_mode`  | string | **Required** | LIMO [steering mode](https://docs.trossenrobotics.com/agilex_limo_docs/operation/steering_modes.html#switching-steering-modes). Options: `differential`, `ackermann`, `omni` (mecanum). |
+| `serial_path` | string | Optional     | The full filesystem path to the serial device, starting with <file>/dev/</file>. With your serial device connected, you can run `sudo dmesg \| grep tty` to show relevant device connection log messages, and then match the returned device name, such as `ttyTHS1`, to its device file, such as <file>/dev/ttyTHS1</file>. If you omit this attribute, Viam will attempt to automatically detect the path.<br>Default: `/dev/ttyTHS1` |
+
+### Example configurations:
+
+```json
+{
+  "drive_mode": "differential"
+}
+```
+
+```json
+{
+  "drive_mode": "omni",
+  "serial_path": "/dev/ttyTHS1"
+}
+```
+
+## Next steps
+
+- To test your base, go to the [**CONTROL** tab](/monitor/teleoperate/).
+- To write code against your base, use one of the [available SDKs](https://docs.viam.com/reference/sdks/).
+- To view examples using a base component, explore [these tutorials](https://docs.viam.com/tutorials/).
+
+## Local development
+
+This module is written in Go.
+
+To build: `make limobase`<br>
+To test: `make test`
+````
+
+{{% /tab %}}
+{{< /tabs >}}
+
+{{< /expand >}}
+
+## Test your module locally
+
+{{% alert title="Tip" color="tip" %}}
+
+If you would like to test your module locally against a target platform other than your development machine before uploading it, you can for example sync your code to an SBC with architecture that matches your target platform, and test your module there to verify that any code changes you have made work as expected on your target platform.
+
+{{% /alert %}}
+
+To use a local module on your machine, first make sure any physical hardware implemented in your module is connected to your machine's computer.
+Add the module to your machine's config, then add the component or service it implements:
+
+1. Navigate to the **CONFIGURE** tab of your machine's page.
+
+1. Click the **+** icon next to your machine part in the left-hand menu, select **Advanced**, then **Local module**.
+
+1. Enter a **Name** for this instance of your module.
+
+1. Enter the module's **Executable path**.
+   This path must be the absolute path on your machine's filesystem to either:
+
+   - the module's executable file, such as `run.sh` or a compiled binary.
+   - a [packaged tarball](https://www.cs.swarthmore.edu/~newhall/unixhelp/howto_tar.html) of your module, ending in `.tar.gz` or `.tgz`.
+     If you are providing a tarball file in this field, be sure that your packaged tarball contains your module's [`meta.json` file](/build-modules/module-reference/) within it.
+
+1. Then, click the **Create** button, and click **Save** in the upper right corner to save your config.
+
+1. Still on your machine's **CONFIGURE** tab, click the **+** icon next to your machine part in the left-hand menu.
+
+1. Select **Advanced**, then **Local module**, then **Local component** or **Local service**.
+
+1. Select or enter the {{< glossary_tooltip term_id="model-namespace-triplet" text="model namespace triplet">}} of your modular resource's {{< glossary_tooltip term_id="model" text="model" >}}.
+
+   {{<imgproc src="/how-tos/sensor-module-config.png" resize="600x" style="width: 300px" alt="Configuring a local component after the local module is configured" class="shadow" >}}
+
+1. Select the type of modular resource provided by your module, such as a [camera](/operate/reference/components/camera/), from the dropdown menu.
+
+1. Enter a name for this instance of your modular resource.
+   This name must be different from the module name.
+
+1. Click **Create** to create the modular resource provided by the local module.
+
+Once you've added your local module using steps 1-5, you can repeat steps 6-11 to add as many additional instances of your modular resource as you need.
+
+## Upload your module to the modular resource registry
+
+Once you are satisfied with the state of your module, you can upload your module to the Viam Registry to:
+
+- share your module with other Viam users
+- deploy your module to a fleet of machines from a central interface
+
+See [Update and manage modules you created](/build-modules/manage-modules/) for instructions.
+
+## Deploy your module to more machines
+
+You have now created a module, and are ready to deploy it to a fleet of machines.
+There are two ways to deploy a module:
+
+- Through the Viam Registry: Once you have uploaded your new module to the Viam Registry, [add the module to one or more machines](/hardware/configure-hardware/).
+  You can also choose to configure [automated uploads for new module versions](/build-modules/manage-modules/#update-automatically-from-a-github-repo-with-cloud-build) through a continuous integration (CI) workflow, using a GitHub Action if desired, greatly simplifying how you push changes to your module to the registry as you make them.
+- As a local module (without uploading it to Viam), as you did in the [Test your module locally step above](#test-your-module-locally).
+  This is a great way to test, but if you'd like to use the module on more machines it's easiest to add it to the registry either publicly or privately.
+
+Often, developers first test their new module by deploying it as a local module to a test machine.
+With a local installation, you can test your module in a controlled environment to confirm that it functions as expected, and make changes to your module as needed.
+
+## Next steps
+
+For instructions on how to update or delete modules you've created, see the following how-to guide:
+
+{{< cards >}}
+{{% card link="/build-modules/manage-modules/" %}}
+{{< /cards >}}
+
+To read more about module development at Viam, check out these tutorials that create modules:
+
+{{< cards >}}
+{{% card link="/tutorials/custom/custom-base-dog/" %}}
+{{% card link="/tutorials/configure/pet-photographer/" %}}
+{{< /cards >}}
diff --git a/docs/build-modules/write-a-driver-module.md b/docs/build-modules/write-a-driver-module.md
new file mode 100644
index 0000000000..16d2cc348d
--- /dev/null
+++ b/docs/build-modules/write-a-driver-module.md
@@ -0,0 +1,1077 @@
+---
+linkTitle: "Write a driver module"
+title: "Write a driver module"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "Build a module that implements a resource API and runs as a separate process."
+date: "2025-01-30"
+aliases:
+  - /build/development/write-a-module/
+  - /development/write-a-module/
+  - /development/write-a-driver-module/
+  - /registry/create/
+  - /use-cases/create-module/
+  - /how-tos/create-module/
+  - /how-tos/sensor-module/
+  - /registry/advanced/iterative-development/
+  - /build/program/extend/modular-resources/
+  - /program/extend/modular-resources/
+  - /extend/
+  - /extend/modular-resources/
+  - /extend/modular-resources/create/
+  - /build/program/extend/modular-resources/key-concepts/
+  - /modular-resources/key-concepts/
+  - /modular-resources/
+  - /extend/modular-resources/examples/custom-arm/
+  - /modular-resources/examples/custom-arm/
+  - /registry/examples/custom-arm/
+  - /program/extend/modular-resources/examples/
+  - /extend/modular-resources/examples/
+  - /modular-resources/examples/
+  - /registry/examples/
+  - /how-tos/hello-world-module/
+---
+
+You want to use hardware that Viam doesn't support out of the box. A driver
+module integrates it with the platform by implementing a standard resource API
+(sensor, camera, motor, or any other type). Once your hardware speaks a Viam
+API, data capture, TEST cards, the SDKs, and other platform features work
+with it automatically.
+
+A driver module runs as a separate process alongside `viam-server`. It has its
+own dependencies, can crash without affecting `viam-server`, and can be
+packaged and distributed through the Viam registry.
+
+For background on choosing a resource API, module lifecycle, and dependencies,
+see the [overview](/build-modules/overview/).
+
+## Steps
+
+When writing a module, follow the steps outlined below. To illustrate each step we'll use a sensor module as a worked example. The same patterns
+apply to any resource type -- substitute the appropriate API and methods for
+your use case.
+
+### 1. Generate the module
+
+Run the Viam CLI generator:
+
+```bash
+viam module generate
+```
+
+| Prompt           | What to enter               | Why                              |
+| ---------------- | --------------------------- | -------------------------------- |
+| Module name      | `my-sensor-module`          | A short, descriptive name        |
+| Language         | `python` or `go`            | Your implementation language     |
+| Visibility       | `private`                   | Keep it private while developing |
+| Namespace        | Your organization namespace | Scopes the module to your org    |
+| Resource subtype | `sensor`                    | The resource API to implement    |
+| Model name       | `my-sensor`                 | The model name for your sensor   |
+| Register         | `yes`                       | Registers the module with Viam   |
+
+The generator creates a complete project with the following files:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+| File                           | Purpose                                       |
+| ------------------------------ | --------------------------------------------- |
+| `src/main.py`                  | Entry point -- starts the module server       |
+| `src/models/my_sensor.py`      | Resource class skeleton -- you will edit this |
+| `requirements.txt`             | Python dependencies                           |
+| `meta.json`                    | Module metadata for the registry              |
+| `setup.sh`                     | Installs dependencies into a virtualenv       |
+| `build.sh`                     | Packages the module for upload                |
+| `.github/workflows/deploy.yml` | CI workflow for cloud builds                  |
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+| File                           | Purpose                                                |
+| ------------------------------ | ------------------------------------------------------ |
+| `cmd/module/main.go`           | Entry point -- starts the module server                |
+| `my_sensor_module.go`          | Resource implementation skeleton -- you will edit this |
+| `go.mod`                       | Go module definition                                   |
+| `Makefile`                     | Build targets                                          |
+| `meta.json`                    | Module metadata for the registry                       |
+| `.github/workflows/deploy.yml` | CI workflow for cloud builds                           |
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 2. Implement the resource API
+
+Open the generated resource file. The generator creates a class (Python) or
+struct (Go) with stub methods. You need to make three changes:
+
+1. Define your config attributes.
+2. Add validation logic.
+3. Implement the API methods for your resource type.
+
+The following example builds a sensor that reads temperature and humidity from
+a custom HTTP API endpoint. Replace the HTTP call with whatever data source
+your sensor uses.
+
+#### Define your config attributes
+
+Config attributes are the fields a user sets when they configure your component
+in the Viam app. The generator creates an empty config; add a field for each
+attribute your module needs.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+In `src/models/my_sensor.py`, add instance attributes to your class. These will
+be set in the `reconfigure` method:
+
+```python
+class MySensor(Sensor, EasyResource):
+    MODEL: ClassVar[Model] = Model(
+        ModelFamily("my-org", "my-sensor-module"), "my-sensor"
+    )
+
+    # Add your config attributes as instance variables
+    source_url: str
+    poll_interval: float
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+In the generated `.go` file, find the empty `Config` struct and add fields.
+Each field needs a `json` tag that matches the attribute name users will set in
+their config JSON:
+
+```go
+type Config struct {
+    SourceURL    string  `json:"source_url"`
+    PollInterval float64 `json:"poll_interval"`
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+#### Add validation logic
+
+The generator creates an empty validation method. Add checks for required
+fields and return any [dependencies](/build-modules/dependencies/) your module needs.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+Find `validate_config` in your class and add validation:
+
+```python
+    @classmethod
+    def validate_config(
+        cls, config: ComponentConfig
+    ) -> Tuple[Sequence[str], Sequence[str]]:
+        fields = config.attributes.fields
+        if "source_url" not in fields:
+            raise Exception("source_url is required")
+        if not fields["source_url"].string_value.startswith("http"):
+            raise Exception("source_url must be an HTTP or HTTPS URL")
+        return [], []  # No required or optional dependencies
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+Find the `Validate` method on your `Config` struct and add validation:
+
+```go
+func (cfg *Config) Validate(path string) ([]string, []string, error) {
+    if cfg.SourceURL == "" {
+        return nil, nil, fmt.Errorf("source_url is required")
+    }
+    return nil, nil, nil // No required or optional dependencies
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+The validation method returns two lists: required dependencies and optional
+dependencies. For a standalone sensor with no dependencies, return empty lists.
+See [Step 5](#5-handle-dependencies) for modules that depend on other
+components.
+
+#### Implement the constructor and reconfigure method
+
+The constructor creates your resource and the reconfigure method updates it when
+the config changes. In Python, the typical pattern is for `new` to call
+`reconfigure` so the config-reading logic lives in one place.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+Update `new` and add a `reconfigure` method:
+
+```python
+    @classmethod
+    def new(cls, config: ComponentConfig,
+            dependencies: Mapping[ResourceName, ResourceBase]) -> Self:
+        sensor = cls(config.name)
+        sensor.reconfigure(config, dependencies)
+        return sensor
+
+    def reconfigure(self, config: ComponentConfig,
+                    dependencies: Mapping[ResourceName, ResourceBase]) -> None:
+        fields = config.attributes.fields
+        self.source_url = fields["source_url"].string_value
+        self.poll_interval = (
+            fields["poll_interval"].number_value
+            if "poll_interval" in fields
+            else 10.0
+        )
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+Find the generated constructor function. Update it to read your config fields
+and initialize your struct:
+
+```go
+func newMySensor(
+    ctx context.Context,
+    deps resource.Dependencies,
+    conf resource.Config,
+    logger logging.Logger,
+) (sensor.Sensor, error) {
+    cfg, err := resource.NativeConfig[*Config](conf)
+    if err != nil {
+        return nil, err
+    }
+
+    timeout := time.Duration(cfg.PollInterval) * time.Second
+    if timeout == 0 {
+        timeout = 10 * time.Second
+    }
+
+    return &MySensor{
+        Named:     conf.ResourceName().AsNamed(),
+        logger:    logger,
+        sourceURL: cfg.SourceURL,
+        client:    &http.Client{Timeout: timeout},
+    }, nil
+}
+```
+
+You will also need to add fields to the generated struct for any state your
+module needs at runtime:
+
+```go
+type MySensor struct {
+    resource.Named
+    resource.AlwaysRebuild
+    logger    logging.Logger
+    sourceURL string
+    client    *http.Client
+}
+```
+
+The generated struct includes `resource.AlwaysRebuild`, which tells
+`viam-server` to destroy and re-create the resource on every config change.
+This is the simplest approach and works well for most modules. For in-place
+reconfiguration, see [Step 6](#6-handle-reconfiguration-optional).
+
+{{% /tab %}}
+{{< /tabs >}}
+
+#### Implement the API method
+
+For a sensor, the key method is `GetReadings`, which returns a map of reading
+names to values. This is the method that data capture calls and your application
+code queries.
+
+The generator creates a stub that returns an error. Replace it with your
+implementation:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+Add a `get_readings` method to your class. The return type is
+`Mapping[str, SensorReading]` (import `SensorReading` from `viam.utils`):
+
+```python
+    async def get_readings(
+        self,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Mapping[str, SensorReading]:
+        try:
+            response = requests.get(self.source_url, timeout=5)
+            response.raise_for_status()
+            data = response.json()
+            return {
+                "temperature": data["temp"],
+                "humidity": data["humidity"],
+            }
+        except requests.RequestException as e:
+            self.logger.error(f"Failed to read from {self.source_url}: {e}")
+            return {"error": str(e)}
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+Find the `Readings` method stub and replace it:
+
+```go
+type sensorResponse struct {
+    Temp     float64 `json:"temp"`
+    Humidity float64 `json:"humidity"`
+}
+
+func (s *MySensor) Readings(
+    ctx context.Context,
+    extra map[string]interface{},
+) (map[string]interface{}, error) {
+    resp, err := s.client.Get(s.sourceURL)
+    if err != nil {
+        s.logger.CErrorw(ctx, "failed to read from source",
+            "url", s.sourceURL, "error", err)
+        return nil, fmt.Errorf("failed to read from %s: %w", s.sourceURL, err)
+    }
+    defer resp.Body.Close()
+
+    var data sensorResponse
+    if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+        return nil, fmt.Errorf("failed to decode response: %w", err)
+    }
+
+    return map[string]interface{}{
+        "temperature": data.Temp,
+        "humidity":    data.Humidity,
+    }, nil
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+{{< expand "View the complete resource file" >}}
+
+For reference, here is the complete resource file after all the changes above.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+`src/models/my_sensor.py`:
+
+```python
+import requests
+from typing import Any, ClassVar, Mapping, Optional, Sequence, Self, Tuple
+
+from viam.components.sensor import Sensor
+from viam.proto.app.robot import ComponentConfig
+from viam.proto.common import ResourceName
+from viam.resource.base import ResourceBase
+from viam.resource.easy_resource import EasyResource
+from viam.resource.types import Model, ModelFamily
+from viam.utils import SensorReading
+
+
+class MySensor(Sensor, EasyResource):
+    """A custom sensor that reads from an HTTP endpoint."""
+
+    MODEL: ClassVar[Model] = Model(
+        ModelFamily("my-org", "my-sensor-module"), "my-sensor"
+    )
+
+    source_url: str
+    poll_interval: float
+
+    @classmethod
+    def new(cls, config: ComponentConfig,
+            dependencies: Mapping[ResourceName, ResourceBase]) -> Self:
+        sensor = cls(config.name)
+        sensor.reconfigure(config, dependencies)
+        return sensor
+
+    @classmethod
+    def validate_config(
+        cls, config: ComponentConfig
+    ) -> Tuple[Sequence[str], Sequence[str]]:
+        fields = config.attributes.fields
+        if "source_url" not in fields:
+            raise Exception("source_url is required")
+        if not fields["source_url"].string_value.startswith("http"):
+            raise Exception("source_url must be an HTTP or HTTPS URL")
+        return [], []
+
+    def reconfigure(self, config: ComponentConfig,
+                    dependencies: Mapping[ResourceName, ResourceBase]) -> None:
+        fields = config.attributes.fields
+        self.source_url = fields["source_url"].string_value
+        self.poll_interval = (
+            fields["poll_interval"].number_value
+            if "poll_interval" in fields
+            else 10.0
+        )
+
+    async def get_readings(
+        self,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Mapping[str, SensorReading]:
+        try:
+            response = requests.get(self.source_url, timeout=5)
+            response.raise_for_status()
+            data = response.json()
+            return {
+                "temperature": data["temp"],
+                "humidity": data["humidity"],
+            }
+        except requests.RequestException as e:
+            self.logger.error(f"Failed to read from {self.source_url}: {e}")
+            return {"error": str(e)}
+
+    async def close(self):
+        self.logger.info("Shutting down MySensor")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+`my_sensor_module.go`:
+
+```go
+package mysensormodule
+
+import (
+    "context"
+    "encoding/json"
+    "fmt"
+    "net/http"
+    "time"
+
+    "go.viam.com/rdk/components/sensor"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/resource"
+)
+
+var Model = resource.NewModel("my-org", "my-sensor-module", "my-sensor")
+
+type Config struct {
+    SourceURL    string  `json:"source_url"`
+    PollInterval float64 `json:"poll_interval"`
+}
+
+func (cfg *Config) Validate(path string) ([]string, []string, error) {
+    if cfg.SourceURL == "" {
+        return nil, nil, fmt.Errorf("source_url is required")
+    }
+    return nil, nil, nil
+}
+
+func init() {
+    resource.RegisterComponent(sensor.API, Model,
+        resource.Registration[sensor.Sensor, *Config]{
+            Constructor: newMySensor,
+        },
+    )
+}
+
+type MySensor struct {
+    resource.Named
+    resource.AlwaysRebuild
+    logger    logging.Logger
+    sourceURL string
+    client    *http.Client
+}
+
+func newMySensor(
+    ctx context.Context,
+    deps resource.Dependencies,
+    conf resource.Config,
+    logger logging.Logger,
+) (sensor.Sensor, error) {
+    cfg, err := resource.NativeConfig[*Config](conf)
+    if err != nil {
+        return nil, err
+    }
+
+    timeout := time.Duration(cfg.PollInterval) * time.Second
+    if timeout == 0 {
+        timeout = 10 * time.Second
+    }
+
+    return &MySensor{
+        Named:     conf.ResourceName().AsNamed(),
+        logger:    logger,
+        sourceURL: cfg.SourceURL,
+        client:    &http.Client{Timeout: timeout},
+    }, nil
+}
+
+type sensorResponse struct {
+    Temp     float64 `json:"temp"`
+    Humidity float64 `json:"humidity"`
+}
+
+func (s *MySensor) Readings(
+    ctx context.Context,
+    extra map[string]interface{},
+) (map[string]interface{}, error) {
+    resp, err := s.client.Get(s.sourceURL)
+    if err != nil {
+        s.logger.CErrorw(ctx, "failed to read from source",
+            "url", s.sourceURL, "error", err)
+        return nil, fmt.Errorf("failed to read from %s: %w", s.sourceURL, err)
+    }
+    defer resp.Body.Close()
+
+    var data sensorResponse
+    if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+        return nil, fmt.Errorf("failed to decode response: %w", err)
+    }
+
+    return map[string]interface{}{
+        "temperature": data.Temp,
+        "humidity":    data.Humidity,
+    }, nil
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+{{< /expand >}}
+
+#### Understanding the entry point
+
+The generator also creates the entry point file that `viam-server` launches.
+You typically do not need to modify it.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+`src/main.py`:
+
+```python
+import asyncio
+from viam.module.module import Module
+from models.my_sensor import MySensor  # noqa: F401
+
+
+if __name__ == "__main__":
+    asyncio.run(Module.run_from_registry())
+```
+
+`run_from_registry()` automatically discovers all imported resource classes and
+registers them with `viam-server`. If you add more models to your module, import
+them here.
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+`cmd/module/main.go`:
+
+```go
+package main
+
+import (
+    mysensormodule "my-org/my-sensor-module"
+    "go.viam.com/rdk/components/sensor"
+    "go.viam.com/rdk/module"
+    "go.viam.com/rdk/resource"
+)
+
+func main() {
+    module.ModularMain(resource.APIModel{sensor.API, mysensormodule.Model})
+}
+```
+
+`ModularMain` handles socket parsing, signal handling, and graceful shutdown.
+The import of the resource package triggers its `init()` function, which calls
+`resource.RegisterComponent` to register the model. If you add more models,
+add more `resource.APIModel` entries to the `ModularMain` call.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 3. Test locally
+
+Use the CLI to build and deploy your module to a machine, then verify it works.
+
+**Deploy with hot reloading:**
+
+```bash
+# Build in the cloud and deploy to the machine
+viam module reload --part-id <machine-part-id>
+```
+
+If your development machine and target machine share the same architecture (for example, both are `linux/arm64`), you can build locally instead:
+
+```bash
+# Build locally and transfer to the machine
+viam module reload-local --part-id <machine-part-id>
+```
+
+Use `reload` (cloud build) when developing on a different architecture than your target, for example when developing on macOS and deploying to a Raspberry Pi. Use `reload-local` when architectures match for faster iteration.
+
+After deploying, configure the component's attributes in the Viam app:
+
+```json
+{
+  "source_url": "https://api.example.com/sensor/data"
+}
+```
+
+Click **Save**.
+
+**Test using the Test section:**
+
+1. Find your sensor component and expand the **Test** section.
+2. Your temperature and humidity values appear automatically under
+   **GetReadings**.
+
+**Get a ready-to-run code sample:**
+
+The **CONNECT** tab on your machine's page in the Viam app provides generated
+code samples in Python and Go that connect to your machine and access all
+configured components. Use this as a starting point for application code that
+interacts with your module.
+
+**Rebuild and redeploy during development:**
+
+Each time you make changes, run `viam module reload` (or `reload-local`) again. Use `--no-build` to skip the build step if you already built manually. Use `viam module restart` to restart without rebuilding (for example, after editing Python source).
+
+### 4. Add logging
+
+Both the Python and Go SDKs provide a logger that writes to `viam-server`'s log
+stream, visible in the **LOGS** tab.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+self.logger.info("Sensor initialized with source URL: %s", self.source_url)
+self.logger.debug("Raw response from source: %s", data)
+self.logger.warning("Source returned unexpected field: %s", field_name)
+self.logger.error("Failed to connect to source: %s", error)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+s.logger.CInfof(ctx, "Sensor initialized with source URL: %s", s.sourceURL)
+s.logger.CDebugf(ctx, "Raw response from source: %v", data)
+s.logger.CWarnw(ctx, "Source returned unexpected field", "field", fieldName)
+s.logger.CErrorw(ctx, "Failed to connect to source", "error", err)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Use `info` for significant events, `debug` for detailed data, `warning` for
+recoverable problems, and `error` for failures.
+
+### 5. Handle dependencies
+
+Many modules need access to other resources on the same machine. To use
+another resource, you need to do three things:
+
+1. **Declare the dependency** in your config validation method by returning the
+   resource name in the required (or optional) dependencies list.
+2. **Resolve the dependency** in your constructor or reconfigure method by
+   looking it up from the `dependencies` map that `viam-server` passes in.
+3. **Call methods on it** in your API implementation, just like any other
+   typed resource.
+
+The following example shows all three. It implements a sensor that depends on
+another sensor -- it reads Celsius temperature readings from the source sensor
+and converts them to Fahrenheit. Watch for the numbered comments in the code:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+class TempConverterSensor(Sensor, EasyResource):
+    MODEL: ClassVar[Model] = Model(
+        ModelFamily("my-org", "my-sensor-module"), "temp-converter"
+    )
+
+    source_sensor: Sensor
+
+    @classmethod
+    def validate_config(
+        cls, config: ComponentConfig
+    ) -> Tuple[Sequence[str], Sequence[str]]:
+        fields = config.attributes.fields
+        if "source_sensor" not in fields:
+            raise Exception("source_sensor is required")
+        source = fields["source_sensor"].string_value
+        # 1. Declare: return the source sensor name as a required dependency
+        return [source], []
+
+    def reconfigure(self, config: ComponentConfig,
+                    dependencies: Mapping[ResourceName, ResourceBase]) -> None:
+        source_name = config.attributes.fields["source_sensor"].string_value
+        # 2. Resolve: find the dependency in the map viam-server passes in
+        for name, dep in dependencies.items():
+            if name.name == source_name:
+                self.source_sensor = dep
+                break
+
+    async def get_readings(self, *, extra=None, timeout=None,
+                           **kwargs) -> Mapping[str, SensorReading]:
+        # 3. Use: call methods on the dependency like any typed resource
+        readings = await self.source_sensor.get_readings()
+        celsius = readings["temperature"]
+        return {"temperature_f": celsius * 9.0 / 5.0 + 32.0}
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+type ConverterConfig struct {
+    SourceSensor string `json:"source_sensor"`
+}
+
+func (cfg *ConverterConfig) Validate(path string) ([]string, []string, error) {
+    if cfg.SourceSensor == "" {
+        return nil, nil, fmt.Errorf("source_sensor is required")
+    }
+    // 1. Declare: return the source sensor name as a required dependency
+    return []string{cfg.SourceSensor}, nil, nil
+}
+
+type TempConverterSensor struct {
+    resource.Named
+    resource.AlwaysRebuild
+    logger logging.Logger
+    source sensor.Sensor
+}
+
+func newTempConverter(
+    ctx context.Context,
+    deps resource.Dependencies,
+    conf resource.Config,
+    logger logging.Logger,
+) (sensor.Sensor, error) {
+    cfg, err := resource.NativeConfig[*ConverterConfig](conf)
+    if err != nil {
+        return nil, err
+    }
+
+    // 2. Resolve: look up the dependency by name from the map viam-server passes in
+    src, err := sensor.FromProvider(deps, cfg.SourceSensor)
+    if err != nil {
+        return nil, fmt.Errorf("source sensor %q not found: %w",
+            cfg.SourceSensor, err)
+    }
+
+    return &TempConverterSensor{
+        Named:  conf.ResourceName().AsNamed(),
+        logger: logger,
+        source: src,
+    }, nil
+}
+
+func (s *TempConverterSensor) Readings(
+    ctx context.Context,
+    extra map[string]interface{},
+) (map[string]interface{}, error) {
+    // 3. Use: call methods on the dependency like any typed resource
+    readings, err := s.source.Readings(ctx, extra)
+    if err != nil {
+        return nil, fmt.Errorf("failed to read source sensor: %w", err)
+    }
+    celsius, ok := readings["temperature"].(float64)
+    if !ok {
+        return nil, fmt.Errorf("source sensor did not return a temperature reading")
+    }
+    return map[string]interface{}{
+        "temperature_f": celsius*9.0/5.0 + 32.0,
+    }, nil
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 6. Handle reconfiguration (optional)
+
+When a user changes a resource's configuration, `viam-server` calls your
+reconfiguration method instead of destroying and re-creating the resource.
+This is faster and preserves internal state like open connections.
+
+The generated code uses `resource.AlwaysRebuild` (Go) by default, which
+tells `viam-server` to destroy and re-create the resource on every config
+change. This is the simplest approach and works well for most modules.
+
+For in-place reconfiguration, implement the reconfiguration method to update
+your resource's fields directly:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+Implement `reconfigure` to update your resource from the new config. This
+method is also typically called from `new` (see the example in Step 2):
+
+```python
+def reconfigure(self, config: ComponentConfig,
+                dependencies: Mapping[ResourceName, ResourceBase]) -> None:
+    fields = config.attributes.fields
+    self.source_url = fields["source_url"].string_value
+    self.poll_interval = (
+        fields["poll_interval"].number_value
+        if "poll_interval" in fields
+        else 10.0
+    )
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+Remove `resource.AlwaysRebuild` from your struct and implement `Reconfigure`:
+
+```go
+type MySensor struct {
+    resource.Named
+    logger    logging.Logger
+    sourceURL string
+    client    *http.Client
+}
+
+func (s *MySensor) Reconfigure(ctx context.Context,
+    deps resource.Dependencies, conf resource.Config) error {
+    cfg, err := resource.NativeConfig[*Config](conf)
+    if err != nil {
+        return err
+    }
+    s.sourceURL = cfg.SourceURL
+    s.client.Timeout = time.Duration(cfg.PollInterval) * time.Second
+    return nil
+}
+```
+
+Go provides these helper traits as alternatives to writing a `Reconfigure`
+method. Embed one in your struct:
+
+| Trait                              | Behavior                                                                             |
+| ---------------------------------- | ------------------------------------------------------------------------------------ |
+| `resource.AlwaysRebuild`           | Resource is destroyed and re-created on every config change (the generated default). |
+| `resource.TriviallyReconfigurable` | Config changes are accepted silently with no action.                                 |
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 7. Use the module data directory
+
+Every module gets a persistent data directory at the path specified by the
+`VIAM_MODULE_DATA` environment variable. Use this for caches, databases, or
+any state that should survive module restarts.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+import os
+
+data_dir = os.environ.get("VIAM_MODULE_DATA", "/tmp")
+cache_path = os.path.join(data_dir, "readings_cache.json")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+dataDir := os.Getenv("VIAM_MODULE_DATA")
+cachePath := filepath.Join(dataDir, "readings_cache.json")
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+The directory is created automatically by `viam-server` at
+`$VIAM_HOME/module-data/<machine-id>/<module-name>/` (where `VIAM_HOME`
+defaults to `~/.viam`) and persists across module
+restarts and reconfigurations.
+
+### 8. Add multiple models to one module (optional)
+
+A single module can provide multiple models, even across different APIs
+(for example, a sensor and a camera). There is no limit on the number of models
+per module.
+
+To add a second model:
+
+1. Run `viam module generate` again in a separate directory to generate
+   the new model's scaffolding. Do not register it -- you only need the
+   generated resource file.
+2. Copy the generated resource file into your existing module's source
+   directory.
+3. Update the entry point to register both models.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+Import the new model in `src/main.py`. `run_from_registry()` automatically
+discovers all imported resource classes:
+
+```python
+import asyncio
+from viam.module.module import Module
+from models.my_sensor import MySensor  # noqa: F401
+from models.my_camera import MyCamera  # noqa: F401
+
+if __name__ == "__main__":
+    asyncio.run(Module.run_from_registry())
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+Add more `resource.APIModel` entries to `ModularMain`:
+
+```go
+package main
+
+import (
+    mymodule "my-org/my-module"
+    "go.viam.com/rdk/components/camera"
+    "go.viam.com/rdk/components/sensor"
+    "go.viam.com/rdk/module"
+    "go.viam.com/rdk/resource"
+)
+
+func main() {
+    module.ModularMain(
+        resource.APIModel{sensor.API, mymodule.SensorModel},
+        resource.APIModel{camera.API, mymodule.CameraModel},
+    )
+}
+```
+
+Each model needs its own `init()` function calling `resource.RegisterComponent`
+(or `resource.RegisterService`) with its API, model, and constructor.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+4. Delete the temporary generated directory.
+5. Update `meta.json` to list all models (or use `viam module update-models
+--binary ./bin/module` to detect them automatically from a Go binary).
+
+## Try It
+
+1. Generate a sensor module using `viam module generate`.
+2. Open the generated resource file and implement your config validation and
+   `GetReadings` method.
+3. Configure the module on your machine as a local module.
+4. Expand the **Test** section on your sensor. Verify readings appear
+   automatically under **GetReadings**.
+5. Enable data capture on the sensor. Wait one minute, then check the **DATA**
+   tab to confirm readings are flowing to the cloud.
+6. Add a new key to the readings map (for example, `"pressure": 1013.25`).
+   Rebuild and redeploy with `viam module reload-local`. Verify the new reading
+   appears on the TEST card.
+
+## Troubleshooting
+
+{{< expand "Module crashes on startup" >}}
+
+- Check the **LOGS** tab for the crash traceback. The most common cause is a
+  missing dependency -- a Python import not in `requirements.txt` or a Go
+  package not in `go.mod`.
+- For Python, verify the module runs outside of `viam-server`:
+  `python3 -m src.main` (from your module directory, with the virtualenv
+  activated).
+- For Go, verify the binary runs: `./bin/<your-module-name>` (the output path
+  is set in your `Makefile`).
+- Check that your entrypoint script has execute permissions: `chmod +x run.sh`.
+
+{{< /expand >}}
+
+{{< expand "Module times out on startup" >}}
+
+`viam-server` expects the module to complete startup within 5 minutes (the
+default `VIAM_MODULE_STARTUP_TIMEOUT`). If your module does heavy
+initialization (loading large files, connecting to slow services), it may
+time out.
+
+- Move slow initialization out of `init()` or model registration and into the
+  constructor instead, where it runs per-resource rather than blocking module
+  startup.
+- Check the **LOGS** tab for timeout errors.
+
+{{< /expand >}}
+
+{{< expand "Dependency not found" >}}
+
+- Confirm the dependency name returned by your config validation method matches
+  the resource name on the machine exactly (names are compared as strings, so
+  case and spelling must match).
+- Verify the depended-on resource exists and is configured correctly.
+- Check for circular dependencies -- if A depends on B and B depends on A,
+  both will fail to start. Check the **LOGS** tab for "circular dependency"
+  errors.
+
+{{< /expand >}}
+
+{{< expand "Readings returning None or nil" >}}
+
+- Add logging inside your `GetReadings` implementation to see what data your
+  source returns.
+- `GetReadings` must return a non-nil map. If it returns `nil` (Go) or `None`
+  (Python), `viam-server` treats this as an error.
+- Check network connectivity from the machine if your sensor reads from an
+  external source.
+
+{{< /expand >}}
+
+{{< expand "Module not restarting after code changes" >}}
+
+`viam-server` does not watch your module's source files or binary for changes.
+To deploy changes:
+
+- Use `viam module reload-local --part-id <id>` to rebuild and redeploy.
+- Use `viam module restart --part-id <id>` to restart without rebuilding.
+
+If `reload-local` fails:
+
+- **"no build command"** -- Your `meta.json` is missing a `build.build` field.
+  Add the path to your build script (for example, `"build": "./build.sh"`).
+- **"could not find module ID"** -- Run the command from the directory
+  containing `meta.json`, or use `--home <path>` to specify the module
+  directory.
+- **PermissionDenied errors** -- Try `--home $HOME` to ensure the CLI can
+  locate the module metadata.
+
+{{< /expand >}}
+
+{{< expand "Data capture not recording readings" >}}
+
+Data capture requires both the data management service and a per-resource
+capture configuration:
+
+- Verify the data management service is configured and does not have
+  `capture_disabled` set to `true`.
+- Verify your sensor component has a data capture configuration with
+  `capture_frequency_hz` greater than `0`.
+- Check that `GetReadings` returns a valid, non-nil map.
+- If the capture frequency is very low, you may need to wait longer to see
+  data appear on the [**Data** page](https://app.viam.com/data).
+
+{{< /expand >}}
+
+## What's Next
+
+- [Write a Logic Module](/build-modules/write-a-logic-module/) -- write a module
+  that monitors sensors, coordinates components, or runs automation logic.
+- [Deploy a Module](/build-modules/deploy-a-module/) -- package your module
+  and upload it to the Viam registry for distribution.
+- [Module Reference](/build-modules/module-reference/) -- complete reference
+  for meta.json, CLI commands, environment variables, and resource interfaces.
diff --git a/docs/build-modules/write-a-logic-module.md b/docs/build-modules/write-a-logic-module.md
new file mode 100644
index 0000000000..8edf4881bb
--- /dev/null
+++ b/docs/build-modules/write-a-logic-module.md
@@ -0,0 +1,690 @@
+---
+linkTitle: "Write a logic module"
+title: "Write a logic module"
+weight: 25
+layout: "docs"
+type: "docs"
+description: "Build a module that monitors sensors, coordinates components, or runs automation logic."
+date: "2025-03-06"
+aliases:
+  - /development/write-a-logic-module/
+  - /manage/software/control-logic
+---
+
+Your machine has resources -- sensors, motors, cameras -- that work individually.
+A logic module makes them work together. It runs as a service alongside
+`viam-server`, declares dependencies on the resources it needs, and implements
+whatever control, monitoring, or coordination logic your application requires.
+
+Use a logic module when you need your machine to make decisions based on what
+it senses: trigger actions when readings cross a threshold, coordinate multiple
+components to accomplish a task, aggregate data from several sources, or run
+any continuous process that reads from some resources and acts on others.
+
+{{< alert title="Driver modules and logic modules" color="tip" >}}
+A [driver module](/build-modules/write-a-driver-module/) wraps hardware -- it implements
+a component API like sensor or motor so that `viam-server` can talk to a
+specific piece of hardware.
+
+A logic module (this page) orchestrates existing resources -- it reads from
+sensors, commands motors, and makes decisions. It typically implements a service
+API.
+
+Both are modules. The difference is what they do, not how they're built. The
+lifecycle, config validation, dependency, and deployment patterns are the same.
+{{< /alert >}}
+
+For background on the generic service API, module lifecycle, dependencies, and
+background tasks, see the [overview](/build-modules/overview/).
+
+## Steps
+
+When writing a logic module, follow the steps outlined below. To illustrate
+each step we'll use a temperature alert monitor as a worked example. It watches
+one or more sensors, compares their readings against configurable thresholds,
+and maintains a list of active alerts that your application code can query.
+
+### 1. Generate a generic service module
+
+```bash
+viam module generate
+```
+
+| Prompt           | What to enter               | Why                              |
+| ---------------- | --------------------------- | -------------------------------- |
+| Module name      | `alert-monitor`             | A short, descriptive name        |
+| Language         | `python` or `go`            | Your implementation language     |
+| Visibility       | `private`                   | Keep it private while developing |
+| Namespace        | Your organization namespace | Scopes the module to your org    |
+| Resource subtype | `generic` (under services)  | Flexible service API             |
+| Model name       | `temp-alert`                | The model name for your service  |
+| Register         | `yes`                       | Registers the module with Viam   |
+
+The generator creates a complete project. The key files you will edit:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+| File                       | Purpose                                                     |
+| -------------------------- | ----------------------------------------------------------- |
+| `src/models/temp_alert.py` | Service class skeleton -- you will edit this                |
+| `src/main.py`              | Entry point -- starts the module server (no changes needed) |
+| `meta.json`                | Module metadata for the registry                            |
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+| File                 | Purpose                                                     |
+| -------------------- | ----------------------------------------------------------- |
+| `alert_monitor.go`   | Service implementation skeleton -- you will edit this       |
+| `cmd/module/main.go` | Entry point -- starts the module server (no changes needed) |
+| `meta.json`          | Module metadata for the registry                            |
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 2. Define the config
+
+Open the generated resource file. Define config attributes for the sensors to
+monitor and the alert thresholds.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+In `src/models/temp_alert.py`, add config attributes to your class:
+
+```python
+class TempAlert(Generic, EasyResource):
+    MODEL: ClassVar[Model] = Model(
+        ModelFamily("my-org", "alert-monitor"), "temp-alert"
+    )
+
+    sensor_names: list[str]
+    max_temp: float
+    poll_interval: float
+    alerts: list[dict]
+    _monitor_task: Optional[asyncio.Task]
+    _stop_event: asyncio.Event
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+In the generated `.go` file, add fields to the `Config` struct. Each field
+needs a `json` tag matching the attribute name users set in their config JSON.
+
+Then update the `Validate` method. It returns three values: a list of required
+dependency names, a list of optional dependency names, and an error.
+
+```go
+type Config struct {
+    SensorNames  []string `json:"sensor_names"`
+    MaxTemp      float64  `json:"max_temp"`
+    PollInterval float64  `json:"poll_interval_secs"`
+}
+
+func (cfg *Config) Validate(path string) ([]string, []string, error) {
+    if len(cfg.SensorNames) == 0 {
+        return nil, nil, fmt.Errorf("sensor_names is required")
+    }
+    if cfg.MaxTemp == 0 {
+        return nil, nil, fmt.Errorf("max_temp is required")
+    }
+    // 1. Declare: return all sensor names as required dependencies
+    return cfg.SensorNames, nil, nil
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 3. Implement the constructor
+
+The constructor receives the validated config and a `dependencies` map
+containing the resources you declared in the validation method. Look up each
+dependency by name, store it on your struct/instance, and start the background
+monitoring loop.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+Update `validate_config`, `new`, and `reconfigure`:
+
+```python
+    @classmethod
+    def validate_config(
+        cls, config: ComponentConfig
+    ) -> Tuple[Sequence[str], Sequence[str]]:
+        fields = config.attributes.fields
+        if "sensor_names" not in fields:
+            raise Exception("sensor_names is required")
+        if "max_temp" not in fields:
+            raise Exception("max_temp is required")
+        sensor_names = [
+            v.string_value
+            for v in fields["sensor_names"].list_value.values
+        ]
+        # 1. Declare: return sensor names as required dependencies
+        return sensor_names, []
+
+    @classmethod
+    def new(cls, config: ComponentConfig,
+            dependencies: Mapping[ResourceName, ResourceBase]) -> Self:
+        instance = cls(config.name)
+        instance.alerts = []
+        instance._monitor_task = None
+        instance._stop_event = asyncio.Event()
+        instance.reconfigure(config, dependencies)
+        return instance
+
+    def reconfigure(self, config: ComponentConfig,
+                    dependencies: Mapping[ResourceName, ResourceBase]) -> None:
+        # Stop any existing monitor loop
+        if self._monitor_task is not None:
+            self._stop_event.set()
+            self._monitor_task = None
+
+        fields = config.attributes.fields
+        self.sensor_names = [
+            v.string_value
+            for v in fields["sensor_names"].list_value.values
+        ]
+        self.max_temp = fields["max_temp"].number_value
+        self.poll_interval = (
+            fields["poll_interval_secs"].number_value
+            if "poll_interval_secs" in fields
+            else 10.0
+        )
+
+        # 2. Resolve: find each sensor in the dependencies map
+        self.sensors = {}
+        for name, dep in dependencies.items():
+            if name.name in self.sensor_names:
+                self.sensors[name.name] = dep
+
+        # Start the monitor loop
+        self._stop_event = asyncio.Event()
+        self._monitor_task = asyncio.create_task(self._monitor_loop())
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+Update the struct and constructor. `resource.Named` provides the `Name()`
+method that `viam-server` requires. `resource.NativeConfig` converts the raw
+config into your typed struct. `sensor.FromProvider` looks up a sensor
+dependency by name from the dependencies map.
+
+```go
+type TempAlert struct {
+    resource.Named
+    logger   logging.Logger
+    cfg      *Config
+    sensors  map[string]sensor.Sensor
+    mu       sync.Mutex
+    alerts   []Alert
+    cancelFn func()
+}
+
+type Alert struct {
+    Sensor    string  `json:"sensor"`
+    Value     float64 `json:"value"`
+    Threshold float64 `json:"threshold"`
+    Time      string  `json:"time"`
+}
+
+func newTempAlert(
+    ctx context.Context,
+    deps resource.Dependencies,
+    conf resource.Config,
+    logger logging.Logger,
+) (resource.Resource, error) {
+    cfg, err := resource.NativeConfig[*Config](conf)
+    if err != nil {
+        return nil, err
+    }
+
+    // 2. Resolve: find each sensor in the dependencies map
+    sensors := make(map[string]sensor.Sensor)
+    for _, name := range cfg.SensorNames {
+        s, err := sensor.FromProvider(deps, name)
+        if err != nil {
+            return nil, fmt.Errorf("sensor %q not found: %w", name, err)
+        }
+        sensors[name] = s
+    }
+
+    monitorCtx, cancelFn := context.WithCancel(context.Background())
+    svc := &TempAlert{
+        Named:    conf.ResourceName().AsNamed(),
+        logger:   logger,
+        cfg:      cfg,
+        sensors:  sensors,
+        alerts:   []Alert{},
+        cancelFn: cancelFn,
+    }
+
+    // Start background monitor loop
+    go svc.monitorLoop(monitorCtx)
+
+    return svc, nil
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 4. Implement the background loop
+
+The monitor loop polls sensors at a fixed interval and checks readings against
+thresholds. When a reading exceeds the threshold, it creates an alert.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+    async def _monitor_loop(self):
+        while not self._stop_event.is_set():
+            for name, s in self.sensors.items():
+                try:
+                    # 3. Use: call methods on dependencies
+                    readings = await s.get_readings()
+                    temp = readings.get("temperature")
+                    if temp is not None and temp > self.max_temp:
+                        alert = {
+                            "sensor": name,
+                            "value": temp,
+                            "threshold": self.max_temp,
+                            "time": datetime.now().isoformat(),
+                        }
+                        self.alerts.append(alert)
+                        self.logger.warning(
+                            "Alert: %s reported %.1f (threshold: %.1f)",
+                            name, temp, self.max_temp,
+                        )
+                except Exception as e:
+                    self.logger.error("Failed to read %s: %s", name, e)
+
+            try:
+                await asyncio.wait_for(
+                    self._stop_event.wait(),
+                    timeout=self.poll_interval,
+                )
+                break  # Stop event was set
+            except asyncio.TimeoutError:
+                pass  # Continue polling
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+func (s *TempAlert) monitorLoop(ctx context.Context) {
+    interval := time.Duration(s.cfg.PollInterval) * time.Second
+    if interval == 0 {
+        interval = 10 * time.Second
+    }
+
+    ticker := time.NewTicker(interval)
+    defer ticker.Stop()
+
+    for {
+        select {
+        case <-ctx.Done():
+            return
+        case <-ticker.C:
+            s.checkSensors(ctx)
+        }
+    }
+}
+
+func (s *TempAlert) checkSensors(ctx context.Context) {
+    s.mu.Lock()
+    defer s.mu.Unlock()
+
+    for name, sens := range s.sensors {
+        // 3. Use: call methods on dependencies
+        readings, err := sens.Readings(ctx, nil)
+        if err != nil {
+            s.logger.CErrorw(ctx, "failed to read sensor", "sensor", name, "error", err)
+            continue
+        }
+        temp, ok := readings["temperature"].(float64)
+        if !ok {
+            continue
+        }
+        if temp > s.cfg.MaxTemp {
+            alert := Alert{
+                Sensor:    name,
+                Value:     temp,
+                Threshold: s.cfg.MaxTemp,
+                Time:      time.Now().Format(time.RFC3339),
+            }
+            s.alerts = append(s.alerts, alert)
+            s.logger.CWarnw(ctx, "alert triggered",
+                "sensor", name, "value", temp, "threshold", s.cfg.MaxTemp)
+        }
+    }
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 5. Implement DoCommand
+
+`DoCommand` is the interface your application code uses to interact with the
+service. Define a command vocabulary that makes sense for your module.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+    async def do_command(
+        self,
+        command: Mapping[str, ValueTypes],
+        *,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Mapping[str, ValueTypes]:
+        cmd = command.get("command", "")
+
+        if cmd == "get_alerts":
+            return {"alerts": self.alerts}
+
+        if cmd == "get_alert_count":
+            return {"count": len(self.alerts)}
+
+        if cmd == "acknowledge":
+            self.alerts.clear()
+            return {"status": "ok"}
+
+        if cmd == "set_threshold":
+            self.max_temp = command["max_temp"]
+            return {"status": "ok", "max_temp": self.max_temp}
+
+        raise Exception(f"Unknown command: {cmd}")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+func (s *TempAlert) DoCommand(
+    ctx context.Context,
+    cmd map[string]interface{},
+) (map[string]interface{}, error) {
+    command, _ := cmd["command"].(string)
+
+    switch command {
+    case "get_alerts":
+        s.mu.Lock()
+        defer s.mu.Unlock()
+        // Convert alerts to interface slice for serialization
+        alertList := make([]interface{}, len(s.alerts))
+        for i, a := range s.alerts {
+            alertList[i] = map[string]interface{}{
+                "sensor":    a.Sensor,
+                "value":     a.Value,
+                "threshold": a.Threshold,
+                "time":      a.Time,
+            }
+        }
+        return map[string]interface{}{"alerts": alertList}, nil
+
+    case "get_alert_count":
+        s.mu.Lock()
+        defer s.mu.Unlock()
+        return map[string]interface{}{"count": len(s.alerts)}, nil
+
+    case "acknowledge":
+        s.mu.Lock()
+        defer s.mu.Unlock()
+        s.alerts = s.alerts[:0]
+        return map[string]interface{}{"status": "ok"}, nil
+
+    case "set_threshold":
+        newMax, ok := cmd["max_temp"].(float64)
+        if !ok {
+            return nil, fmt.Errorf("max_temp must be a number")
+        }
+        s.mu.Lock()
+        s.cfg.MaxTemp = newMax
+        s.mu.Unlock()
+        return map[string]interface{}{"status": "ok", "max_temp": newMax}, nil
+
+    default:
+        return nil, fmt.Errorf("unknown command: %s", command)
+    }
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 6. Handle shutdown
+
+When `viam-server` stops the module or reconfigures it, your background loop
+must stop cleanly. Without this, goroutines or async tasks leak.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+    async def close(self):
+        self._stop_event.set()
+        if self._monitor_task is not None:
+            await self._monitor_task
+            self._monitor_task = None
+        self.logger.info("TempAlert monitor stopped")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+func (s *TempAlert) Close(ctx context.Context) error {
+    s.cancelFn()
+    s.logger.CInfof(ctx, "TempAlert monitor stopped")
+    return nil
+}
+```
+
+In Go, the `Reconfigure` method should also stop the old loop and start a new
+one:
+
+```go
+func (s *TempAlert) Reconfigure(
+    ctx context.Context,
+    deps resource.Dependencies,
+    conf resource.Config,
+) error {
+    // Stop the old loop
+    s.cancelFn()
+
+    cfg, err := resource.NativeConfig[*Config](conf)
+    if err != nil {
+        return err
+    }
+
+    sensors := make(map[string]sensor.Sensor)
+    for _, name := range cfg.SensorNames {
+        sens, err := sensor.FromProvider(deps, name)
+        if err != nil {
+            return fmt.Errorf("sensor %q not found: %w", name, err)
+        }
+        sensors[name] = sens
+    }
+
+    monitorCtx, cancelFn := context.WithCancel(context.Background())
+
+    s.mu.Lock()
+    s.cfg = cfg
+    s.sensors = sensors
+    s.cancelFn = cancelFn
+    s.mu.Unlock()
+
+    go s.monitorLoop(monitorCtx)
+    return nil
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 7. Test locally
+
+**Deploy with hot reloading:**
+
+Ensure you have at least one sensor configured on your machine (this is the resource your logic module will monitor).
+
+Use the CLI to build and deploy your module:
+
+```bash
+# Build in the cloud and deploy to the machine
+viam module reload --part-id <machine-part-id>
+```
+
+If your development machine and target machine share the same architecture, you can build locally instead:
+
+```bash
+# Build locally and transfer to the machine
+viam module reload-local --part-id <machine-part-id>
+```
+
+Use `reload` (cloud build) when developing on a different architecture than your target. Use `reload-local` when architectures match for faster iteration.
+
+After deploying, configure the service's attributes in the Viam app:
+
+```json
+{
+  "sensor_names": ["my-temp-sensor"],
+  "max_temp": 30.0,
+  "poll_interval_secs": 5
+}
+```
+
+Click **Save**.
+
+**Test with DoCommand:**
+
+On the **CONFIGURE** tab, expand your service's **Test** section and then expand **DoCommand**. Send a command:
+
+```json
+{ "command": "get_alerts" }
+```
+
+You should see a response with any alerts that have been triggered.
+
+**Get a ready-to-run code sample:**
+
+The **CONNECT** tab on your machine's page in the Viam app provides generated
+code samples in Python and Go that connect to your machine and access all
+configured resources. Use this as a starting point for application code that
+sends `DoCommand` requests to your service.
+
+**Rebuild and redeploy during development:**
+
+Each time you make changes, run `viam module reload` (or `reload-local`) again. Use `viam module restart` to restart without rebuilding (for example, after editing Python source).
+
+**Test the alert flow:**
+
+1. Verify your sensor is returning temperature readings on the TEST card.
+2. Set `max_temp` to a value below the current temperature so alerts trigger.
+3. Wait for one poll interval, then send `{"command": "get_alerts"}`.
+4. You should see alerts in the response.
+5. Send `{"command": "acknowledge"}` to clear them.
+
+### 8. Schedule logic with jobs (optional)
+
+Instead of running a continuous background loop, you can use
+{{< glossary_tooltip term_id="job" text="jobs" >}} to have `viam-server` call
+your service's `DoCommand` method on a schedule. This is useful for periodic
+tasks that don't need sub-second polling.
+
+1. In the [Viam app](https://app.viam.com), click the **+** icon next to your
+   machine part and select **Job**.
+2. Name the job and click **Create**.
+3. Set the **Schedule** to one of:
+   - **Interval** -- a Go duration string like `5s`, `1m`, or `2h30m`.
+   - **Cron** -- a 5- or 6-part cron expression (for example, `0 */5 * * *`).
+4. Select your service resource by name.
+5. Select the `DoCommand` **Method** and specify the **Command**, for example:
+
+   ```json
+   { "command": "get_alerts" }
+   ```
+
+6. Click **Save**.
+
+`viam-server` calls `DoCommand` with the specified arguments on the configured
+schedule. You can view job history (last 10 successes and failures) in the
+machine's configuration.
+
+Jobs also support calling other gRPC methods on resources (such as
+`GetReadings` on a sensor), but only `DoCommand` accepts command arguments.
+
+## Try It
+
+1. Generate a generic service module using `viam module generate`.
+2. Define config attributes for monitored sensors and thresholds.
+3. Implement the constructor to resolve sensor dependencies and start the
+   monitor loop.
+4. Implement `DoCommand` with `get_alerts`, `acknowledge`, and `set_threshold`
+   commands.
+5. Configure the module on your machine with a real sensor.
+6. Lower the threshold below the current temperature and verify alerts appear.
+
+## Troubleshooting
+
+{{< expand "Background loop not running" >}}
+
+- Check the **LOGS** tab for errors from the monitor loop. A failing sensor
+  read can cause the loop to exit silently.
+- Verify the `poll_interval_secs` is greater than 0.
+- In Python, ensure you are creating an `asyncio.Task` (not just calling the
+  async function without `await` or `create_task`).
+- In Go, ensure the goroutine context is not prematurely canceled. Use
+  `context.Background()` for the loop context, not the request context.
+
+{{< /expand >}}
+
+{{< expand "DoCommand returning unexpected results" >}}
+
+- Verify the `command` field in your request matches the command names in your
+  implementation exactly (case-sensitive).
+- Check that value types match. JSON numbers are `float64` in Go and `float`
+  in Python. If you send `"max_temp": 30`, Go receives it as `float64(30)`.
+- Add logging inside `DoCommand` to see the raw command map.
+
+{{< /expand >}}
+
+{{< expand "Sensor dependency not available" >}}
+
+- Confirm the sensor names in `sensor_names` match the names of sensors
+  configured on the machine exactly.
+- Verify the sensors are configured and working before the logic module starts.
+  Check the **CONTROL** tab to confirm each sensor returns readings.
+- If a sensor is added after the logic module is already running, reconfigure
+  the logic module (re-save its config) so `viam-server` re-resolves
+  dependencies.
+
+{{< /expand >}}
+
+{{< expand "Alerts not appearing" >}}
+
+- Check that your sensor's readings map includes a `"temperature"` key. The
+  monitor loop checks for this specific key.
+- Verify `max_temp` is set below the actual temperature so alerts trigger.
+- Check the **LOGS** tab for warning messages from the monitor loop.
+
+{{< /expand >}}
+
+## What's Next
+
+- [Write a Driver Module](/build-modules/write-a-driver-module/) -- write a module
+  that wraps custom hardware.
+- [Deploy a Module](/build-modules/deploy-a-module/) -- package and upload your
+  module to the Viam registry.
+- [Module Reference](/build-modules/module-reference/) -- complete reference
+  for meta.json, CLI commands, environment variables, and resource interfaces.
diff --git a/docs/build-modules/write-an-inline-module.md b/docs/build-modules/write-an-inline-module.md
new file mode 100644
index 0000000000..2a686696b5
--- /dev/null
+++ b/docs/build-modules/write-an-inline-module.md
@@ -0,0 +1,532 @@
+---
+linkTitle: "Write an inline module"
+title: "Write an inline module"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Write and deploy a custom module directly in the browser using Viam's inline module editor."
+date: "2025-01-30"
+aliases:
+  - /build/development/write-an-inline-module/
+  - /development/write-an-inline-module/
+---
+
+Viam provides built-in support for many types of hardware and software, but you
+may want to use hardware that Viam doesn't support out of the box, or add
+application-specific logic. Modules let you add that support yourself.
+
+An inline module is the fastest way to get started. You write your module code
+directly in the Viam app's browser-based editor -- no IDE, terminal, or GitHub
+account required. When you click **Save & Deploy**, Viam builds your module in
+the cloud and deploys it to your machine automatically.
+
+{{< alert title="Availability" color="tip" >}}
+Inline modules are currently available to organizations that have the feature
+enabled. If you do not see the **Viam-hosted** option when adding code, contact
+Viam support to request access.
+{{< /alert >}}
+
+For background on inline modules, how they compare to externally managed
+modules, and the Generic service API, see the
+[overview](/build-modules/overview/#inline-and-externally-managed-modules).
+
+## Steps
+
+### 1. Create the module
+
+1. In the [Viam app](https://app.viam.com), navigate to your machine's
+   **CONFIGURE** tab.
+2. Click **+** and select **Control code**.
+3. In the "Choose where to host your code" dialog, select **Viam-hosted** and
+   click **Choose**.
+4. Name your module (for example, `servo-distance-control`) and choose a language
+   (**Python** or **Go**).
+5. Click **Create module**.
+
+The browser opens the code editor with a working template that includes all
+necessary imports and method stubs.
+
+### 2. Understand the template
+
+The editor opens a single file -- your module's main source file. The template
+includes three methods you need to fill in:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+The editable file is `src/models/generic_service.py`. It contains a class that
+extends `GenericService` and `EasyResource`:
+
+```python
+class MyGenericService(GenericService, EasyResource):
+    MODEL: ClassVar[Model] = Model(
+        ModelFamily("my-org", "my-module"), "generic-service"
+    )
+```
+
+The three methods to implement:
+
+- **`validate_config`** -- check that configuration attributes are valid and
+  declare dependencies.
+- **`new`** -- initialize your service with attributes and dependencies.
+- **`do_command`** -- your control logic.
+
+{{< alert title="Important" color="caution" >}}
+Do not change the class name or the `MODEL` triplet. Viam uses these
+auto-generated values to identify your module. Changing them will break your
+inline module.
+{{< /alert >}}
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+The editable file is `module.go`. It contains a struct, a config type, and
+registration logic:
+
+```go
+var GenericService = resource.NewModel(
+    "my-org", "my-module", "generic-service",
+)
+
+func init() {
+    resource.RegisterService(genericservice.API, GenericService,
+        resource.Registration[resource.Resource, *Config]{
+            Constructor: newGenericService,
+        },
+    )
+}
+```
+
+The three areas to implement:
+
+- **`Validate`** on the `Config` struct -- check attributes, return
+  dependencies.
+- **`NewGenericService`** -- initialize the service with attributes and
+  dependencies.
+- **`DoCommand`** -- your control logic.
+
+{{< alert title="Important" color="caution" >}}
+Do not change the model name triplet, struct names, or public function names.
+Viam uses these auto-generated values to identify your module. Changing them
+will break your inline module.
+{{< /alert >}}
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 3. Implement validate_config
+
+The validate method runs every time the machine configuration changes. It checks
+that the attributes passed to your service are valid and declares dependencies
+on other components or services.
+
+This example validates attributes for a distance-responsive servo controller --
+a service that reads an ultrasonic sensor and adjusts a servo angle based on
+distance:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+@classmethod
+def validate_config(
+    cls, config: ComponentConfig
+) -> Tuple[Sequence[str], Sequence[str]]:
+    attrs = struct_to_dict(config.attributes)
+
+    # Required numeric attributes
+    sensor_range_start = attrs.get("sensor_range_start")
+    if sensor_range_start is None or not isinstance(
+        sensor_range_start, (int, float)
+    ):
+        raise ValueError(
+            "attribute 'sensor_range_start' is required "
+            "and must be an int or float value"
+        )
+
+    sensor_range_end = attrs.get("sensor_range_end")
+    if sensor_range_end is None or not isinstance(
+        sensor_range_end, (int, float)
+    ):
+        raise ValueError(
+            "attribute 'sensor_range_end' is required "
+            "and must be an int or float value"
+        )
+
+    # Required dependency attributes
+    required_deps: List[str] = []
+
+    servo_name = attrs.get("servo")
+    if not isinstance(servo_name, str) or not servo_name:
+        raise ValueError(
+            "attribute 'servo' (non-empty string) is required"
+        )
+    required_deps.append(servo_name)
+
+    sensor_name = attrs.get("sensor")
+    if not isinstance(sensor_name, str) or not sensor_name:
+        raise ValueError(
+            "attribute 'sensor' (non-empty string) is required"
+        )
+    required_deps.append(sensor_name)
+
+    return required_deps, []
+```
+
+The return value is a tuple of two lists:
+
+1. **Required dependencies** -- component or service names that must exist and
+   be ready before your service starts.
+2. **Optional dependencies** -- names your service can use if available but
+   does not require.
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+type Config struct {
+    SensorRangeStart float64 `json:"sensor_range_start"`
+    SensorRangeEnd   float64 `json:"sensor_range_end"`
+    ServoAngleMin    *int64  `json:"servo_angle_min"`
+    ServoAngleMax    *int64  `json:"servo_angle_max"`
+    Reversed         *bool   `json:"reversed"`
+    Servo            string  `json:"servo"`
+    Sensor           string  `json:"sensor"`
+}
+
+func (cfg *Config) Validate(path string) ([]string, []string, error) {
+    if cfg.SensorRangeStart == 0 {
+        return nil, nil, fmt.Errorf(
+            "%s: 'sensor_range_start' is required and must be non-zero",
+            path,
+        )
+    }
+    if cfg.SensorRangeEnd == 0 {
+        return nil, nil, fmt.Errorf(
+            "%s: 'sensor_range_end' is required and must be non-zero",
+            path,
+        )
+    }
+
+    requiredDeps := []string{}
+    if cfg.Servo == "" {
+        return nil, nil, fmt.Errorf(
+            "%s: 'servo' (non-empty string) is required", path,
+        )
+    }
+    requiredDeps = append(requiredDeps, cfg.Servo)
+
+    if cfg.Sensor == "" {
+        return nil, nil, fmt.Errorf(
+            "%s: 'sensor' (non-empty string) is required", path,
+        )
+    }
+    requiredDeps = append(requiredDeps, cfg.Sensor)
+
+    return requiredDeps, []string{}, nil
+}
+```
+
+The `Validate` method returns two slices (required dependencies and optional
+dependencies) and an error.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 4. Implement the constructor
+
+The constructor runs when the service is first created and again whenever its
+configuration changes. Use it to parse attributes and resolve dependencies.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+@classmethod
+def new(
+    cls, config: ComponentConfig,
+    dependencies: Mapping[ResourceName, ResourceBase]
+) -> Self:
+    self = await super().new(config, dependencies)
+    attrs = struct_to_dict(config.attributes)
+
+    # Required attributes
+    self.sensor_range_start = float(attrs.get("sensor_range_start"))
+    self.sensor_range_end = float(attrs.get("sensor_range_end"))
+
+    # Optional attributes with defaults
+    self.servo_angle_min = float(attrs.get("servo_angle_min", 0))
+    self.servo_angle_max = float(attrs.get("servo_angle_max", 180))
+    self.reversed = attrs.get("reversed", False)
+
+    # Resolve dependencies
+    servo_name = attrs.get("servo")
+    sensor_name = attrs.get("sensor")
+    self.servo = dependencies[Servo.get_resource_name(servo_name)]
+    self.sensor = dependencies[Sensor.get_resource_name(sensor_name)]
+
+    return self
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+func NewGenericService(
+    ctx context.Context, deps resource.Dependencies,
+    name resource.Name, conf *Config, logger logging.Logger,
+) (resource.Resource, error) {
+    cancelCtx, cancelFunc := context.WithCancel(context.Background())
+
+    // Apply defaults for optional fields
+    servoAngleMin := int64(0)
+    if conf.ServoAngleMin != nil {
+        servoAngleMin = *conf.ServoAngleMin
+    }
+    servoAngleMax := int64(180)
+    if conf.ServoAngleMax != nil {
+        servoAngleMax = *conf.ServoAngleMax
+    }
+    reversed := false
+    if conf.Reversed != nil {
+        reversed = *conf.Reversed
+    }
+
+    // Resolve dependencies
+    servoDep, err := servo.FromProvider(deps, conf.Servo)
+    if err != nil {
+        return nil, err
+    }
+    sensorDep, err := sensor.FromProvider(deps, conf.Sensor)
+    if err != nil {
+        return nil, err
+    }
+
+    return &genericService{
+        name:             name,
+        logger:           logger,
+        cfg:              conf,
+        cancelCtx:        cancelCtx,
+        cancelFunc:       cancelFunc,
+        servo:            servoDep,
+        sensor:           sensorDep,
+        sensorRangeStart: conf.SensorRangeStart,
+        sensorRangeEnd:   conf.SensorRangeEnd,
+        servoAngleMin:    servoAngleMin,
+        servoAngleMax:    servoAngleMax,
+        reversed:         reversed,
+    }, nil
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 5. Implement DoCommand
+
+`DoCommand` is where your control logic goes. This example reads a distance
+sensor and maps the reading to a servo angle:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+async def do_command(
+    self, command: Mapping[str, ValueTypes], *,
+    timeout: Optional[float] = None, **kwargs
+) -> Mapping[str, ValueTypes]:
+    readings = await self.sensor.get_readings()
+    if not readings:
+        raise ValueError("No sensor readings available")
+
+    value = next(iter(readings.values()))
+
+    # Map sensor range to servo angle range
+    t = (value - self.sensor_range_start) / (
+        self.sensor_range_end - self.sensor_range_start
+    )
+    t = max(0.0, min(1.0, 1.0 - t if self.reversed else t))
+
+    angle = self.servo_angle_min + t * (
+        self.servo_angle_max - self.servo_angle_min
+    )
+    await self.servo.move(int(angle))
+
+    return {"servo_angle_deg": angle}
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+func (s *genericService) DoCommand(
+    ctx context.Context, cmd map[string]interface{},
+) (map[string]interface{}, error) {
+    readings, _ := s.sensor.Readings(ctx, nil)
+    value, ok := readings["distance"].(float64)
+    if !ok {
+        return nil, fmt.Errorf("sensor reading 'distance' must be a float64")
+    }
+
+    // Map sensor range to servo angle range
+    t := (value - s.sensorRangeStart) /
+        (s.sensorRangeEnd - s.sensorRangeStart)
+    if t < 0 { t = 0 } else if t > 1 { t = 1 }
+    if s.reversed { t = 1 - t }
+
+    angle := float64(s.servoAngleMin) +
+        t * (float64(s.servoAngleMax) - float64(s.servoAngleMin))
+    return map[string]interface{}{
+        "servo_angle_deg": angle,
+    }, s.servo.Move(ctx, uint32(angle), nil)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+In this example no DoCommand payload is used. You can use the command payload to
+customize behavior per invocation. Attributes are constant across all
+invocations; the DoCommand payload can vary with each call.
+
+### 6. Save and deploy
+
+1. Click **Save & Deploy** in the code editor toolbar.
+2. Viam uploads your code as a new version and starts a cloud build.
+3. Builds typically take 2-5 minutes. You can continue editing while a build
+   runs -- your next save creates a new version.
+4. If the build fails, click **View Logs** to see what went wrong.
+
+Each save creates a new version in your module's history. You can switch between
+versions using the version dropdown in the editor toolbar.
+
+### 7. Test on a machine
+
+#### Add the module to a machine
+
+1. In the code editor, click **Add to machine**.
+2. Select a location, machine, and part.
+3. Click **Add**.
+
+The Viam app navigates you to the machine's **CONFIGURE** tab with your module
+added.
+
+#### Configure the service
+
+1. In the module section, click **Add** to add a model of your generic service.
+2. Click **+** to add each dependency your service requires (for example, a servo and
+   a sensor). Configure each dependency with the appropriate attributes.
+3. Configure the attributes for your generic service:
+
+```json
+{
+  "sensor_range_start": 0.05,
+  "sensor_range_end": 0.3,
+  "servo_angle_min": 40,
+  "servo_angle_max": 270,
+  "reversed": true,
+  "servo": "servo-1",
+  "sensor": "sensor-1"
+}
+```
+
+4. Click **Save**.
+
+#### Send test commands
+
+1. On the **CONFIGURE** tab, expand your generic service's **Test** section.
+2. Expand **DoCommand**.
+3. Enter a command (or an empty map `{}` if your DoCommand does not use the
+   payload):
+
+```json
+{}
+```
+
+4. Click **Execute**. You should see a response like:
+
+```json
+{ "servo_angle_deg": 155.0 }
+```
+
+### 8. Automate with a scheduled job
+
+The DoCommand section in the Viam app runs your logic once per click. To have
+it run automatically:
+
+1. Click **+** and select **Job**.
+2. Name the job and click **Create**.
+3. Choose a schedule. For control logic that should always run, select
+   **Continuous**.
+4. Select your generic service as the resource.
+5. Edit the DoCommand payload or leave it as an empty map if no payload is
+   needed.
+6. Click **Save**.
+
+## Try It
+
+1. Create a new inline module from the **+** menu.
+2. Implement `validate_config`, the constructor, and `do_command`.
+3. Click **Save & Deploy** and wait for the build to complete.
+4. Add the module to a machine and configure the service with dependencies.
+5. Execute a DoCommand and verify the response.
+6. Set up a scheduled job to run the logic continuously.
+
+## Troubleshooting
+
+{{< expand "\"Viam-hosted\" option not visible" >}}
+
+The inline module feature is gated by a feature flag. If you do not see the
+"Viam-hosted" option when clicking **+** → **Control code**, your organization
+may not have the feature enabled. Contact Viam support to request access.
+
+{{< /expand >}}
+
+{{< expand "Build fails after saving" >}}
+
+- Click **View Logs** in the build progress bar to see the error.
+- Common causes: syntax errors, missing imports, incompatible dependencies.
+- You can fix the code and save again -- each save creates a new version.
+
+{{< /expand >}}
+
+{{< expand "Module not appearing on machine" >}}
+
+- Verify the machine is online and connected to the cloud.
+- Check that you added the module using the **Add to machine** button in the
+  code editor, or that the module appears in the machine's configuration.
+- The module version defaults to `latest`. After a successful build, the machine
+  picks up the new version automatically within a few minutes.
+
+{{< /expand >}}
+
+{{< expand "DoCommand returns an error" >}}
+
+- Check that all dependencies are configured on the machine and are working.
+  Use the test section of each dependency to verify them in isolation.
+- Verify the attribute names in your service configuration match what
+  `validate_config` expects.
+- Check the **LOGS** tab for detailed error messages.
+
+{{< /expand >}}
+
+{{< expand "Changes to code not taking effect" >}}
+
+- Make sure the build completed successfully. Check the build progress bar in
+  the code editor.
+- The machine must be online to receive the updated module. Check the machine's
+  status in the Viam app.
+- By default, modules are configured with version `latest`, which means every
+  new build deploys automatically. If the version is pinned, update it manually.
+
+{{< /expand >}}
+
+## What's Next
+
+- [Write a Driver Module](/build-modules/write-a-driver-module/) -- build a module
+  with a typed resource API when you need to manage your own source code and
+  build pipeline.
+- [Write a Logic Module](/build-modules/write-a-logic-module/) -- build control
+  logic as an externally managed module with full IDE support.
+- [Deploy a Module](/build-modules/deploy-a-module/) -- package and upload
+  a module to the Viam registry for distribution to other machines or users.
diff --git a/docs/cli/_index.md b/docs/cli/_index.md
new file mode 100644
index 0000000000..3db90682ab
--- /dev/null
+++ b/docs/cli/_index.md
@@ -0,0 +1,12 @@
+---
+linkTitle: "Viam CLI"
+title: "Viam CLI"
+weight: 37
+layout: "docs"
+type: "docs"
+no_list: true
+manualLink: "/cli/overview/"
+description: "The Viam CLI gives you command-line access to every operation in the Viam platform, from machine configuration to data export to fleet management."
+aliases:
+  - /dev/tools/cli/
+---
diff --git a/docs/cli/administer-your-organization.md b/docs/cli/administer-your-organization.md
new file mode 100644
index 0000000000..b65773e1ee
--- /dev/null
+++ b/docs/cli/administer-your-organization.md
@@ -0,0 +1,201 @@
+---
+linkTitle: "Administer your organization"
+title: "Administer your organization with the CLI"
+weight: 70
+layout: "docs"
+type: "docs"
+description: "Manage API keys, OAuth, billing, and organization settings from the command line."
+---
+
+Create and manage API keys, configure OAuth authentication for end users, and set up white-label billing for your organization.
+
+{{< expand "Prerequisites" >}}
+You need the Viam CLI installed and authenticated.
+See [Viam CLI overview](/cli/overview/) for installation and authentication instructions.
+{{< /expand >}}
+
+## Find your IDs
+
+To find your organization ID:
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations list
+```
+
+To find location IDs:
+
+```sh {class="command-line" data-prompt="$"}
+viam locations list
+```
+
+To find machine IDs:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines list --organization=<org-id> --all
+```
+
+## Manage locations
+
+List all locations in your organization:
+
+```sh {class="command-line" data-prompt="$"}
+viam locations list
+```
+
+If you belong to multiple organizations, specify which one:
+
+```sh {class="command-line" data-prompt="$"}
+viam locations list --organization=<org-id>
+```
+
+If you have set a default organization with `viam defaults set-org`, the CLI uses it automatically.
+
+## Manage API keys
+
+### Organization API key
+
+Create an API key with organization-level access.
+Organization keys have the `organization_owner` role with full read and write access to every resource in the organization.
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations api-key create --org-id=<org-id> --name=my-org-key
+```
+
+The CLI prints the key ID and key value. Save both immediately; the key value is only shown once.
+
+```sh {class="command-line" data-prompt="$" data-output="1-3"}
+Successfully created key:
+Key ID: abcdef12-3456-7890-abcd-ef1234567890
+Key Value: your-secret-key-value
+```
+
+### Location API key
+
+Create an API key scoped to a specific location.
+Location keys have the `location_owner` role.
+
+```sh {class="command-line" data-prompt="$"}
+viam locations api-key create --location-id=<location-id> --name=my-location-key
+```
+
+### Machine API key
+
+Create an API key scoped to a single machine.
+Machine keys have the `robot_owner` role.
+
+```sh {class="command-line" data-prompt="$"}
+viam machines api-key create --machine-id=<machine-id>
+```
+
+## Set up OAuth
+
+OAuth setup is CLI-only. There is no web UI for these operations.
+
+### Enable the auth service
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations auth-service enable --org-id=<org-id>
+```
+
+### Set branding
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations logo set --org-id=<org-id> --logo-path=./logo.png
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations support-email set --org-id=<org-id> --support-email=support@example.com
+```
+
+### Create an OAuth application
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations auth-service oauth-app create \
+  --org-id=<org-id> \
+  --client-name=my-app \
+  --client-authentication=unspecified \
+  --url-validation=exact_match \
+  --pkce=required \
+  --enabled-grants=authorization_code \
+  --redirect-uris=https://example.com/callback \
+  --logout-uri=https://example.com/logout \
+  --origin-uris=https://example.com
+```
+
+On success, the CLI prints the client ID and client secret.
+Save both values immediately; you need the client ID for subsequent commands.
+
+### Manage OAuth applications
+
+List all OAuth applications:
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations auth-service oauth-app list --org-id=<org-id>
+```
+
+Get details on a specific application:
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations auth-service oauth-app read \
+  --org-id=<org-id> \
+  --client-id=<client-id>
+```
+
+Update an application:
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations auth-service oauth-app update \
+  --org-id=<org-id> \
+  --client-id=<client-id> \
+  --client-name=updated-name
+```
+
+Delete an application:
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations auth-service oauth-app delete \
+  --org-id=<org-id> \
+  --client-id=<client-id>
+```
+
+### Disable the auth service
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations auth-service disable --org-id=<org-id>
+```
+
+## Configure white-label billing
+
+Billing service setup is CLI-only.
+
+Enable billing.
+The address format is `"line1, line2 (optional), city, state, zipcode"`:
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations billing-service enable --org-id=<org-id> --address="123 Main St, Springfield, IL, 62704"
+```
+
+Get billing configuration:
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations billing-service get-config --org-id=<org-id>
+```
+
+Update billing:
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations billing-service update --org-id=<org-id> --address=<billing-address>
+```
+
+Disable billing:
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations billing-service disable --org-id=<org-id>
+```
+
+## Related pages
+
+- [Manage access](/organization/access/) for role-based access control in the Viam app
+- [Authenticate end users with OAuth](/organization/oauth/) for OAuth setup details
+- [White-labeled billing](/organization/billing/) for billing fragment configuration
+- [CLI reference](/cli/) for the complete `organizations` command reference
diff --git a/docs/cli/automate-with-scripts.md b/docs/cli/automate-with-scripts.md
new file mode 100644
index 0000000000..6f5a71e809
--- /dev/null
+++ b/docs/cli/automate-with-scripts.md
@@ -0,0 +1,211 @@
+---
+linkTitle: "Automate with scripts"
+title: "Automate with scripts"
+weight: 80
+layout: "docs"
+type: "docs"
+description: "Use the Viam CLI in shell scripts, CI/CD pipelines, and provisioning workflows."
+---
+
+Combine CLI commands into shell scripts, CI/CD pipelines, and provisioning workflows to automate common Viam operations.
+
+## Authenticate in scripts
+
+Interactive `viam login` opens a browser, which does not work in headless environments.
+Use API key authentication instead:
+
+```sh {class="command-line" data-prompt="$"}
+viam login api-key --key-id=$VIAM_API_KEY_ID --key=$VIAM_API_KEY
+```
+
+Store credentials in environment variables or your CI/CD system's secret manager, not in the script itself.
+To create an API key, see [Manage API keys](/cli/administer-your-organization/#manage-api-keys).
+
+### Use profiles for non-interactive auth
+
+If a script needs to operate across multiple organizations, set up profiles in advance:
+
+```sh {class="command-line" data-prompt="$"}
+viam profiles add --profile-name=production --key-id=$PROD_KEY_ID --key=$PROD_KEY
+viam profiles add --profile-name=staging --key-id=$STAGING_KEY_ID --key=$STAGING_KEY
+```
+
+Then use `--profile` on each command, or set `VIAM_CLI_PROFILE_NAME` to activate a profile for the entire script:
+
+```sh {class="command-line" data-prompt="$"}
+export VIAM_CLI_PROFILE_NAME=production
+viam machines list --all
+```
+
+## CI/CD: upload a module on release
+
+A GitHub Actions workflow that builds and uploads a module when you push a version tag:
+
+```yaml
+# .github/workflows/upload-module.yml
+name: Upload module
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  upload:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Viam CLI
+        run: |
+          sudo curl --compressed -o /usr/local/bin/viam \
+            https://storage.googleapis.com/packages.viam.com/apps/viam-cli/viam-cli-stable-linux-amd64
+          sudo chmod a+rx /usr/local/bin/viam
+
+      - name: Authenticate
+        run: viam login api-key --key-id=${{ secrets.VIAM_KEY_ID }} --key=${{ secrets.VIAM_KEY }}
+
+      - name: Build
+        run: viam module build local
+
+      - name: Upload
+        run: |
+          VERSION=${GITHUB_REF_NAME#v}
+          viam module upload --version=$VERSION --platform=linux/amd64 dist/archive.tar.gz
+```
+
+## CI/CD: retrain a model on new data
+
+A script that creates a fresh dataset from recent data and submits a training job.
+
+Set these environment variables before running:
+
+- `VIAM_KEY_ID` and `VIAM_KEY`: your API key credentials (see [Manage API keys](/cli/administer-your-organization/#manage-api-keys))
+- `ORG_ID`: your organization ID (run `viam organizations list`)
+
+```sh
+#!/bin/bash
+set -euo pipefail
+
+viam login api-key --key-id=$VIAM_KEY_ID --key=$VIAM_KEY
+
+# Create a dataset from the last 7 days of labeled images.
+# The create command prints: "Created dataset <name> with dataset ID: <uuid>"
+DATASET_ID=$(viam dataset create --org-id=$ORG_ID --name="weekly-$(date +%F)" \
+  | grep -oE '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
+
+# date -v is macOS; date -d is Linux. Adjust for your platform.
+START=$(date -u -v-7d +%FT%TZ 2>/dev/null || date -u -d '7 days ago' +%FT%TZ)
+END=$(date -u +%FT%TZ)
+
+viam dataset data add filter \
+  --dataset-id=$DATASET_ID \
+  --org-ids=$ORG_ID \
+  --tags=labeled \
+  --start=$START \
+  --end=$END
+
+# Submit a managed training job
+viam train submit managed \
+  --dataset-id=$DATASET_ID \
+  --model-org-id=$ORG_ID \
+  --model-name=defect-detector-$(date +%F) \
+  --model-type=object_detection \
+  --model-framework=tflite \
+  --model-labels=defective,good
+```
+
+Schedule this as a cron job or a weekly CI/CD trigger.
+
+## Batch fleet operations
+
+### List all machines
+
+Set `ORG_ID` to your organization ID (run `viam organizations list`).
+
+```sh
+#!/bin/bash
+set -euo pipefail
+
+viam login api-key --key-id=$VIAM_KEY_ID --key=$VIAM_KEY
+
+# List all machines across all locations
+viam machines list --organization=$ORG_ID --all
+```
+
+## Provisioning: create and configure a machine
+
+Script that creates a machine and applies a standard configuration fragment.
+
+Set these environment variables before running:
+
+- `VIAM_KEY_ID` and `VIAM_KEY`: your API key credentials
+- `ORG_ID`: your organization ID
+- `LOCATION_ID`: your location ID (run `viam locations list`)
+
+The script takes two arguments: the machine name and the fragment ID.
+
+```sh
+#!/bin/bash
+set -euo pipefail
+
+MACHINE_NAME=$1
+FRAGMENT_ID=$2
+
+viam login api-key --key-id=$VIAM_KEY_ID --key=$VIAM_KEY
+
+# Create the machine.
+# Output format: "created new machine with id <uuid>"
+CREATE_OUTPUT=$(viam machines create --name=$MACHINE_NAME --location=$LOCATION_ID)
+MACHINE_ID=$(echo "$CREATE_OUTPUT" | grep -oE '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
+
+# Get the part ID from the part list.
+# Output includes lines like "  ID: <uuid>"
+PART_ID=$(viam machines part list --machine=$MACHINE_ID | grep 'ID:' | head -1 | awk '{print $2}')
+
+# Apply the configuration fragment
+viam machines part fragments add --part=$PART_ID --fragment=$FRAGMENT_ID
+
+echo "Machine $MACHINE_NAME ($MACHINE_ID) created with fragment $FRAGMENT_ID applied."
+```
+
+## Bulk data export
+
+Export all images from a fleet for offline analysis.
+Set `ORG_ID` to your organization ID.
+
+```sh
+#!/bin/bash
+set -euo pipefail
+
+viam login api-key --key-id=$VIAM_KEY_ID --key=$VIAM_KEY
+
+# date -v is macOS; date -d is Linux. Adjust for your platform.
+START=$(date -u -v-30d +%FT%TZ 2>/dev/null || date -u -d '30 days ago' +%FT%TZ)
+END=$(date -u +%FT%TZ)
+
+viam data export binary filter \
+  --destination=./fleet-data \
+  --org-ids=$ORG_ID \
+  --mime-types=image/jpeg,image/png \
+  --start=$START \
+  --end=$END \
+  --parallel=20
+```
+
+The `--parallel` flag controls how many concurrent downloads run (default: 100).
+Increase it for faster exports on high-bandwidth connections, or decrease it to reduce load.
+
+## Tips for scripting
+
+- Use `--quiet` (`-q`) to suppress non-essential output when parsing command results
+- Use `--debug` (`-vvv`) when troubleshooting a script
+- Set defaults with `viam defaults set-org` to avoid passing `--org-id` on every command
+- All timestamps use ISO-8601 format: `2026-01-15T00:00:00Z`
+- Exit codes are non-zero on failure, so `set -e` works as expected
+
+## Related pages
+
+- [Viam CLI overview](/cli/overview/) for installation and authentication
+- [Provision devices](/fleet/provision-devices/) for provisioning with viam-agent
+- [Deploy a module](/build-modules/deploy-a-module/) for GitHub Actions integration
+- [CLI reference](/cli/) for the complete command reference
diff --git a/docs/cli/build-and-deploy-modules.md b/docs/cli/build-and-deploy-modules.md
new file mode 100644
index 0000000000..cfb02c62b1
--- /dev/null
+++ b/docs/cli/build-and-deploy-modules.md
@@ -0,0 +1,244 @@
+---
+linkTitle: "Build and deploy modules"
+title: "Build and deploy modules with the CLI"
+weight: 50
+layout: "docs"
+type: "docs"
+description: "Scaffold, build, upload, and version modules from the command line."
+---
+
+Scaffold a new module, iterate on it locally with hot-reload, upload it to the registry, and manage versions and cloud builds.
+
+{{< expand "Prerequisites" >}}
+You need the Viam CLI installed and authenticated.
+See [Viam CLI overview](/cli/overview/) for installation and authentication instructions.
+{{< /expand >}}
+
+## Find your IDs
+
+To find the part ID for a running machine (needed for reload and restart):
+
+```sh {class="command-line" data-prompt="$"}
+viam machines list --organization=<org-id> --location=<location-id>
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part list --machine=<machine-id>
+```
+
+To find your organization and location IDs:
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations list
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam locations list
+```
+
+## Scaffold a new module
+
+Generate a module project with boilerplate code, a `meta.json` manifest, and a build script.
+This command does not require authentication, so you can scaffold a module before logging in.
+
+```sh {class="command-line" data-prompt="$"}
+viam module generate
+```
+
+The generator walks you through an interactive prompt to choose:
+
+- Module name
+- Programming language (Python or Go)
+- Namespace and visibility
+- Resource type (component or service) and API
+
+You can also pass flags to skip the interactive prompts:
+
+```sh {class="command-line" data-prompt="$"}
+viam module generate \
+  --name=my-sensor-module \
+  --language=python \
+  --visibility=public
+```
+
+## Iterate during development
+
+After making code changes, reload your module on a running machine without restarting the entire machine:
+
+```sh {class="command-line" data-prompt="$"}
+viam module reload-local --part-id=<part-id>
+```
+
+To reload a module from the registry (after uploading a new version):
+
+```sh {class="command-line" data-prompt="$"}
+viam module reload --part-id=<part-id>
+```
+
+If a reload is not sufficient, restart the module process:
+
+```sh {class="command-line" data-prompt="$"}
+viam module restart --part-id=<part-id>
+```
+
+## Update model definitions
+
+After adding or changing models in your module, update the model definitions in `meta.json`.
+This command runs the module binary in a sandbox, queries it for the API-model pairs it advertises, and updates the manifest.
+It also auto-detects markdown documentation files named `namespace_module_model.md`.
+
+```sh {class="command-line" data-prompt="$"}
+viam module update-models --binary=./bin/module
+```
+
+Then push the updated `meta.json` to the registry:
+
+```sh {class="command-line" data-prompt="$"}
+viam module update
+```
+
+## Upload to the registry
+
+Upload a module version for a specific platform.
+The CLI validates the tarball before uploading: it checks for an executable at the declared entrypoint, verifies file permissions, and warns about platform mismatches or symlinks escaping the archive.
+Pass `--force` to skip validation.
+
+```sh {class="command-line" data-prompt="$"}
+viam module upload \
+  --version=1.0.0 \
+  --platform=linux/amd64 \
+  dist/archive.tar.gz
+```
+
+On success, the CLI prints a link to your module in the registry:
+
+```sh {class="command-line" data-prompt="$" data-output="1"}
+Version successfully uploaded! you can view your changes online here: https://app.viam.com/module/my-org/my-module
+```
+
+Upload for multiple platforms by running the command once per platform:
+
+```sh {class="command-line" data-prompt="$"}
+viam module upload --version=1.0.0 --platform=linux/amd64 dist/archive-amd64.tar.gz
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam module upload --version=1.0.0 --platform=linux/arm64 dist/archive-arm64.tar.gz
+```
+
+## Cloud builds
+
+For CI/CD workflows, use cloud builds to compile your module on Viam's build infrastructure.
+
+Start a cloud build:
+
+```sh {class="command-line" data-prompt="$"}
+viam module build start --version=1.0.0
+```
+
+Build for multiple platforms in one command:
+
+```sh {class="command-line" data-prompt="$"}
+viam module build start --version=1.0.0 --platforms=linux/amd64,linux/arm64
+```
+
+Build from a specific git ref:
+
+```sh {class="command-line" data-prompt="$"}
+viam module build start --version=1.0.0 --ref=main
+```
+
+Build locally to test before pushing:
+
+```sh {class="command-line" data-prompt="$"}
+viam module build local
+```
+
+List recent builds (the output includes build IDs you need for `build logs`):
+
+```sh {class="command-line" data-prompt="$"}
+viam module build list
+```
+
+View build logs:
+
+```sh {class="command-line" data-prompt="$"}
+viam module build logs --build-id=<build-id>
+```
+
+Wait for a build to complete and stream logs:
+
+```sh {class="command-line" data-prompt="$"}
+viam module build logs --build-id=<build-id> --wait
+```
+
+## Download a module
+
+Download a module from the registry for local testing or inspection.
+The `--id` flag takes the format `org-namespace:module-name`:
+
+```sh {class="command-line" data-prompt="$"}
+viam module download \
+  --id=my-org:my-sensor-module \
+  --version=1.0.0 \
+  --platform=linux/amd64 \
+  --destination=./downloaded-module
+```
+
+## Create a module
+
+If you need to register a module in the registry before uploading (for example, to reserve a name), use `create`:
+
+```sh {class="command-line" data-prompt="$"}
+viam module create --name=my-new-module
+```
+
+Most users should use `viam module generate` instead, which handles both creation and scaffolding.
+
+## Convert xacro files to URDF
+
+If your module works with a robot described in [xacro](https://wiki.ros.org/xacro) format (the ROS XML macro language), convert it to URDF with the CLI.
+The conversion runs in a Docker container with the specified ROS distribution.
+
+```sh {class="command-line" data-prompt="$"}
+viam xacro convert \
+  --input-file=./robot.xacro \
+  --output-file=./robot.urdf
+```
+
+If the xacro file uses `<xacro:arg>` tags, pass the required arguments:
+
+```sh {class="command-line" data-prompt="$"}
+viam xacro convert \
+  --input-file=./robot.xacro \
+  --output-file=./robot.urdf \
+  --args name:=ur20
+```
+
+To collapse fixed joint chains (useful when the URDF must have a single end-effector):
+
+```sh {class="command-line" data-prompt="$"}
+viam xacro convert \
+  --input-file=./robot.xacro \
+  --output-file=./robot.urdf \
+  --collapse-fixed-joints
+```
+
+By default, the conversion uses the `osrf/ros:humble-desktop` Docker image.
+To use a different ROS distribution or a custom image:
+
+```sh {class="command-line" data-prompt="$"}
+viam xacro convert \
+  --input-file=./robot.xacro \
+  --output-file=./robot.urdf \
+  --docker-image=osrf/ros:jazzy-desktop
+```
+
+Use `--dry-run` to print the Docker command without running it.
+
+## Related pages
+
+- [Write a driver module](/build-modules/write-a-driver-module/) for a complete guide to writing a hardware driver
+- [Write a logic module](/build-modules/write-a-logic-module/) for writing automation and monitoring logic
+- [Deploy a module](/build-modules/deploy-a-module/) for deployment with GitHub Actions
+- [CLI reference](/cli/) for the complete `module` command reference
diff --git a/docs/cli/configure-machines.md b/docs/cli/configure-machines.md
new file mode 100644
index 0000000000..cc673b5aa8
--- /dev/null
+++ b/docs/cli/configure-machines.md
@@ -0,0 +1,219 @@
+---
+linkTitle: "Configure machines"
+title: "Configure machines with the CLI"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Create machines, add components and services, and manage fragments from the command line."
+---
+
+Create and configure machines, add and remove components and services, and apply configuration fragments from the command line.
+
+{{< expand "Prerequisites" >}}
+You need the Viam CLI installed and authenticated.
+See [Viam CLI overview](/cli/overview/) for installation and authentication instructions.
+{{< /expand >}}
+
+## Find your IDs
+
+Many commands on this page require an organization ID, location ID, machine ID, or part ID.
+
+A machine can have one or more **parts**, each running a separate instance of `viam-server`.
+Most machines have a single part.
+Multi-part machines are used when one logical machine runs across multiple computers.
+Every machine has at least one part (the main part), which is created automatically when you create the machine.
+When you add resources, apply fragments, or restart, you target a specific part.
+
+Find your organization ID and location ID:
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations list
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam locations list
+```
+
+Find machine IDs and part IDs.
+The `machines list` command prints each machine's ID and its main part ID.
+Use `machines part list` to see all parts for a machine:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines list --organization=<org-id> --location=<location-id>
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part list --machine=<machine-id>
+```
+
+## Create a machine
+
+```sh {class="command-line" data-prompt="$"}
+viam machines create --name=my-machine --location=<location-id>
+```
+
+This creates the machine in the Viam app.
+The machine is not connected to any hardware until you [install `viam-server`](/foundation/) on a device and configure it with this machine's credentials.
+
+On success, the CLI prints the new machine's ID:
+
+```sh {class="command-line" data-prompt="$" data-output="1"}
+created new machine with id abc12345-1234-abcd-5678-ef1234567890
+```
+
+Save this ID for subsequent commands.
+
+## List machines
+
+List all machines in a location:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines list --organization=<org-id> --location=<location-id>
+```
+
+List all machines across your entire organization:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines list --organization=<org-id> --all
+```
+
+## Add a component or service
+
+Add a resource to a machine part using its model triplet:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part add-resource \
+  --part=<part-id> \
+  --name=my-camera \
+  --model-name=viam:camera:webcam
+```
+
+This creates a bare resource entry with no additional attributes.
+Most components need attributes like pin numbers or device paths to function.
+See [Update resource attributes](#update-resource-attributes) to set them from the CLI, or configure them in the [Viam app](https://app.viam.com).
+
+The model triplet follows the format `namespace:module-name:model-name`.
+You can browse available models in the [Viam registry](https://app.viam.com/registry).
+Common model triplets:
+
+| Component            | Model triplet            |
+| -------------------- | ------------------------ |
+| Webcam camera        | `viam:camera:webcam`     |
+| GPIO motor           | `viam:motor:gpio`        |
+| Raspberry Pi 5 board | `viam:raspberry-pi:rpi5` |
+| Ultrasonic sensor    | `viam:ultrasonic:sensor` |
+| Fake arm (testing)   | `viam:arm:fake`          |
+| Fake motor (testing) | `viam:motor:fake`        |
+
+## Remove a component or service
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part remove-resource \
+  --part=<part-id> \
+  --name=my-camera
+```
+
+Connected machines pick up configuration changes automatically.
+You do not need to restart the machine after adding or removing a resource.
+
+## Manage resources
+
+### Update resource attributes
+
+After adding a resource, use `viam resource update` to set its attributes.
+The `--config` flag accepts inline JSON or a path to a JSON file:
+
+```sh {class="command-line" data-prompt="$"}
+viam resource update --part=<part-id> \
+  --resource-name=my-sensor --config '{"pin": "38"}'
+```
+
+To load attributes from a file:
+
+```sh {class="command-line" data-prompt="$"}
+viam resource update --part=<part-id> \
+  --resource-name=my-sensor --config ./sensor-config.json
+```
+
+{{< alert title="Caution" color="caution" >}}
+The `--config` flag replaces all existing attributes on the resource.
+To modify a single attribute, include the full attribute set in your JSON.
+Passing an empty value for an attribute deletes it.
+{{< /alert >}}
+
+### Enable and disable resources
+
+Disable a resource to stop it without removing it from the configuration.
+This is useful for temporarily taking a component offline or debugging issues with a specific resource.
+
+```sh {class="command-line" data-prompt="$"}
+viam resource disable --part=<part-id> --resource-name=my-sensor
+```
+
+Re-enable it:
+
+```sh {class="command-line" data-prompt="$"}
+viam resource enable --part=<part-id> --resource-name=my-sensor
+```
+
+You can enable or disable multiple resources in a single command:
+
+```sh {class="command-line" data-prompt="$"}
+viam resource disable --part=<part-id> \
+  --resource-name=my-sensor --resource-name=arm-1
+```
+
+## Apply a fragment
+
+Fragments are reusable configuration blocks that can define a set of components, services, and their attributes.
+Apply the same fragment across multiple machines to keep their configuration consistent.
+Add a fragment to a machine part by specifying its fragment ID:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part fragments add --part=<part-id> --fragment=<fragment-id>
+```
+
+If you omit the `--fragment` flag, the CLI prompts you to select a fragment interactively.
+
+Remove a fragment:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part fragments remove --part=<part-id> --fragment=<fragment-id>
+```
+
+See [Reuse machine configuration](/fleet/reuse-configuration/) for details on creating and managing fragments.
+
+## Rename or move a machine
+
+```sh {class="command-line" data-prompt="$"}
+viam machines update \
+  --machine=<machine-id> \
+  --new-name=updated-name \
+  --new-location=<new-location-id>
+```
+
+Moving a machine to a different location may affect access if your API keys or permissions are scoped to a specific location.
+
+## Delete a machine
+
+{{< alert title="Caution" color="caution" >}}
+Deleting a machine removes it and all of its configuration permanently.
+This cannot be undone.
+{{< /alert >}}
+
+```sh {class="command-line" data-prompt="$"}
+viam machines delete --machine=<machine-id>
+```
+
+## Restart a machine part
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part restart --part=<part-id>
+```
+
+## Related pages
+
+- [Get started](/foundation/) for setting up your first machine
+- [Configure hardware](/hardware/) for component configuration with the Viam app
+- [Manage your fleet with the CLI](/cli/manage-your-fleet/) for monitoring and remote access
+- [CLI reference](/cli/) for the complete `machines` command reference
diff --git a/docs/cli/data-pipelines.md b/docs/cli/data-pipelines.md
new file mode 100644
index 0000000000..b6137b3615
--- /dev/null
+++ b/docs/cli/data-pipelines.md
@@ -0,0 +1,120 @@
+---
+linkTitle: "Data pipelines"
+title: "Data pipelines with the CLI"
+weight: 40
+layout: "docs"
+type: "docs"
+description: "Create and manage scheduled data pipelines from the command line."
+---
+
+Create data pipelines that run MQL aggregations on your captured data on a schedule, transforming raw sensor readings or image metadata into precomputed summaries you can query efficiently.
+
+{{< expand "Prerequisites" >}}
+You need the Viam CLI installed and authenticated.
+See [Viam CLI overview](/cli/overview/) for installation and authentication instructions.
+
+You also need captured tabular data in the Viam cloud.
+See [Capture and sync data](/data/capture-sync/capture-and-sync-data/) to get started.
+{{< /expand >}}
+
+## Find your IDs
+
+To find your organization ID:
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations list
+```
+
+To find pipeline IDs for existing pipelines:
+
+```sh {class="command-line" data-prompt="$"}
+viam datapipelines list --org-id=<org-id>
+```
+
+## Create a pipeline
+
+A pipeline needs a name, a cron schedule, an MQL query, and whether to backfill historical data:
+
+```sh {class="command-line" data-prompt="$"}
+viam datapipelines create \
+  --org-id=<org-id> \
+  --name=hourly-temp-avg \
+  --schedule="0 * * * *" \
+  --data-source-type=standard \
+  --mql='[{"$match":{"component_name":"my-sensor"}},{"$group":{"_id":"$part_id","avg_temp":{"$avg":"$data.readings.temperature"}}}]' \
+  --enable-backfill=false
+```
+
+On success, the CLI prints the pipeline name and ID:
+
+```sh {class="command-line" data-prompt="$" data-output="1"}
+hourly-temp-avg (ID: abcdef12-3456-7890-abcd-ef1234567890) created.
+```
+
+Save the pipeline ID for management commands.
+
+For complex queries, put the MQL in a JSON file:
+
+```sh {class="command-line" data-prompt="$"}
+viam datapipelines create \
+  --org-id=<org-id> \
+  --name=hourly-temp-avg \
+  --schedule="0 * * * *" \
+  --data-source-type=standard \
+  --mql-path=./pipeline-query.json \
+  --enable-backfill=false
+```
+
+| Flag                    | Required     | Description                                                   |
+| ----------------------- | ------------ | ------------------------------------------------------------- |
+| `--name`                | Yes          | Pipeline name                                                 |
+| `--schedule`            | Yes          | Cron expression for when the pipeline runs                    |
+| `--enable-backfill`     | Yes          | `true` to run over historical data, `false` for new data only |
+| `--org-id`              | No           | Your organization ID (uses default if set)                    |
+| `--data-source-type`    | No           | `standard` (default) or `hotstorage` (hot data store)         |
+| `--mql` or `--mql-path` | One required | MQL query as inline JSON or path to a JSON file               |
+
+## List pipelines
+
+```sh {class="command-line" data-prompt="$"}
+viam datapipelines list --org-id=<org-id>
+```
+
+## Get pipeline details
+
+```sh {class="command-line" data-prompt="$"}
+viam datapipelines describe --id=<pipeline-id>
+```
+
+## Enable and disable pipelines
+
+Disable a pipeline without deleting it:
+
+```sh {class="command-line" data-prompt="$"}
+viam datapipelines disable --id=<pipeline-id>
+```
+
+Re-enable it:
+
+```sh {class="command-line" data-prompt="$"}
+viam datapipelines enable --id=<pipeline-id>
+```
+
+## Rename a pipeline
+
+```sh {class="command-line" data-prompt="$"}
+viam datapipelines rename --id=<pipeline-id> --name=new-pipeline-name
+```
+
+## Delete a pipeline
+
+```sh {class="command-line" data-prompt="$"}
+viam datapipelines delete --id=<pipeline-id>
+```
+
+## Related pages
+
+- [Create a data pipeline](/data/pipelines/create-a-pipeline/) for step-by-step pipeline creation with the Viam app and SDKs
+- [Pipeline examples and MQL tips](/data/pipelines/examples/) for common MQL patterns
+- [Query pipeline results](/data/pipelines/query-results/) for querying pipeline output
+- [CLI reference](/cli/) for the complete `datapipelines` command reference
diff --git a/docs/cli/datasets-and-training.md b/docs/cli/datasets-and-training.md
new file mode 100644
index 0000000000..0824d85a09
--- /dev/null
+++ b/docs/cli/datasets-and-training.md
@@ -0,0 +1,289 @@
+---
+linkTitle: "Datasets and training"
+title: "Datasets and training with the CLI"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "Create datasets, manage training data, and submit ML training jobs from the command line."
+---
+
+Create and populate datasets, submit training jobs, manage training scripts, and run inference from the command line or in automation scripts.
+
+{{< expand "Prerequisites" >}}
+You need the Viam CLI installed and authenticated.
+See [Viam CLI overview](/cli/overview/) for installation and authentication instructions.
+{{< /expand >}}
+
+## Find your IDs
+
+To find your organization ID:
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations list
+```
+
+To list datasets and find dataset IDs:
+
+```sh {class="command-line" data-prompt="$"}
+viam dataset list --org-id=<org-id>
+```
+
+To list training containers and find valid container versions:
+
+```sh {class="command-line" data-prompt="$"}
+viam train containers list
+```
+
+## Manage datasets
+
+### Create a dataset
+
+```sh {class="command-line" data-prompt="$"}
+viam dataset create --org-id=<org-id> --name=my-dataset
+```
+
+The CLI prints the new dataset's name and ID:
+
+```sh {class="command-line" data-prompt="$" data-output="1"}
+Created dataset my-dataset with dataset ID: abcdef12-3456-7890-abcd-ef1234567890
+```
+
+Save the dataset ID for subsequent commands.
+
+### List datasets
+
+List all datasets in your organization:
+
+```sh {class="command-line" data-prompt="$"}
+viam dataset list --org-id=<org-id>
+```
+
+List specific datasets by ID:
+
+```sh {class="command-line" data-prompt="$"}
+viam dataset list --dataset-ids=abc,def
+```
+
+### Add images to a dataset
+
+Adding images to a dataset creates references to the binary data items, it does not copy the data.
+Removing images removes the references without deleting the underlying data.
+
+Add images matching a filter (uses the same filter flags as [data export](/cli/manage-data/#export-images-and-binary-files)):
+
+```sh {class="command-line" data-prompt="$"}
+viam dataset data add filter \
+  --dataset-id=<dataset-id> \
+  --org-ids=<org-id> \
+  --location-ids=<location-id> \
+  --tags=defective \
+  --start=2026-01-01T00:00:00Z \
+  --end=2026-03-01T00:00:00Z
+```
+
+Add specific images by ID:
+
+```sh {class="command-line" data-prompt="$"}
+viam dataset data add ids \
+  --dataset-id=<dataset-id> \
+  --binary-data-ids=aaa,bbb,ccc
+```
+
+### Remove images from a dataset
+
+By filter:
+
+```sh {class="command-line" data-prompt="$"}
+viam dataset data remove filter \
+  --dataset-id=<dataset-id> \
+  --tags=low-quality
+```
+
+By ID:
+
+```sh {class="command-line" data-prompt="$"}
+viam dataset data remove ids \
+  --dataset-id=<dataset-id> \
+  --binary-data-ids=aaa,bbb
+```
+
+### Export a dataset
+
+Download all data from a dataset to a local directory.
+The export includes the binary files plus a `dataset.jsonl` file with annotation metadata (classification labels, bounding boxes, timestamps, file paths) that Viam's training infrastructure consumes.
+
+```sh {class="command-line" data-prompt="$"}
+viam dataset export \
+  --dataset-id=<dataset-id> \
+  --destination=./my-dataset
+```
+
+To export only the metadata without downloading binary files (useful for inspecting annotations):
+
+```sh {class="command-line" data-prompt="$"}
+viam dataset export \
+  --dataset-id=<dataset-id> \
+  --destination=./my-dataset \
+  --only-jsonl
+```
+
+### Merge datasets
+
+Combine multiple datasets into a new one:
+
+```sh {class="command-line" data-prompt="$"}
+viam dataset merge \
+  --name=combined-dataset \
+  --dataset-ids=abc,def,ghi
+```
+
+### Rename and delete datasets
+
+```sh {class="command-line" data-prompt="$"}
+viam dataset rename --dataset-id=<dataset-id> --name=new-name
+```
+
+Deleting a dataset removes the dataset and its references, but does not delete the underlying binary data.
+
+```sh {class="command-line" data-prompt="$"}
+viam dataset delete --dataset-id=<dataset-id>
+```
+
+## Submit training jobs
+
+### Train with a built-in model type
+
+Submit a managed training job using one of Viam's built-in model types:
+
+```sh {class="command-line" data-prompt="$"}
+viam train submit managed \
+  --dataset-id=<dataset-id> \
+  --model-org-id=<org-id> \
+  --model-name=my-detector \
+  --model-type=single_label_classification \
+  --model-framework=tflite \
+  --model-labels=defective,good
+```
+
+On success, the CLI prints the job ID:
+
+```sh {class="command-line" data-prompt="$" data-output="1"}
+Submitted training job with ID abcdef12-3456-7890-abcd-ef1234567890
+```
+
+Model types: `single_label_classification`, `multi_label_classification`, `object_detection`.
+
+### Train with a custom training script
+
+Submit a job using a custom script from the registry:
+
+```sh {class="command-line" data-prompt="$"}
+viam train submit custom from-registry \
+  --dataset-id=<dataset-id> \
+  --model-name=my-custom-model \
+  --org-id=<org-id> \
+  --script-name=<training-script-name> \
+  --version=<script-version> \
+  --container-version=<container-version>
+```
+
+Submit a custom script by uploading it directly:
+
+```sh {class="command-line" data-prompt="$"}
+viam train submit custom with-upload \
+  --dataset-id=<dataset-id> \
+  --model-name=my-custom-model \
+  --model-org-id=<org-id> \
+  --script-name=my-training-script \
+  --path=./my-training-script/ \
+  --framework=tflite \
+  --container-version=<container-version>
+```
+
+### Monitor training jobs
+
+List training jobs in your organization:
+
+```sh {class="command-line" data-prompt="$"}
+viam train list --org-id=<org-id>
+```
+
+Filter by status:
+
+```sh {class="command-line" data-prompt="$"}
+viam train list --org-id=<org-id> --job-status=completed
+```
+
+Get details on a specific job (use the job ID from `train submit` or `train list`):
+
+```sh {class="command-line" data-prompt="$"}
+viam train get --job-id=<job-id>
+```
+
+View training logs:
+
+```sh {class="command-line" data-prompt="$"}
+viam train logs --job-id=<job-id>
+```
+
+Cancel a running job:
+
+```sh {class="command-line" data-prompt="$"}
+viam train cancel --job-id=<job-id>
+```
+
+## Manage training scripts
+
+Upload a custom training script to the registry:
+
+```sh {class="command-line" data-prompt="$"}
+viam training-script upload \
+  --path=./my-training-script/ \
+  --script-name=my-training-script \
+  --framework=tflite
+```
+
+Update script visibility:
+
+```sh {class="command-line" data-prompt="$"}
+viam training-script update \
+  --script-name=my-training-script \
+  --visibility=public
+```
+
+Test a training script locally before uploading (use `viam train containers list` to find valid container versions).
+Local testing runs in a Docker container that mirrors the cloud training environment.
+The container validates that your script directory contains `setup.py` and `model/training.py`.
+
+{{< alert title="Note" color="note" >}}
+Local testing uses Google Vertex AI containers, which are linux/x86_64 only.
+On ARM Macs, Docker runs them through Rosetta emulation, which may be slower.
+{{< /alert >}}
+
+```sh {class="command-line" data-prompt="$"}
+viam training-script test-local \
+  --dataset-root=./my-dataset/ \
+  --training-script-directory=./my-training-script/ \
+  --container-version=<container-version>
+```
+
+## Run inference
+
+Run inference on a single image using a trained model:
+
+```sh {class="command-line" data-prompt="$"}
+viam infer \
+  --binary-data-id=<binary-data-id> \
+  --model-org-id=<org-id> \
+  --model-name=my-detector \
+  --model-version=latest
+```
+
+To find binary data IDs, export data with `viam data export` or browse the DATA page in the Viam app.
+
+## Related pages
+
+- [Create a dataset](/train/create-a-dataset/) for step-by-step dataset creation with the Viam app
+- [Train a model](/train/train-a-model/) for training with the Viam app
+- [Custom training scripts](/train/custom-training-scripts/) for writing custom training logic
+- [CLI reference](/cli/) for the complete `train` command reference
diff --git a/docs/cli/manage-data.md b/docs/cli/manage-data.md
new file mode 100644
index 0000000000..d9cffaa77a
--- /dev/null
+++ b/docs/cli/manage-data.md
@@ -0,0 +1,237 @@
+---
+linkTitle: "Manage data"
+title: "Manage data with the CLI"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "Export, tag, delete, and query your machine data from the command line."
+---
+
+Export captured data to your local machine, organize it with tags, delete old data, and configure database access for direct queries.
+
+{{< expand "Prerequisites" >}}
+You need the Viam CLI installed and authenticated.
+See [Viam CLI overview](/cli/overview/) for installation and authentication instructions.
+{{< /expand >}}
+
+## Find your IDs
+
+Many data commands require an organization ID, location ID, or part ID.
+To look up these values:
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations list
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam locations list
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam machines list --organization=<org-id> --location=<location-id>
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part list --machine=<machine-id>
+```
+
+## Export data
+
+### Export images and binary files
+
+Export all binary data from an organization:
+
+```sh {class="command-line" data-prompt="$"}
+viam data export binary filter \
+  --destination=./my-data \
+  --org-ids=<org-id>
+```
+
+The CLI downloads files into the destination directory and prints progress as it goes.
+
+Narrow the export with filters:
+
+```sh {class="command-line" data-prompt="$"}
+viam data export binary filter \
+  --destination=./my-data \
+  --org-ids=<org-id> \
+  --mime-types=image/jpeg,image/png \
+  --machine-id=<machine-id> \
+  --start=2026-01-01T00:00:00Z \
+  --end=2026-02-01T00:00:00Z
+```
+
+Available filters:
+
+| Filter                | Flag                                   | Example                             |
+| --------------------- | -------------------------------------- | ----------------------------------- |
+| By machine            | `--machine-id` or `--machine-name`     | `--machine-id=abc123`               |
+| By part               | `--part-id` or `--part-name`           | `--part-id=def456`                  |
+| By location           | `--location-ids`                       | `--location-ids=loc1,loc2`          |
+| By time range         | `--start`, `--end`                     | `--start=2026-01-01T00:00:00Z`      |
+| By component          | `--component-name`, `--component-type` | `--component-name=my-camera`        |
+| By MIME type          | `--mime-types`                         | `--mime-types=image/jpeg,image/png` |
+| By tag                | `--tags`                               | `--tags=defective,reviewed`         |
+| By bounding box label | `--bbox-labels`                        | `--bbox-labels=screw,bolt`          |
+
+Export specific files by their binary data IDs:
+
+```sh {class="command-line" data-prompt="$"}
+viam data export binary ids \
+  --destination=./my-data \
+  --binary-data-ids=aaa,bbb,ccc
+```
+
+### Export sensor and tabular data
+
+Tabular exports require a part ID and resource identifier:
+
+```sh {class="command-line" data-prompt="$"}
+viam data export tabular \
+  --destination=./sensor-data \
+  --part-id=<part-id> \
+  --resource-name=my-sensor \
+  --resource-subtype=rdk:component:sensor \
+  --method=Readings
+```
+
+Output is written to a `data.ndjson` file (one JSON object per line).
+You can also filter by time range with `--start` and `--end`.
+
+## Tag data
+
+Tags help you organize data for filtering, dataset creation, and search.
+
+### Add tags by ID
+
+Add tags to specific files by their binary data IDs:
+
+```sh {class="command-line" data-prompt="$"}
+viam data tag ids add \
+  --tags=reviewed,approved \
+  --binary-data-ids=aaa,bbb
+```
+
+Remove tags from specific files:
+
+```sh {class="command-line" data-prompt="$"}
+viam data tag ids remove \
+  --tags=reviewed \
+  --binary-data-ids=aaa,bbb
+```
+
+### Add tags by filter
+
+{{< alert title="Note" color="note" >}}
+The filter-based tag commands (`tag filter add` and `tag filter remove`) use deprecated underlying APIs.
+They still work but may be removed in a future release.
+Prefer the ID-based commands above when possible.
+{{< /alert >}}
+
+Add tags to all data matching a filter:
+
+```sh {class="command-line" data-prompt="$"}
+viam data tag filter add \
+  --tags=reviewed,approved \
+  --org-ids=<org-id> \
+  --location-ids=<location-id> \
+  --mime-types=image/jpeg
+```
+
+Remove tags by filter:
+
+```sh {class="command-line" data-prompt="$"}
+viam data tag filter remove \
+  --tags=reviewed \
+  --org-ids=<org-id>
+```
+
+## Delete data
+
+### Delete binary data
+
+Delete binary data matching a filter.
+Both `--start` and `--end` are required:
+
+```sh {class="command-line" data-prompt="$"}
+viam data delete binary \
+  --org-ids=<org-id> \
+  --mime-types=image/jpeg \
+  --start=2026-01-01T00:00:00Z \
+  --end=2026-02-01T00:00:00Z
+```
+
+### Delete tabular data
+
+Delete tabular data older than a specified number of days.
+Pass `0` to delete all tabular data for your organization.
+
+```sh {class="command-line" data-prompt="$"}
+viam data delete tabular --org-id=<org-id> --delete-older-than-days=90
+```
+
+If the organization has a [hot data store](/data/hot-data-store/), matching data is deleted from that store as well.
+
+{{< alert title="Caution" color="caution" >}}
+Passing `--delete-older-than-days=0` deletes **all** tabular data in the organization. This command has no component or location filter.
+{{< /alert >}}
+
+## Configure database access
+
+To query synced data directly with MongoDB-compatible tools like `mongosh` or Grafana, set up a database user:
+
+```sh {class="command-line" data-prompt="$"}
+viam data database configure --org-id=<org-id> --password=<password>
+```
+
+{{< alert title="Caution" color="caution" >}}
+If you already have database credentials configured, changing the password breaks existing connections from dashboards and integrations that use the old password.
+{{< /alert >}}
+
+Get the connection hostname:
+
+```sh {class="command-line" data-prompt="$"}
+viam data database hostname --org-id=<org-id>
+```
+
+Use the returned hostname with your MongoDB client.
+See [Visualize data](/data/visualize-data/) for Grafana setup instructions.
+
+## Manage data indexes
+
+Create custom indexes to speed up queries on large datasets.
+The `--collection-type` flag specifies the target: `hot-storage` for hot data store collections, or `pipeline-sink` for data pipeline output collections (requires `--pipeline-name`).
+
+The `--index-path` flag takes a JSON file defining the index using [MongoDB index specification format](https://www.mongodb.com/docs/manual/reference/command/createIndexes/):
+
+```json
+{
+  "key": { "meta.captured_at": 1, "tags": 1 },
+  "name": "captured-at-tags"
+}
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam data index create \
+  --collection-type=hot-storage \
+  --index-path=./my-index.json
+```
+
+List existing indexes:
+
+```sh {class="command-line" data-prompt="$"}
+viam data index list --collection-type=hot-storage
+```
+
+Delete an index:
+
+```sh {class="command-line" data-prompt="$"}
+viam data index delete --collection-type=hot-storage --index-name=my-index
+```
+
+## Related pages
+
+- [Export data](/data/export-data/) for step-by-step export instructions with the Viam app
+- [Data pipelines with the CLI](/cli/data-pipelines/) for scheduled data transformations
+- [Datasets and training with the CLI](/cli/datasets-and-training/) for managing ML datasets
+- [CLI reference](/cli/#data) for the complete `data` command reference
diff --git a/docs/cli/manage-your-fleet.md b/docs/cli/manage-your-fleet.md
new file mode 100644
index 0000000000..e79237f6f9
--- /dev/null
+++ b/docs/cli/manage-your-fleet.md
@@ -0,0 +1,301 @@
+---
+linkTitle: "Manage your fleet"
+title: "Manage your fleet with the CLI"
+weight: 60
+layout: "docs"
+type: "docs"
+description: "Monitor machines, view logs, access remote shells, and deploy software from the command line."
+---
+
+Monitor machine status, stream logs, connect to remote machines with a shell, copy files, and deploy software packages across your fleet.
+
+{{< expand "Prerequisites" >}}
+You need the Viam CLI installed and authenticated.
+See [Viam CLI overview](/cli/overview/) for installation and authentication instructions.
+{{< /expand >}}
+
+## Find your IDs
+
+To find your organization ID and location IDs:
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations list
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam locations list
+```
+
+To find machine IDs and part IDs:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines list --organization=<org-id> --location=<location-id>
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part list --machine=<machine-id>
+```
+
+## List and monitor machines
+
+List all machines in a location:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines list --organization=<org-id> --location=<location-id>
+```
+
+List all machines across your organization:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines list --organization=<org-id> --all
+```
+
+Check the status of a specific machine:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines status --machine=<machine-id>
+```
+
+## View logs
+
+Stream logs from a machine:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines logs --machine=<machine-id>
+```
+
+Stream logs from a specific part:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part logs --part=<part-id>
+```
+
+Show only errors:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part logs --part=<part-id> --errors
+```
+
+Follow logs in real time:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part logs --part=<part-id> --tail
+```
+
+## Shell into a machine
+
+Open an interactive shell on a remote machine part.
+The connection uses Viam's secure WebRTC channel, not direct SSH. The machine must have a shell service configured.
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part shell --part=<part-id>
+```
+
+## Copy files to and from machines
+
+File copy uses the same secure connection as shell access, not SSH or SCP.
+Use the `machine:` prefix for remote paths.
+
+Copy a file to a machine:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part cp --part=<part-id> local-file.txt machine:/home/user/
+```
+
+Copy a file from a machine:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part cp --part=<part-id> machine:/home/user/remote-file.txt ./
+```
+
+Copy a directory recursively:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part cp --part=<part-id> -r ./local-dir machine:/home/user/
+```
+
+Preserve file permissions and timestamps:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part cp --part=<part-id> -r --preserve ./local-dir machine:/home/user/
+```
+
+## Create a tunnel
+
+Forward a local port to a port on a remote machine.
+This is useful for accessing web UIs, databases, or other services running on machines that are not directly reachable from your network.
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part tunnel \
+  --part=<part-id> \
+  --local-port=8080 \
+  --destination-port=8080
+```
+
+## Run component and service methods
+
+Call a gRPC method on a component or service directly from the CLI, like `curl` for Viam's API:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part run \
+  --part=<part-id> \
+  --data='{"name": "my-sensor"}' \
+  rdk.component.sensor.v1.SensorService.GetReadings
+```
+
+Stream results at an interval:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part run \
+  --part=<part-id> \
+  --stream=500ms \
+  --data='{"name": "my-camera"}' \
+  rdk.component.camera.v1.CameraService.GetImage
+```
+
+## Deploy software packages
+
+Upload a package to the Viam registry for deployment to machines.
+The `--type` flag specifies the package type: `archive`, `ml_model`, `module`, `slam_map`, or `ml_training`.
+
+```sh {class="command-line" data-prompt="$"}
+viam packages upload \
+  --path=./my-package.tar.gz \
+  --name=my-control-logic \
+  --version=1.0.0 \
+  --type=archive \
+  --org-id=<org-id>
+```
+
+For ML model packages, you must also specify the framework and model type:
+
+```sh {class="command-line" data-prompt="$"}
+viam packages upload \
+  --path=./my-model.tar.gz \
+  --name=my-detector \
+  --version=1.0.0 \
+  --type=ml_model \
+  --model-framework=tflite \
+  --model-type=object_detection \
+  --org-id=<org-id>
+```
+
+Download a package from the registry:
+
+```sh {class="command-line" data-prompt="$"}
+viam packages export \
+  --org-id=<org-id> \
+  --name=my-detector \
+  --version=latest \
+  --type=ml_model \
+  --destination=./downloaded
+```
+
+If you omit `--version`, the CLI downloads the latest version.
+If you omit `--destination`, the package is saved to the current directory.
+
+## Export diagnostics
+
+Export FTDC (Full-Time Diagnostic Data Capture) metrics from a machine:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part get-ftdc --part=<part-id>
+```
+
+Parse an FTDC file locally:
+
+```sh {class="command-line" data-prompt="$"}
+viam parse-ftdc --path=./ftdc-data
+```
+
+## Work with traces
+
+Viam machines collect [OpenTelemetry](https://opentelemetry.io/) traces that record the timing and context of operations.
+Use the `viam traces` commands to retrieve and inspect these traces for debugging performance issues.
+
+### Print traces to the console
+
+Print traces from a remote machine:
+
+```sh {class="command-line" data-prompt="$"}
+viam traces print-remote --part=<part-id>
+```
+
+Print traces from a local file:
+
+```sh {class="command-line" data-prompt="$"}
+viam traces print-local ./traces-file
+```
+
+### Download traces
+
+Download traces from a machine and save them to disk:
+
+```sh {class="command-line" data-prompt="$"}
+viam traces get-remote --part=<part-id>
+```
+
+By default, the file is saved to the current directory.
+Pass a target path to save elsewhere:
+
+```sh {class="command-line" data-prompt="$"}
+viam traces get-remote --part=<part-id> ./my-traces
+```
+
+### Import traces to an OTLP endpoint
+
+If you run a tracing backend like Jaeger or Grafana Tempo, import traces directly from a machine or a local file:
+
+```sh {class="command-line" data-prompt="$"}
+viam traces import-remote --part=<part-id> --endpoint=localhost:4317
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam traces import-local ./traces-file --endpoint=localhost:4317
+```
+
+The `--endpoint` flag defaults to `localhost:4317` if omitted.
+
+{{< alert title="Note" color="note" >}}
+Remote trace commands require the machine to have a shell service configured.
+{{< /alert >}}
+
+## Read metadata
+
+Read metadata attached to an organization, location, machine, or machine part.
+Specify at least one ID:
+
+```sh {class="command-line" data-prompt="$"}
+viam metadata read --machine-id=<machine-id>
+```
+
+You can combine multiple IDs to read metadata at different levels:
+
+```sh {class="command-line" data-prompt="$"}
+viam metadata read --org-id=<org-id> --location-id=<location-id>
+```
+
+Available flags: `--org-id`, `--location-id`, `--machine-id`, `--part-id`.
+
+## Create API keys for machines
+
+Create an API key scoped to a specific machine:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines api-key create --machine-id=<machine-id>
+```
+
+The CLI prints the key ID and key value. Save both immediately; the key value is only shown once.
+
+```sh {class="command-line" data-prompt="$" data-output="1-3"}
+Successfully created key:
+Key ID: abcdef12-3456-7890-abcd-ef1234567890
+Key Value: your-secret-key-value
+```
+
+## Related pages
+
+- [Monitor machine status](/monitor/monitor/) for monitoring with the Viam app
+- [Troubleshoot](/monitor/troubleshoot/) for debugging machine issues
+- [Deploy software](/fleet/deploy-software/) for deploying with fragments
+- [CLI reference](/cli/#machines-alias-robots-and-machine) for the complete `machines` command reference
diff --git a/docs/cli/overview.md b/docs/cli/overview.md
new file mode 100644
index 0000000000..6c0cc3f8b0
--- /dev/null
+++ b/docs/cli/overview.md
@@ -0,0 +1,195 @@
+---
+linkTitle: "Overview"
+title: "Viam CLI overview"
+weight: 1
+layout: "docs"
+type: "docs"
+description: "The Viam CLI gives you command-line access to every operation in the Viam platform, from machine configuration to data export to fleet management."
+---
+
+The Viam CLI is a single binary that gives you command-line access to the Viam platform.
+Everything you can do in the Viam app, and several things you can only do from the command line, are available as CLI commands.
+
+## When to use the CLI
+
+If you prefer working in a terminal, the CLI covers the same operations as the Viam app.
+You can use whichever interface you prefer, or both.
+
+The CLI is particularly well-suited for tasks that are awkward or impossible in a browser:
+
+- **Scripting and automation.** Create machines, export data, upload modules, or submit training jobs from shell scripts and CI/CD pipelines.
+- **Headless environments.** Authenticate with an API key, view logs, and shell into a remote machine without a browser.
+- **Bulk operations.** List all machines across an organization, or export binary data filtered by location, machine, or component type.
+- **Operations only available through the CLI.** Scaffold new modules, transfer files to and from machines, tunnel ports, and hot-reload modules during development.
+
+## What the CLI covers
+
+| Area                     | What you can do                                                  | Guide                                                              |
+| ------------------------ | ---------------------------------------------------------------- | ------------------------------------------------------------------ |
+| Machine configuration    | Create machines, add components and services, apply fragments    | [Configure machines](/cli/configure-machines/)                     |
+| Data management          | Export, tag, and delete captured data; configure database access | [Manage data](/cli/manage-data/)                                   |
+| Datasets and ML training | Create datasets, submit training jobs, run inference             | [Datasets and training](/cli/datasets-and-training/)               |
+| Data pipelines           | Create and manage scheduled MQL aggregation pipelines            | [Data pipelines](/cli/data-pipelines/)                             |
+| Module development       | Scaffold, build, upload, and version modules                     | [Build and deploy modules](/cli/build-and-deploy-modules/)         |
+| Fleet operations         | Monitor status, stream logs, shell into machines, copy files     | [Manage your fleet](/cli/manage-your-fleet/)                       |
+| Organization admin       | Manage API keys, configure OAuth, set up billing                 | [Administer your organization](/cli/administer-your-organization/) |
+| Scripting and CI/CD      | Authenticate in scripts, automate common workflows               | [Automate with scripts](/cli/automate-with-scripts/)               |
+
+### CLI-only operations
+
+Some operations are only available through the CLI:
+
+- **Module scaffolding** (`viam module generate`) creates a new module project with boilerplate code and a build script.
+- **Shell access** (`viam machines part shell`) opens an interactive terminal on a remote machine.
+- **File transfer** (`viam machines part cp`) copies files to and from machines.
+- **Port tunneling** (`viam machines part tunnel`) forwards a local port to a remote machine.
+- **Module hot-reload** (`viam module reload-local`) reloads a module during development without restarting the machine.
+
+## Install
+
+{{< readfile "/static/include/how-to/install-cli.md" >}}
+
+Verify the installation:
+
+```sh {class="command-line" data-prompt="$"}
+viam version
+```
+
+To update the CLI to the latest version:
+
+```sh {class="command-line" data-prompt="$"}
+viam update
+```
+
+## Authenticate
+
+{{< readfile "/static/include/how-to/auth-cli.md" >}}
+
+Authentication tokens refresh automatically. You do not need to re-authenticate between sessions unless your token is revoked.
+
+To check who you are authenticated as:
+
+```sh {class="command-line" data-prompt="$"}
+viam whoami
+```
+
+This prints your email if you logged in interactively, or `key-<uuid>` if you authenticated with an API key.
+
+To end your session:
+
+```sh {class="command-line" data-prompt="$"}
+viam logout
+```
+
+To print your current access token (for piping into other tools, only works with interactive login, not API keys):
+
+```sh {class="command-line" data-prompt="$"}
+viam login print-access-token
+```
+
+### Authenticate in scripts and CI/CD
+
+Interactive login opens a browser, which does not work in headless environments.
+Use API key authentication instead:
+
+```sh {class="command-line" data-prompt="$"}
+viam login api-key --key-id=<key-id> --key=<key>
+```
+
+To create an API key, see [Manage API keys](/cli/administer-your-organization/#manage-api-keys).
+
+## Set defaults
+
+If you work primarily within one organization or location, set defaults to avoid passing `--org-id` or `--location-id` on every command.
+The CLI validates that the org or location exists and is accessible before saving.
+Defaults are scoped to the active profile, so each profile can have its own default org and location.
+
+```sh {class="command-line" data-prompt="$"}
+viam defaults set-org --org-id=<org-id>
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam defaults set-location --location-id=<location-id>
+```
+
+To find your organization ID:
+
+```sh {class="command-line" data-prompt="$"}
+viam organizations list
+```
+
+To find location IDs within your organization:
+
+```sh {class="command-line" data-prompt="$"}
+viam locations list
+```
+
+Clear defaults when you need to work across organizations:
+
+```sh {class="command-line" data-prompt="$"}
+viam defaults clear-org
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam defaults clear-location
+```
+
+## Manage authentication profiles
+
+If you work across multiple organizations or use both personal and service accounts, profiles let you switch between saved credentials without re-authenticating.
+Each profile stores an API key and maintains its own default org and location independently.
+
+```sh {class="command-line" data-prompt="$"}
+viam profiles add --profile-name=production --key-id=<key-id> --key=<key>
+```
+
+`profiles add` errors if the name already exists. Use `profiles update` to overwrite an existing profile:
+
+```sh {class="command-line" data-prompt="$"}
+viam profiles update --profile-name=production --key-id=<new-key-id> --key=<new-key>
+```
+
+Use a profile for a single command with the `--profile` global flag:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines list --all --profile=production
+```
+
+Or set the `VIAM_CLI_PROFILE_NAME` environment variable to activate a profile for an entire shell session:
+
+```sh {class="command-line" data-prompt="$"}
+export VIAM_CLI_PROFILE_NAME=production
+viam machines list --all
+```
+
+List and remove profiles:
+
+```sh {class="command-line" data-prompt="$"}
+viam profiles list
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam profiles remove --profile-name=staging
+```
+
+## Global flags
+
+Every command accepts these flags:
+
+| Flag                 | Description                                |
+| -------------------- | ------------------------------------------ |
+| `--profile`          | Use a saved authentication profile         |
+| `--config`, `-c`     | Path to a CLI config file                  |
+| `--debug`, `--vvv`   | Enable debug logging                       |
+| `--quiet`, `-q`      | Suppress non-essential output              |
+| `--disable-profiles` | Ignore all saved profiles for this command |
+
+## Get help
+
+Every command supports the `--help` flag:
+
+```sh {class="command-line" data-prompt="$"}
+viam --help
+viam machines --help
+viam machines part shell --help
+```
diff --git a/docs/dev/tools/cli.md b/docs/cli/reference.md
similarity index 79%
rename from docs/dev/tools/cli.md
rename to docs/cli/reference.md
index 3c3c46056c..cb525bf906 100644
--- a/docs/dev/tools/cli.md
+++ b/docs/cli/reference.md
@@ -1,295 +1,22 @@
 ---
-title: "Viam CLI"
-linkTitle: "CLI"
-weight: 10
+title: "CLI reference"
+linkTitle: "CLI reference"
+weight: 90
 type: "docs"
-no_list: true
-description: "Manage and control your machines from the command line."
-aliases:
-  - "/build/program/cli"
-  - /manage/cli/
-  - /fleet/cli/
-  - /cli/
-images: ["/platform/cli.png"]
+description: "Complete command reference for the Viam CLI: every command, subcommand, flag, and alias."
 date: "2024-08-23"
 # updated: ""  # When the content was last entirely checked
 ---
 
-The Viam CLI (command line interface) tool enables you to manage your machines and {{< glossary_tooltip term_id="modular-resource" text="modular resources" >}} across organizations and locations from the command line.
-The CLI lets you:
+This page documents every command, subcommand, flag, and alias in the Viam CLI.
+For installation, authentication, and task-oriented guides, see the [Viam CLI overview](/cli/overview/).
 
-- Retrieve [organization](/dev/reference/glossary/#organization) and location information
-- Manage fleet data and logs
-- Control machines by issuing component and service commands
-- Upload and manage modular resources in the [registry](https://app.viam.com/registry/)
-
-For example, this CLI command moves a servo to the 75 degree position:
-
-```sh {class="command-line" data-prompt="$"}
-viam machines part run --machine 82c608a-1be9-46a5 --organization 123 \
---location myLoc --part "mymachine-main" --data '{"name": "myServo", "angle_deg":75}' \
-viam.component.servo.v1.ServoService.MoveRequest
-```
-
-## Install
-
-You can download the Viam CLI using one of the options below.
-Select the tab for your platform and architecture.
-If you are on Linux, you can use the `uname -m` command to determine your system architecture.
-
-{{< tabs >}}
-{{% tab name="macOS" %}}
-
-To download the Viam CLI on a macOS computer, run the following commands:
-
-```sh {class="command-line" data-prompt="$"}
-brew tap viamrobotics/brews
-brew install viam
-```
-
-{{% /tab %}}
-{{% tab name="Linux aarch64" %}}
-
-To download the Viam CLI on a Linux computer with the `aarch64` architecture, run the following commands:
-
-```sh {class="command-line" data-prompt="$"}
-sudo curl --compressed -o /usr/local/bin/viam https://storage.googleapis.com/packages.viam.com/apps/viam-cli/viam-cli-stable-linux-arm64
-sudo chmod a+rx /usr/local/bin/viam
-```
-
-{{% /tab %}}
-{{% tab name="Linux x86_64" %}}
-
-To download the Viam CLI on a Linux computer with the `amd64` (Intel `x86_64`) architecture, run the following commands:
-
-```sh {class="command-line" data-prompt="$"}
-sudo curl --compressed -o /usr/local/bin/viam https://storage.googleapis.com/packages.viam.com/apps/viam-cli/viam-cli-stable-linux-amd64
-sudo chmod a+rx /usr/local/bin/viam
-```
-
-You can also install the Viam CLI using [brew](https://brew.sh/) on Linux `amd64` (Intel `x86_64`):
-
-```sh {class="command-line" data-prompt="$"}
-brew tap viamrobotics/brews
-brew install viam
-```
-
-{{% /tab %}}
-{{% tab name="Windows" %}}
-
-[Download the binary](https://storage.googleapis.com/packages.viam.com/apps/viam-cli/viam-cli-stable-windows-amd64.exe) and run it directly to use the Viam CLI on a Windows computer.
-
-{{% /tab %}}
-{{% tab name="Source" %}}
-
-If you have [Go installed](https://go.dev/doc/install), you can build the Viam CLI directly from source using the `go install` command:
-
-```sh {class="command-line" data-prompt="$"}
-go install go.viam.com/rdk/cli/viam@latest
-```
-
-To confirm `viam` is installed and ready to use, issue the _viam_ command from your terminal.
-If you see help instructions, everything is correctly installed.
-If you do not see help instructions, add your local <file>go/bin/\*</file> directory to your `PATH` variable.
-If you use `bash` as your shell, you can use the following command:
-
-```sh {class="command-line" data-prompt="$"}
-echo 'export PATH="$HOME/go/bin:$PATH"' >> ~/.bashrc
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-To later update the Viam CLI tool on Linux, use the steps above to reinstall the latest version.
-to later update the Viam CLI tool on macOS, run `brew upgrade viam`.
-
-## Authenticate
-
-Once you have [installed the Viam CLI](#install), you must authenticate your CLI session with Viam in order to run CLI commands.
-
-You can authenticate your CLI session using a personal access token, a profile, or an organization, location, or machine part API key.
-
-- To authenticate your CLI session using a personal access token:
-
-  ```sh {class="command-line" data-prompt="$"}
-  viam login
-  ```
-
-  This will open a new browser window with a prompt to start the authentication process.
-  If a browser window does not open, the CLI will present a URL for you to manually open in your browser.
-  Follow the instructions to complete the authentication process.
-
-- To authenticate your CLI session using an organization, location, or machine part API key:
-
-  ```sh {class="command-line" data-prompt="$"}
-  viam login api-key --key-id <api-key-id> --key <organization-api-key-secret>
-  ```
-
-  {{< alert title="Note" color="note" >}}
-  To use an organization, location, or machine part API key to authenticate, you can create one from the organization's settings page or authenticate with a personal access token and then [create an organization API key](#create-an-organization-api-key), a [location](#create-a-location-api-key), or a [machine part API key](#create-a-machine-part-api-key).
-  {{< /alert >}}
-
-An authenticated session is valid for 24 hours, unless you explicitly [log out](#logout).
-
-After the session expires or you log out, you must re-authenticate to use the CLI again.
-
-## CLI profiles
-
-You can also authenticate your CLI session with profiles which allow you to switch between using different privileges.
-To create a profile, run the following command:
-
-```sh {class="command-line" data-prompt="$"}
-viam profiles add --profile-name=default --key-id=<api-key-id> --key=<api-key>
-```
-
-To use a profile to authenticate a command, pass the `--profile` flag.
-By default, the Viam CLI does not use a profile.
-To use a specific profile by default, set the environment variable `VIAM_CLI_PROFILE_NAME` to the profile name.
-
-### Create an organization API key
-
-To use an API key to authenticate your CLI session, you must create one.
-You can do this from the organization's settings page or with the CLI.
-
-1. First, [authenticate](#authenticate) your CLI session.
-
-1. Then, run the following command to create a new organization API key:
-
-   ```sh {class="command-line" data-prompt="$"}
-   viam organizations api-key create --org-id <org-id> --name <key-name>
-   ```
-
-   Where:
-
-   - `org-id` is your organization ID.
-     You can find your organization ID by running `viam organizations list` or by visiting your organization's **Settings** page in the [Viam app](https://app.viam.com/).
-   - `key-name` is an optional name for your API key.
-
-The command will return a `key id` and a `key value`.
-You will need both to authenticate.
-
-{{% alert title="Important" color="note" %}}
-Keep these key values safe.
-By default, new organization API keys are created with **Owner** permissions, giving the key full read and write access to all machines within your organization.
-You can change an API key's permissions on the organizations page by clicking the **Show details** link next to your API key.
-{{% /alert %}}
-
-Once created, you can use the organization API key to authenticate future CLI sessions or to [use the SDKs](/dev/reference/sdks/).
-To switch to using an organization API key for authentication right away, [logout](#logout) then log back in using `viam login api-key`.
-
-An organization can have multiple API keys.
-
-### Create a location API key
-
-To use an location API key to authenticate your CLI session, you must first create one:
-You can do this from the organization's settings page or with the CLI.
-
-1. First, [authenticate](#authenticate) your CLI session.
-   If you don't already have a location API key created, authenticate using a personal access token, an [organization API key](#create-an-organization-api-key), or a [machine part API key](#create-a-machine-part-api-key).
-
-1. Then, run the following command to create a new location API key:
-
-   ```sh {class="command-line" data-prompt="$"}
-   viam locations api-key create --location-id <location-id> --org-id <org-id> --name <key-name>
-   ```
-
-   Where:
-
-   - `location-id` is your location ID.
-     You can find your location ID by running `viam locations list` or by visiting your [fleet's page](https://app.viam.com/robots).
-   - `org-id` is an optional organization ID to attach the key to.
-     You can find your organization ID by running `viam organizations list` or by visiting your organization's **Settings** page in the [Viam app](https://app.viam.com/).
-     If only one organization owns the location, you can omit the parameter.
-     If multiple organizations own the location, you must specify the `org-id` explicitly.
-   - `key-name` is an optional name for your API key.
-     If omitted, a name will be auto-generated based on your login info and the current time.
-
-The command will return a `key id` and a `key value`.
-You will need both to authenticate.
-
-{{% alert title="Important" color="note" %}}
-Keep these key values safe.
-By default, new location API keys are created with **Owner** permissions, giving the key full read and write access to all machines within your location.
-You can change an API key's permissions on the organizations page by clicking the **Show details** link next to your API key.
-{{% /alert %}}
-
-Once created, you can use the location API key to authenticate future CLI sessions or to [connect to machines with the SDK](/dev/reference/sdks/).
-To switch to using a location API key for authentication right away, [logout](#logout) then log back in using `viam login api-key`.
-
-A location can have multiple API keys.
-
-### Create a machine part API key
-
-To use a machine part API key to authenticate your CLI session, you must first create one:
-You can do this from the organization's settings page or with the CLI.
-
-1. First, [authenticate](#authenticate) your CLI session.
-   If you don't already have a machine part API key created, authenticate using a personal access token, an [organization API key](#create-an-organization-api-key), or a [location API key](#create-a-location-api-key).
-
-1. Then, run the following command to create a new machine part API key:
-
-   ```sh {class="command-line" data-prompt="$"}
-   viam machines api-key create --machine-id <machine-id> --org-id <org-id> --name <key-name>
-   ```
-
-   Where:
-
-   - `machine-id` is your machine's ID.
-     You can find your machine ID by running `viam machines list`, or by clicking the **...** button in the upper-right corner of your machine's page, and selecting **Copy machine ID**.
-   - `org-id` is an optional organization ID to attach the key to.
-     You can find your organization ID by running `viam organizations list` or by visiting your organization's **Settings** page.
-     If only one organization owns the robot, you can omit the parameter.
-     If multiple organizations own the robot, you must specify the `org-id` explicitly.
-   - `key-name` is an optional name for your API key.
-     If omitted, a name will be auto-generated based on your login info and the current time.
-
-The command will return a `key id` and a `key value`.
-You will need both to authenticate.
-
-{{% alert title="Important" color="note" %}}
-Keep these key values safe.
-Authenticating using a machine part API key gives the authenticated CLI session full read and write access to your machine.
-{{% /alert %}}
-
-Once created, you can use the machine part API key to authenticate future CLI sessions or to [connect to your machine with the SDK](/dev/reference/sdks/).
-To switch to using a machine part API key for authentication right away, [logout](#logout) then log back in using `viam login api-key`.
-
-A location can have multiple API keys.
-
-## Manage your machines with the Viam CLI
-
-With the Viam CLI [installed](#install) and [authenticated](#authenticate), you can use it to issue commands to your machine fleet or manage custom modules.
-All Viam CLI commands use the following format:
+All commands use this format:
 
 ```sh {class="command-line" data-prompt="$"}
 viam [global options] command [command options] [arguments...]
 ```
 
-<!-- prettier-ignore -->
-| Parameter | Description |
-| --------- | ----------- |
-| [Global options](#global-options) | _optional_ - list of flags that apply for commands. |
-| [Command](#commands) | _required_ - the specific CLI command to run. |
-| Command options | _required for some commands_  - the operation to run for the specified command. |
-| Arguments | _required for some commands_ - the arguments for the specified command operation. Some commands take positional arguments, some named arguments. |
-
-See the list of [commands](#commands) below.
-
-### CLI help
-
-The Viam CLI has a built-in help system that lists all available commands.
-You can access it at any time by issuing the command:
-
-```sh {class="command-line" data-prompt="$"}
-viam --help
-```
-
-You can also access contextual help by passing the `--help` flag as a command option for any CLI command, for example:
-
-```sh {class="command-line" data-prompt="$"}
-viam organizations --help
-```
-
 ## Commands
 
 ### `data`
@@ -302,13 +29,16 @@ viam data export binary filter --destination=<output path> [...named args]
 viam data export binary ids --destination=<output path> [...named args]
 viam data export tabular --destination=<destination> --part-id=<part-id> --resource-name=<resource-name> --resource-subtype=<resource-subtype> --method=<method> [other options]
 viam data delete binary --org-ids=<org-ids> --start=<timestamp> --end=<timestamp> [...named args]
-viam data delete tabular --org-ids=<org-ids> --start=<timestamp> --end=<timestamp> [...named args]
+viam data delete tabular --org-id=<org-id> --delete-older-than-days=<N>
 viam data database configure --org-id=<org-id> --password=<db-user-password>
 viam data database hostname --org-id=<org-id>
 viam data tag ids add --tags=<tags> --binary-data-ids=<binary_ids>
 viam data tag ids remove --tags=<tags> --binary-data-ids=<binary_ids>
 viam data tag filter add --tags=<tags> [...named args from filter]
 viam data tag filter remove --tags=<tags> [...named args from filter]
+viam data index create --collection-type=<type> --index-path=<file> [--org-id=<org-id>] [--pipeline-name=<name>]
+viam data index delete --collection-type=<type> --index-name=<name> [--org-id=<org-id>] [--pipeline-name=<name>]
+viam data index list --collection-type=<type> [--org-id=<org-id>]
 ```
 
 Examples:
@@ -361,10 +91,13 @@ done
 | `export tabular` | Export tabular or sensor data to a specified location in the <file>.ndjson</file> output format. You can copy this from the UI with a filter. See [Copy `export` command](#copy-export-command). | - |
 | `export binary` | Export binary or image data to a specified location. Binary data will be downloaded in the original output it was specified as. You can copy this from the UI with a filter. See [Copy `export` command](#copy-export-command). | `ids`, `filter` |
 | `tag` | Add or remove tags from data matching the IDs or filter. | `ids`, `filter` |
-| `database configure` | Create a new database user for the Viam organization's MongoDB Atlas Data Federation instance, or change the password of an existing user. See [Configure data query](/data-ai/data/query/#configure-data-query). | - |
-| `database hostname` | Get the MongoDB Atlas Data Federation instance hostname and connection URI. See [Configure data query](/data-ai/data/query/#configure-data-query). | - |
+| `database configure` | Create a new database user for the Viam organization's MongoDB Atlas Data Federation instance, or change the password of an existing user. See [Configure data query](/data/query-data/). | - |
+| `database hostname` | Get the MongoDB Atlas Data Federation instance hostname and connection URI. See [Configure data query](/data/query-data/). | - |
 | `delete binary` | Delete binary data from the Viam Cloud. | - |
 | `delete tabular` | Delete tabular data from the Viam Cloud. | - |
+| `index create` | Create a custom index on a data collection. | - |
+| `index delete` | Delete a custom index from a data collection. | - |
+| `index list` | List all custom indexes for a data collection. | - |
 | `--help` | Return help | - |
 
 ##### Positional arguments: `tag`
@@ -372,8 +105,8 @@ done
 <!-- prettier-ignore -->
 | Argument | Description |
 | -------- | ----------- |
-| `filter` | `add` or `remove` images or tags from a dataset using a filter. See [Using the `filter` argument](#using-the-filter-argument).|
-| `ids` | `add` or `remove` images or tags from a dataset by specifying one or more binary data IDs as a comma-separated list. See [Using the `ids` argument](#using-the-ids-argument).|
+| `filter` | `add` or `remove` images or tags from a dataset using a filter. See [Using the `filter` argument](#using-the-filter-argument). |
+| `ids` | `add` or `remove` images or tags from a dataset by specifying one or more binary data IDs as a comma-separated list. See [Using the `ids` argument](#using-the-ids-argument). |
 | `--help` | Return help |
 
 ##### Named arguments
@@ -382,31 +115,34 @@ done
 | Argument | Description | Applicable commands | Required? |
 | -------- | ----------- | ------------------- | --------- |
 | `--destination` | Output directory for downloaded data. | `export tabular`, `export binary` | **Required** |
-| `--component-name` | Filter by specified component name. | `export binary`, `delete`, `tag filter`| Optional |
+| `--component-name` | Filter by specified component name. | `export binary`, `delete`, `tag filter` | Optional |
 | `--component-type` | Filter by specified component type. | `export binary`, `delete`, `tag filter` | Optional |
-| `--component-model` | Filter by specified component model. | `export`, `delete`| Optional |
-| `--delete-older-than-days` | Number of days, 0 means all data will be deleted. | `delete` | Optional |
-| `--timeout` | Number of seconds to wait for file downloads. Default: `30`. | `export binary` | Optional|
-| `--start` | ISO-8601 timestamp indicating the start of the interval. | `export binary`, `export tabular`, `delete`, `dataset`, `tag filter`| Optional |
-| `--end` | ISO-8601 timestamp indicating the end of the interval. | `export binary`, `export tabular`, `delete`, `dataset`, `tag filter`| Optional |
+| `--delete-older-than-days` | Number of days, 0 means all data will be deleted. | `delete tabular` | **Required** |
+| `--timeout` | Number of seconds to wait for file downloads. Default: `30`. | `export binary` | Optional |
+| `--start` | ISO-8601 timestamp indicating the start of the interval. | `export binary`, `export tabular`, `delete`, `dataset`, `tag filter` | Optional |
+| `--end` | ISO-8601 timestamp indicating the end of the interval. | `export binary`, `export tabular`, `delete`, `dataset`, `tag filter` | Optional |
 | `--binary-data-ids` | Binary data IDs to add or remove tags from. | `export binary ids`, `tag ids` | **Required** |
-| `--location-ids` | Filter by specified location ID (accepts comma-separated list). See [Using the `ids` argument](#using-the-ids-argument) for instructions on retrieving these values. | `export binary`, `delete`, `tag filter`| Optional |
-| `--method` | Filter by specified method. | `export binary`, `export tabular`, `delete`, `tag filter`| Optional |
-| `--mime-types` | Filter by specified MIME type (accepts comma-separated list). | `export binary`, `delete`, `tag filter`|false |
-| `--org-ids` | Filter by specified organizations ID (accepts comma-separated list). See [Using the `ids` argument](#using-the-ids-argument) for instructions on retrieving these values. | `export binary`, `delete`, `tag filter`| Optional |
-| `--parallel` | Number of download requests to make in parallel, with a default value of 10. | `export binary`, `delete`, `dataset export` | Optional |
-| `--part-id` | Filter by specified part ID. | `export binary`, `export tabular`, `delete`, `tag filter`| Optional, **Required** for `export tabular` |
-| `--part-name` | Filter by specified part name. | `export binary`, `delete`, `tag filter`| Optional |
+| `--location-ids` | Filter by specified location ID (accepts comma-separated list). See [Using the `ids` argument](#using-the-ids-argument) for instructions on retrieving these values. | `export binary`, `delete`, `tag filter` | Optional |
+| `--method` | Filter by specified method. | `export binary`, `export tabular`, `delete`, `tag filter` | Optional, **Required** for `export tabular` |
+| `--mime-types` | Filter by specified MIME type (accepts comma-separated list). | `export binary`, `delete`, `tag filter` | Optional |
+| `--org-ids` | Filter by specified organizations ID (accepts comma-separated list). See [Using the `ids` argument](#using-the-ids-argument) for instructions on retrieving these values. | `export binary`, `delete`, `tag filter` | Optional |
+| `--parallel` | Number of download requests to make in parallel. Default: `100`. | `export binary`, `delete`, `dataset export` | Optional |
+| `--part-id` | Filter by specified part ID. | `export binary`, `export tabular`, `delete`, `tag filter` | Optional, **Required** for `export tabular` |
+| `--part-name` | Filter by specified part name. | `export binary`, `delete`, `tag filter` | Optional |
 | `--machine-id` | Filter by specified machine ID. | `export binary`, `delete`, `tag filter` | Optional |
-| `--machine-name` | Filter by specified machine name. | `export binary`, `delete`, `tag filter`| Optional |
-| `--tags` | Filter by (`export`, `delete`) or add (`tag`) specified tag (accepts comma-separated list). |`export binary`, `delete`, `tag ids`, `tag filter` | Optional |
+| `--machine-name` | Filter by specified machine name. | `export binary`, `delete`, `tag filter` | Optional |
+| `--tags` | Filter by (`export`, `delete`) or add (`tag`) specified tag (accepts comma-separated list). | `export binary`, `delete`, `tag ids`, `tag filter` | Optional |
 | `--filter-tags` | Filter tags. Options: `'tagged'`, `'untagged'`, or a comma-separated list of tags for all data matching any of the tags. | `tag filter` | Optional |
 | `--bbox-labels` | String labels corresponding to bounding boxes within images. | `tag filter`, `export binary` | Optional |
 | `--chunk-limit` | Maximum number of results per download request (tabular data only). | `tag filter` | Optional |
-| `--org-id` | The organization ID for the database user. | `database configure` | **Required** |
+| `--org-id` | The organization ID. Required for `delete tabular`. Uses default org if set for other commands. | `delete tabular`, `database configure`, `database hostname`, `index create`, `index delete`, `index list` | Optional, **Required** for `delete tabular` |
 | `--password` | Password for the database user being configured. | `database configure` | **Required** |
 | `--resource-name` | Resource name. Sometimes called "component name". | `export tabular` | **Required** |
 | `--resource-subtype` | Resource {{< glossary_tooltip term_id="api-namespace-triplet" text="API namespace triplet" >}}. | `export tabular` | **Required** |
+| `--collection-type` | Data collection type for index operations. Options: `hot-storage`, `pipeline-sink`. | `index create`, `index delete`, `index list` | **Required** |
+| `--index-path` | Path to a JSON file defining the index using MongoDB index specification format. | `index create` | **Required** |
+| `--index-name` | Name of the index to delete. | `index delete` | **Required** |
+| `--pipeline-name` | Name of the data pipeline (required when `--collection-type` is `pipeline-sink`). | `index create`, `index delete` | Conditional |
 
 ### `datapipelines`
 
@@ -415,7 +151,7 @@ Data pipelines help you optimize query performance for frequently accessed compl
 
 ```sh {class="command-line" data-prompt="$"}
 viam datapipelines create --org-id=<org-id> --name=<name> --schedule=<schedule> --mql=<mql-query> --data-source-type=<type> --enable-backfill=False
-viam datapipelines update --id=<pipeline-id> --name=<name> --schedule=<schedule> --mql=<mql-query> [--data-source-type=<type>]
+viam datapipelines rename --id=<pipeline-id> --name=<new-name>
 viam datapipelines list --org-id=<org-id>
 viam datapipelines describe --id=<pipeline-id>
 ```
@@ -456,6 +192,7 @@ viam datapipelines delete --id=abc123
 | `enable` | Resume executing a disabled data pipeline. | - |
 | `disable` | Stop executing a data pipeline without deleting it. | - |
 | `list` | List all data pipelines in an organization. | - |
+| `rename` | Rename a data pipeline. | - |
 | `--help` | Return help. | - |
 
 ##### Named arguments
@@ -463,13 +200,13 @@ viam datapipelines delete --id=abc123
 <!-- prettier-ignore -->
 | Argument | Description | Applicable commands | Required? |
 | -------- | ----------- | ------------------- | --------- |
-| `--org-id` | ID of the organization that owns the data pipeline. | `create`, `list` | **Required** |
-| `--name` | Name of the data pipeline. | `create` | **Required** for `create` |
+| `--org-id` | ID of the organization that owns the data pipeline. Uses default org if set. | `create`, `list` | Optional |
+| `--name` | Name of the data pipeline. | `create`, `rename` | **Required** |
 | `--schedule` | Cron schedule that expresses when the pipeline should run, for example `0 9 * * *` for daily at 9 AM. | `create` | **Required** for `create` |
 | `--mql` | MQL (MongoDB Query Language) query as a JSON string for data processing. You must specify either `--mql` or `--mql-path` when creating a pipeline. | `create` | Optional |
 | `--mql-path` | Path to a JSON file containing the MQL query for the data pipeline. You must specify either `--mql` or `--mql-path` when creating a pipeline. | `create` | Optional |
-| `--data-source-type` | Data source type for the pipeline. Options: `standard` (default), `hotstorage`. `standard` provides typical analytics storage; `hotstorage` offers faster access for real-time processing. | `create` | **Required** for `create` |
-| `--id` | ID of the data pipeline to describe, or delete. | `enable`, `delete`, `describe`, `disable` | **Required** |
+| `--data-source-type` | Data source type for the pipeline. Options: `standard` (default), `hotstorage`. | `create` | Optional |
+| `--id` | ID of the data pipeline. | `enable`, `delete`, `describe`, `disable`, `rename` | **Required** |
 | `--enable-backfill` | Enable the data pipeline to run over organization's historical data. Default: `false`. | `create` | **Required** |
 
 ### `dataset`
@@ -543,8 +280,8 @@ viam dataset data remove ids --dataset-id=abc --binary-data-ids=aaa,bbb
 <!-- prettier-ignore -->
 | Argument | Description |
 | -------- | ----------- |
-| `filter` | `add` or `remove` images from a dataset using a filter. See [Using the `filter` argument)](#using-the-filter-argument).|
-| `ids` | `add` or `remove` images from a dataset by specifying one or more binary data IDs as a comma-separated list. See [Using the `ids` argument)](#using-the-ids-argument).|
+| `filter` | `add` or `remove` images from a dataset using a filter. See [Using the `filter` argument)](#using-the-filter-argument). |
+| `ids` | `add` or `remove` images from a dataset by specifying one or more binary data IDs as a comma-separated list. See [Using the `ids` argument)](#using-the-ids-argument). |
 | `--help` | Return help. |
 
 ##### Named arguments
@@ -557,7 +294,7 @@ viam dataset data remove ids --dataset-id=abc --binary-data-ids=aaa,bbb
 | `--destination` | Output directory for downloaded data. | `export` | **Required** |
 | `--end` | ISO-8601 timestamp indicating the end of the interval. | `data add`, `data remove` | Optional |
 | `--binary-data-ids` | The binary data IDs of the files to perform an operation on. | `data add ids`, `data remove ids` | **Required** |
-| `--include-jsonl` | Set to `true` to include JSON Lines files for local testing. |`export`| Optional |
+| `--include-jsonl` | Set to `true` to include JSON Lines files for local testing. | `export` | Optional |
 | `--name` | The name of the dataset to create or rename. | `create`, `rename` | **Required** |
 | `--org-id` | Organization ID of the organization the dataset belongs to. | `create`, `data add`, `list` | **Required** |
 | `--org-ids` | Organization IDs of the organizations to filter data on. | `data add filter`, `data remove filter` | Optional |
@@ -632,11 +369,11 @@ Removing the `viam data export` string, you can use the same filter parameters (
 
 You cannot use the `--binary-data-ids` argument when using `filter`.
 
-See [Create a dataset](/data-ai/train/create-dataset/) for more information.
+See [Create a dataset](/train/create-a-dataset/) for more information.
 
 ### `infer`
 
-The `infer` command enables you to run [cloud inference](/data-ai/ai/run-inference/#cloud-inference) on data. Cloud inference runs in the cloud, instead of on a local machine.
+The `infer` command enables you to run [cloud inference](/vision/configure/) on data. Cloud inference runs in the cloud, instead of on a local machine.
 
 ```sh {class="command-line" data-prompt="$" data-output="2-18"}
 viam infer --binary-data-id <binary-data-id> --model-name <model-name> --model-org-id <org-id-that-owns-model> --model-version "2025-04-14T16-38-25" --org-id <org-id-that-executes-inference>
@@ -664,15 +401,15 @@ Bounding Box Format: [x_min, y_min, x_max, y_max]
 <!-- prettier-ignore -->
 | Argument | Description | Required? |
 | -------- | ----------- | --------- |
-| `--binary-data-id` | The binary data ID of the image you want to run inference on.  | **Required** |
+| `--binary-data-id` | The binary data ID of the image you want to run inference on. | **Required** |
 | `--model-name` | The name of the model that you want to run in the cloud. | **Required** |
 | `--model-version` | The version of the model that you want to run in the cloud. To find the latest version string for a model, visit the [registry page](https://app.viam.com/registry?type=ML+Model) for that model. You can find the latest version string in the **Version history** section, for instance "2024-02-16T12-55-32". Pass this value as a string, using double quotes. | **Required** |
-| `--org-id` | The organization ID of the organization that will run the inference.  | **Required** |
+| `--org-id` | The organization ID of the organization that will run the inference. | **Required** |
 | `--model-org-id` | The organization ID of the organization that owns the model. | **Required** |
 
 ### `locations`
 
-The `locations` command allows you to manage the [locations](/manage/reference/organize/) that you have access to.
+The `locations` command allows you to manage the [locations](/reference/) that you have access to.
 With it, you can list available locations, filter locations by organization, or create a new location API key.
 
 ```sh {class="command-line" data-prompt="$"}
@@ -717,7 +454,7 @@ viam login print-access-token
 ```
 
 Use `viam login` to authenticate using a personal access token, or `viam login api-key` to authenticate using an API key.
-See [Authenticate](#authenticate).
+See [Authenticate](/cli/overview/#authenticate).
 
 #### Command options
 
@@ -853,7 +590,7 @@ viam machines part get-ftdc --part=123 ~/some/existing/dir/
 | `api-key` | Work with an API key for your machine. | `create` (see [positional arguments: api-key](#positional-arguments-api-key)) |
 | `status` | Retrieve machine status for a specified machine. | - |
 | `logs` | Retrieve logs for a specified machine. | - |
-| `part` | Manage a specified machine part. | `list`, `status`, `run`, `logs`, `shell`, `restart`, `tunnel`, `get-ftdc`, `cp` (see [positional arguments: part](#positional-arguments-part)). To use the `part shell` and `part cp` commands, you must add the [ViamShellDanger fragment](https://app.viam.com/fragment/b511adfa-80ab-4a70-9bd5-fbb14696b17e/json). The `ViamShellDanger` fragment contains the latest version of the shell service, which you must add to your machine before copying files or using the shell. Once downloaded you can use the `viam parse-ftdc` command to inspect the data. |
+| `part` | Manage a specified machine part. | `list`, `status`, `run`, `logs`, `shell`, `restart`, `tunnel`, `get-ftdc`, `cp`, `create`, `delete`, `add-resource`, `remove-resource`, `fragments`, `motion` (see [positional arguments: part](#positional-arguments-part)). To use `part shell` and `part cp`, add the [ViamShellDanger fragment](https://app.viam.com/fragment/b511adfa-80ab-4a70-9bd5-fbb14696b17e/json). |
 | `--help` | Return help. | - |
 
 ##### Positional arguments: `api-key`
@@ -876,8 +613,18 @@ viam machines part get-ftdc --part=123 ~/some/existing/dir/
 | `shell` | Access a machine part securely using a secure shell to execute commands. To use this feature you must add the [`ViamShellDanger` fragment](https://app.viam.com/fragment/b511adfa-80ab-4a70-9bd5-fbb14696b17e/json). The `ViamShellDanger` fragment contains the latest version of the shell service, which you must add to your machine before copying files or using the shell. |
 | `restart` | Restart a machine part. |
 | `cp` | Copy files to and from a machine part. To use this feature you must add the [`ViamShellDanger` fragment](https://app.viam.com/fragment/b511adfa-80ab-4a70-9bd5-fbb14696b17e/json), which contains the shell service, to your machine. Once added you can use `cp` in a similar way to the Linux `scp` command to copy files to and from machines. |
-| `tunnel` | Tunnel connections to a specified port on a machine part. You must explicitly enumerate ports to which you are allowed to tunnel in your machine's JSON config. See [Tunnel to a machine part](/manage/fleet/system-settings/#configure-network-settings-for-tunneling). |
-| `get-ftdc` |  Download FTDC data from a machine part. To use this feature you must add the [`ViamShellDanger` fragment](https://app.viam.com/fragment/b511adfa-80ab-4a70-9bd5-fbb14696b17e/json). The `ViamShellDanger` fragment contains the latest version of the shell service, which you must add to your machine before copying files or using the shell. <br> Organization and location are required flags if using name (rather than ID) for the part. <br> If [target] is not specified then the FTDC data will be saved to the current working directory. <br> Note: There is no progress meter while copying is in progress.|
+| `tunnel` | Tunnel connections to a specified port on a machine part. You must explicitly enumerate ports to which you are allowed to tunnel in your machine's JSON config. See [Tunnel to a machine part](/fleet/system-settings/). |
+| `get-ftdc` | Download FTDC data from a machine part. Requires the shell service. |
+| `create` | Create a new part on a machine. |
+| `delete` | Delete a part. |
+| `add-resource` | Add a component or service to a part's configuration by specifying an API and model triplet. |
+| `remove-resource` | Remove a resource from a part's configuration. |
+| `fragments add` | Attach a configuration fragment to a part. |
+| `fragments remove` | Detach a configuration fragment from a part. |
+| `motion print-config` | Print the motion planning configuration for the part. |
+| `motion print-status` | Print current motion state for the part. |
+| `motion get-pose` | Get the pose of a component in a reference frame. |
+| `motion set-pose` | Command a component to move to a specific pose. |
 | `--help` | Return help. |
 
 ##### Named arguments
@@ -887,8 +634,10 @@ viam machines part get-ftdc --part=123 ~/some/existing/dir/
 | -------- | ----------- | ------------------- | --------- |
 | `--part` | Part ID for which the command is being issued. | `part` | **Required** |
 | `--machine` | Machine ID or name for which the command is being issued. If machine name is used instead of ID, `--organization` and `--location` are required. | `update`, `delete`, `status`, `logs` | **Required** |
-| `--name` | Name for the machine. | `create`, `update` | **Required** for `create`, Optional for `update` |
-| `--location` | ID of the location that the machine belongs to or to list machines in. For `create`, this is the location where the new machine will be created. For `update`, this moves the machine to a new location. | `create`, `update`, `delete`, `list`, `status`, `logs`, `part` | **Required** for `create`, Optional for others |
+| `--name` | Name for the machine. | `create`, `part add-resource`, `part remove-resource` | **Required** for `create`, `part add-resource`, `part remove-resource` |
+| `--new-name` | New name for the machine when renaming. | `update` | Optional |
+| `--location` | ID of the location that the machine belongs to or to list machines in. | `create`, `delete`, `list`, `status`, `logs`, `part` | **Required** for `create`, Optional for others |
+| `--new-location` | ID of the location to move the machine to. | `update` | Optional |
 | `--organization` | ID of the organization that the machine belongs to or to list machines in. | `delete`, `list`, `status`, `logs`, `part` | Optional |
 | `--all` | List all machines in the organization. Overrides `--location` flag. Default: `false` | `list` | Optional |
 | `--errors` | Boolean, return only errors (default: false). | `logs` | Optional |
@@ -908,6 +657,10 @@ viam machines part get-ftdc --part=123 ~/some/existing/dir/
 | `--preserve`, `-p` | Preserve modification times and file mode bits from the source files. Default: `false`. | `part cp` | Optional |
 | `--destination-port` | The port on a machine part to tunnel to. | `part tunnel` | **Required** |
 | `--local-port` | The local port from which to tunnel. | `part tunnel` | **Required** |
+| `--part-name` | Name for the new part. | `part create` | **Required** |
+| `--model-name` | Model triplet (`namespace:type:model`) for the resource to add. | `part add-resource` | **Required** |
+| `--fragment` | Fragment ID to add or remove. If omitted for `add`, the CLI prompts interactively. | `part fragments add`, `part fragments remove` | Optional |
+| `--component` | Component name for motion commands. | `part motion get-pose`, `part motion set-pose` | **Required** |
 
 ##### Using the `--stream` and `--data` arguments
 
@@ -975,10 +728,10 @@ This includes:
 - Building a module locally and running it on a target device. Rebuilding & restarting if already running.
 - Downloading a module package from the registry
 
-See [Update and manage modules you created](/operate/modules/advanced/manage-modules/) for more information.
+See [Update and manage modules you created](/build-modules/manage-modules/) for more information.
 
 If you update and release your module as part of a continuous integration (CI) workflow, you can also
-[automatically upload new versions of your module on release](/operate/modules/advanced/manage-modules/#update-automatically-from-a-github-repo-with-cloud-build) using a GitHub Action.
+[automatically upload new versions of your module on release](/build-modules/manage-modules/) using a GitHub Action.
 
 ```sh {class="command-line" data-prompt="$"}
 viam module generate
@@ -1098,14 +851,14 @@ viam module local-app-testing --app-url http://localhost:3000
 | -------------- | ----------- | -------------------- |
 | `generate` | Generate a new module with stub files and a <file>meta.json</file> file. Recommended when starting a new module. | - |
 | `create` | Generate a <file>meta.json</file> file and register the metadata with the Viam registry. Recommended when you already have working module code. | - |
-| `update` | Update your module's metadata and documentation in the Viam registry. Updates are based on changes to [<file>meta.json</file>](/operate/modules/advanced/metajson/), the module <file>README.md</file>, and the model readme <FILE>namespace_module_model.md</FILE>. Viam automatically runs `update` when you `upload` your module, as well as when you trigger a cloud build with Viam's default build action. | - |
+| `update` | Update your module's metadata and documentation in the Viam registry. Updates are based on changes to [<file>meta.json</file>](/build-modules/module-reference/), the module <file>README.md</file>, and the model readme <FILE>namespace_module_model.md</FILE>. Viam automatically runs `update` when you `upload` your module, as well as when you trigger a cloud build with Viam's default build action. | - |
 | `update-models` | Update the module's metadata file with the models it provides. | - |
 | `upload` | Validate and upload a new or existing custom module on your local filesystem to the Viam Registry. See [Upload validation](#upload-validation) for more information. | **module-path** : specify the path to the file, directory, or compressed archive (with `.tar.gz` or `.tgz` extension) that contains your custom module code. |
-| `reload` | Build a module in the cloud and run it on a target marchine. Rebuild and restart if it is already running. The module is loaded to <FILE>~/.viam/packages-local/namespace_module-name_from_reload-module.tar.gz</FILE> on the target machine. | - |
+| `reload` | Build a module in the cloud and configure the target machine to download it directly. Rebuild and restart if the module is already running. | - |
 | `reload-local` | Build a module locally and run it on a target machine. Rebuild and restart if it is already running. The module is loaded to <FILE>~/.viam/packages-local/namespace_module-name_from_reload-module.tar.gz</FILE> on the target machine. | - |
 | `restart` | Restart a running module. | - |
-| `build start` | Start a module build in a cloud runner using the build step in your [`meta.json` file](/operate/modules/advanced/metajson/). See [Using the `build` subcommand](#using-the-build-subcommand). | - |
-| `build local` | Start a module build locally using the build step in your [`meta.json` file](/operate/modules/advanced/metajson/). See [Using the `build` subcommand](#using-the-build-subcommand). | - |
+| `build start` | Start a module build in a cloud runner using the build step in your [`meta.json` file](/build-modules/module-reference/). See [Using the `build` subcommand](#using-the-build-subcommand). | - |
+| `build local` | Start a module build locally using the build step in your [`meta.json` file](/build-modules/module-reference/). See [Using the `build` subcommand](#using-the-build-subcommand). | - |
 | `build list` | List the status of your cloud module builds. See [Using the `build` subcommand](#using-the-build-subcommand). | - |
 | `build logs` | Show the logs from a specific cloud module build. See [Using the `build` subcommand](#using-the-build-subcommand). | - |
 | `download` | Download a module package from the registry. | - |
@@ -1122,19 +875,19 @@ viam module local-app-testing --app-url http://localhost:3000
 | `--cloud-config` | The location of the <FILE>viam.json</FILE> file which contains the machine ID to lookup the part-id. Alternative to `--part-id`. Default: `/etc/viam.json` | `reload`, `reload-local`, `restart` | Optional |
 | `--destination` | Output directory for downloaded package (default: `.`) | `download` | Optional |
 | `--force` | Skip local validation of the packaged module, which may result in an unusable module if the contents of the packaged module are not correct. | `upload` | Optional |
-| `--home` | Specify home directory for a remote machine where `$HOME` is not the default `/root`. | `reload`, `reload-local` | Optional |
+| `--home` | Specify home directory for a remote machine where `$HOME` is not the default `/root`. | `reload-local` | Optional |
 | `--id` | For `build`, the build ID to list or show logs for, as returned from `build start`. For `reload`, `reload-local`, `restart`, and `download`, the module ID (`namespace:module-name` or `org-id:module-name`). | `build list`, `build logs`, `reload`, `reload`, `reload-local`, `restart`, `download` | Optional |
 | `--local` | Use if the target machine is localhost, to run the entrypoint directly rather than transferring a bundle. Default: `false`. | `reload`, `reload-local` | Optional |
-| `--module` | The path to the [`meta.json` file](/operate/modules/advanced/metajson/) for the module, if not in the current directory. | `update`, `upload`, `build`, `reload`, `reload-local` | Optional |
+| `--module` | The path to the [`meta.json` file](/build-modules/module-reference/) for the module, if not in the current directory. | `update`, `upload`, `build`, `reload`, `reload-local` | Optional |
 | `--model-name` | If passed, creates a resource in the part config with the given model triple. Use with `--resource-name`. Default: Creates no new resource. | `reload`, `reload-local` | Optional |
 | `--no-build` | Skip build step. Default: `false`. | `reload-local` | Optional |
-| `--no-progress` | Hide progress of the file transfer. Default: `false`. | `reload`, `reload-local` | Optional |
+| `--no-progress` | Hide progress of the file transfer. Default: `false`. | `reload-local` | Optional |
 | `--part-id` | Part ID of the machine part. Required if running on a remote device. | `reload`, `reload-local`, `restart` | Optional |
 | `--path` | The path to the root of the git repo to build. Default: `.` | `reload` | Optional |
 | `--resource-name` | If passed, creates a new resource with the given resource name. Use with `--model-name`. Default: Creates no new resource. | `reload`, `reload-local` | Optional |
 | `--resource-subtype` | The API to implement with the modular resource. For example, `motor`. We recommend _not_ using this option and instead following the prompts after running the command. | `generate` | Optional |
 | `--resource-type` | Whether the new resource is a component or a service. For example, `component`. We recommend _not_ using this option and instead following the prompts. | `generate` | Optional |
-| `--local-only` |  Create a meta.json file for local use, but don't create the module on the backend (default: `false`). | `create` | Optional |
+| `--local-only` | Create a meta.json file for local use, but don't create the module on the backend (default: `false`). | `create` | Optional |
 | `--name` | The name of the module. For example: `hello-world`. | `create`, `reload-local`, `restart` | Optional |
 | `--org-id` | The organization ID to associate the module to. See [Using the `--org-id` argument](#using-the---org-id-and---public-namespace-arguments). | `create`, `upload` | **Required** |
 | `--public-namespace` | The namespace to associate the module to. See [Using the `--public-namespace` argument](#using-the---org-id-and---public-namespace-arguments). | `create`, `upload` | **Required** |
@@ -1147,6 +900,7 @@ viam module local-app-testing --app-url http://localhost:3000
 | `--version` | The version of your module to set for this upload or download. For `download`, defaults to `latest`. See [Using the `--version` argument](#using-the---version-argument). | `upload`, `download` | **Required** for `upload` |
 | `--workdir` | Use this to indicate that your <file>meta.json</file> is in a subdirectory of your repo. `--module` flag should be relative to this. Default: `.` | `build start`, `reload`, `reload-local` | Optional |
 | `--wait` | Wait for the build to finish before outputting any logs. | `build logs` | Optional |
+| `--group-logs` | Group log output by platform. | `build logs` | Optional |
 | `--app-url` | The url where local app is running, including port number. For example `http://localhost:5000`. | `local-app-testing` | **Required** |
 | `--machine-id` | The machine ID of the machine you want to test with. You can get your machine ID on the [Fleet page](https://app.viam.com/fleet/machines). | `local-app-testing` | Optional |
 
@@ -1154,7 +908,7 @@ viam module local-app-testing --app-url http://localhost:3000
 
 All of the `module` commands accept either the `--org-id` or `--public-namespace` argument.
 
-- Use the `--public-namespace` argument to supply the [namespace of your organization](/operate/modules/advanced/metajson/#create-a-namespace-for-your-organization).
+- Use the `--public-namespace` argument to supply the [namespace of your organization](/build-modules/module-reference/).
   This will upload your module to the Viam Registry and share it with other users.
 - Use the `--org-id` to provide your organization ID instead, This will upload your module privately within your organization.
 
@@ -1174,13 +928,13 @@ The `--platform` argument accepts one of the following architectures:
 | `darwin/any` | macOS machines running any architecture. | Suitable for Python modules that also require macOS OS-level support (such as platform-specific dependencies). |
 | `linux/amd64` | Linux machines running the Intel `x86_64` architecture. | Suitable for most C++ or Go modules on Linux `amd64`. |
 | `linux/arm64` | Linux machines running the `arm64` (`aarch64`) architecture, such as the Raspberry Pi. | Suitable for most C++ or Go modules on Linux `arm64`. |
-| `linux/arm32v7`| Linux machines running the `arm32v7` architecture. | Suitable for most C++ or Go modules on Linux `arm32v7`. |
-| `linux/arm32v6`| Linux machines running the `arm32v6` architecture. | Suitable for most C++ or Go modules on `arm32v6`. |
+| `linux/arm32v7` | Linux machines running the `arm32v7` architecture. | Suitable for most C++ or Go modules on Linux `arm32v7`. |
+| `linux/arm32v6` | Linux machines running the `arm32v6` architecture. | Suitable for most C++ or Go modules on `arm32v6`. |
 | `darwin/amd64` | macOS machines running the Intel `x86_64` architecture. | Suitable for most C++ or Go modules on macOS `amd64`. |
 | `darwin/arm64` | macOS machines running the `arm64` architecture, such as Apple Silicon. | Suitable for most C++ or Go modules on macOS `arm64`. |
 | `windows/amd64` | Windows machines running the Intel `x86_64` architecture. | Suitable for most C++ or Go modules on Windows `amd64`. |
 
-For information on which of these platforms are supported for cloud build, see [Supported platforms for automatic updates](/operate/modules/advanced/manage-modules/#supported-platforms-for-automatic-updates).
+For information on which of these platforms are supported for cloud build, see [Supported platforms for automatic updates](/build-modules/manage-modules/).
 
 You can use the `uname -m` command on your computer or board to determine its system architecture.
 
@@ -1208,7 +962,7 @@ You can delete the distribution files for a version, but you must increment to a
 Once your module is uploaded, users can select which version of your module to use on their machine from your module's page on the Viam Registry.
 Users can choose to pin to a specific patch version, permit upgrades within major release families or only within minor releases, or permit continuous updates.
 
-When you `update` a module configuration and then `upload` it, the `entrypoint` for that module defined in the [`meta.json` file](/operate/modules/advanced/metajson/) is associated with the specific `--version` for that `upload`.
+When you `update` a module configuration and then `upload` it, the `entrypoint` for that module defined in the [`meta.json` file](/build-modules/module-reference/) is associated with the specific `--version` for that `upload`.
 Therefore, you are able to change the `entrypoint` file from version to version, if desired.
 
 ##### Upload validation
@@ -1217,11 +971,11 @@ When you `upload` a module, the command performs basic validation of your module
 The following criteria are checked for every `upload`:
 
 - The module must exist on the filesystem at the path provided to the `upload` command.
-- The entry point file specified in the [`meta.json` file](/operate/modules/advanced/metajson/) must exist on the filesystem at the path specified.
+- The entry point file specified in the [`meta.json` file](/build-modules/module-reference/) must exist on the filesystem at the path specified.
 - The entry point file must be executable.
 - If the module is provided to the `upload` command as a compressed archive, the archive must have the `.tar.gz` or `.tgz` extension.
 
-See [Create a module](/operate/modules/write-a-driver-module/) and [Update and manage modules you created](/operate/modules/advanced/manage-modules/) for a detailed walkthrough of the `viam module` commands.
+See [Create a module](/build-modules/write-a-driver-module/) and [Update and manage modules you created](/build-modules/manage-modules/) for a detailed walkthrough of the `viam module` commands.
 
 ##### Using the `build` subcommand
 
@@ -1230,7 +984,7 @@ You can use the `module build start` or `module build local` commands to build y
 - Use `build start` to build or compile your module on a cloud build host that might offer more platform support than you have access to locally.
 - Use `build local` to quickly test that your module builds or compiles as expected on your local hardware.
 
-To configure your module's build steps, add a `build` object to your [`meta.json` file](/operate/modules/advanced/metajson/) like the following:
+To configure your module's build steps, add a `build` object to your [`meta.json` file](/build-modules/module-reference/) like the following:
 
 <!-- Developers can either have a single build file for all platforms, or platform specific files: -->
 
@@ -1403,16 +1157,16 @@ The `organizations` command allows you to list the organizations your authentica
 ```sh {class="command-line" data-prompt="$"}
 viam organizations list
 viam organizations api-key create --org-id=<org-id> [--name=<key-name>]
-viam organizations support-email [get|set] --org-id=<org-id> --support-email=<support-email>
+viam organizations support-email [get | set] --org-id=<org-id> --support-email=<support-email>
 viam organizations logo set --org-id=<org-id> --logo-path=<logo-path>
-viam organization auth-service [enable|disable] --org-id=<org-id>
-viam organization auth-service oauth-app [create|update] --client-authentication [required|unspecified|not_required|not_required_when_using_pkce] \
-    --client-name <client-name> --enabled-grants [password|unspecified|refresh_token|implicit|device_code|authorization_code] \
+viam organization auth-service [enable | disable] --org-id=<org-id>
+viam organization auth-service oauth-app [create | update] --client-authentication [required | unspecified | not_required | not_required_when_using_pkce] \
+    --client-name <client-name> --enabled-grants [password | unspecified | refresh_token | implicit | device_code | authorization_code] \
     --logout-uri=https://logoipsum.com --origin-uris=https://logoipsum.com \
-    --pkce=[required|not_required|unspecified] --redirect-uris=https://logoipsum.com/callback \
-    --url-validation=[allow_wildcards|unspecified|exact_match] --org-id=<org-id>
+    --pkce=[required | not_required | unspecified] --redirect-uris=https://logoipsum.com/callback \
+    --url-validation=[allow_wildcards | unspecified | exact_match] --org-id=<org-id>
 viam organization auth-service oauth-app [list] --org-id=<org-id>
-viam organization auth-service oauth-app [read|delete] --org-id=<org-id> --client-id=<client-id>
+viam organization auth-service oauth-app [read | delete] --org-id=<org-id> --client-id=<client-id>
 ```
 
 Examples:
@@ -1425,14 +1179,14 @@ viam organizations list
 viam organizations api-key create --org-id=123 --name=my-key
 ```
 
-See [create an organization API key](#create-an-organization-api-key) for more information.
+See [Manage API keys](/cli/administer-your-organization/#manage-api-keys) for more information.
 
 #### Command options
 
 <!-- prettier-ignore -->
 | Command option | Description | Positional arguments |
 | -------------- | ----------- | -------------------- |
-| `list` | List all organizations (name, ID, and [namespace](/operate/modules/advanced/metajson/#create-a-namespace-for-your-organization)) that the authenticated session has access to. | - |
+| `list` | List all organizations (name, ID, and [namespace](/build-modules/module-reference/)) that the authenticated session has access to. | - |
 | `api-key create` | Create a new organization API key. | - |
 | `support-email get` | Get the support email for an organization. | - |
 | `support-email set` | Set the support email for an organization. | - |
@@ -1449,16 +1203,16 @@ See [create an organization API key](#create-an-organization-api-key) for more i
 | Argument | Description | Applicable commands | Required? |
 | -------- | ----------- | ------------------- | --------- |
 | `--org-id` | The organization to perform the command on. | `api-key`, `support-email get`, `support-email set`, `logo set`, `billing-service get-config`, `billing-service enable`, `billing-service update`, `billing-service disable`, `auth-service enable`, `auth-service disable`, `auth-service oauth-app create`, `auth-service oauth-app update` `auth-service oauth-app list`, `auth-service oauth-app read`, `auth-service oauth-app delete`. | **Required** |
-| `--name` | The optional name for the organization API key. If omitted, a name will be auto-generated based on your login info and the current time. |`api-key` | Optional |
+| `--name` | The optional name for the organization API key. If omitted, a name will be auto-generated based on your login info and the current time. | `api-key` | Optional |
 | `--support-email` | The support email to set for the organization. | `support-email get`, `support-email set` | **Required** |
 | `--logo-path` | The support email to set for the organization. | `logo set` | **Required** |
 | `--address` | The stringified billing address that follows the pattern: line1, line2 (optional), city, state, zipcode. | `billing-service enable`, `billing-service update` | **Required** |
 | `--client-id` | The client ID of the OAuth application. | `auth-service oauth-app read`, `auth-service oauth-app delete`, `auth-service oauth-app update` | **Required** |
 | `--client-authentication` | The client authentication policy for the OAuth application. Options: `unspecified`, `required`, `not_required`, `not_required_when_using_pkce`. Default: `unspecified`. | `auth-service oauth-app create`, `auth-service oauth-app update` | **Required** |
-| `--client-name` | The name for the OAuth application. | `auth-service oauth-app create`, `auth-service oauth-app update`| **Required** |
+| `--client-name` | The name for the OAuth application. | `auth-service oauth-app create`, `auth-service oauth-app update` | **Required** |
 | `--enabled-grants` | Comma-separated enabled grants for the OAuth application. Options: `unspecified`, `refresh_token`, `password`, `implicit`, `device_code`, `authorization_code`. | `auth-service oauth-app create`, `auth-service oauth-app update` | **Required** |
 | `--logout-uri` | The logout uri for the OAuth application. | `auth-service oauth-app create`, `auth-service oauth-app update` | **Required** |
-| `--org-id` |  The organization ID that is tied to the OAuth application. | `auth-service oauth-app create`, `auth-service oauth-app update` | **Required** |
+| `--org-id` | The organization ID that is tied to the OAuth application. | `auth-service oauth-app create`, `auth-service oauth-app update` | **Required** |
 | `--origin-uris` | Comma-separated origin URIs for the OAuth application. | `auth-service oauth-app create`, `auth-service oauth-app update` | **Required** |
 | `--pkce` | Proof Key for Code Exchange (PKCE) for the OAuth application. Options: `unspecified`, `required`, `not_required`, `not_required_when_using_client_authentication`. Default: `unspecified`. | `auth-service oauth-app create`, `auth-service oauth-app update` | **Required** |
 | `--redirect-uris` | Comma-separated redirect URIs for the OAuth application. | `auth-service oauth-app create`, `auth-service oauth-app update` | **Required** |
@@ -1505,7 +1259,8 @@ viam packages export --org-id=123 --name=MyMLModel --version=latest --type=ml_mo
 
 ### `parse-ftdc`
 
-The `parse-ftdc` command allows you to parse an FTDC file and open a REPL with extra options to inspect the data.
+The `parse-ftdc` command parses an FTDC (Full-Time Diagnostic Data Capture) file and opens an interactive REPL for inspecting performance metrics collected by `viam-server`.
+This is a diagnostic tool. Viam support may ask you to run it when troubleshooting performance issues.
 
 ```sh {class="command-line" data-prompt="$"}
 viam machines part get-ftdc --part=<part-id> ftdc-data
@@ -1556,7 +1311,7 @@ viam profiles remove --profile-name=mycompany
 viam --profile=mycompany machines list
 ```
 
-See [create an organization API key](#create-an-organization-api-key) for more information.
+See [Manage API keys](/cli/administer-your-organization/#manage-api-keys) for more information.
 
 {{% alert title="Tip" color="tip" %}}
 You can set a default profile by using the `VIAM_CLI_PROFILE_NAME` environment variable.
@@ -1584,7 +1339,7 @@ You can set a default profile by using the `VIAM_CLI_PROFILE_NAME` environment v
 
 ### `training-script`
 
-Manage training scripts for [custom ML training](/data-ai/train/train/).
+Manage training scripts for [custom ML training](/train/custom-training-scripts/).
 
 ```sh {class="command-line" data-prompt="$"}
 viam training-script upload --framework=<framework> --org-id=<org-id> --path=<path-to-script> --script-name=<script-name> --type=<type>
@@ -1637,6 +1392,7 @@ viam train get --job-id=<job-id>
 viam train logs --job-id=<job-id>
 viam train cancel --job-id=<job-id>
 viam train list --org-id=<org-id> --job-status=<job-status>
+viam train containers list
 ```
 
 Examples:
@@ -1674,6 +1430,7 @@ viam train list --org-id=123 --job-status=completed
 | `logs` | Gets the logs of a training job from the Viam Cloud based on training job ID. | - |
 | `cancel` | Cancels training job in the Viam Cloud based on training job ID. | - |
 | `list` | Lists training jobs in Viam Cloud based on organization ID and job status. | - |
+| `containers list` | Lists supported Docker container images for custom training. | - |
 
 ##### Positional arguments: `submit`
 
@@ -1701,21 +1458,39 @@ viam train list --org-id=123 --job-status=completed
 | `--org-id` | The organization ID to train and save the ML model in or list training jobs from. You can find your organization ID by running `viam organizations list` or by visiting your organization's **Settings** page in the [Viam app](https://app.viam.com/). | `submit custom from-registry`, `list` | **Required** |
 | `--model-name` | The name of the ML model. | `submit managed`, `submit custom from-registry`, `submit custom with-upload` | **Required** |
 | `--model-type` | Type of model to train. Can be one of `single_label_classification`, `multi_label_classification`, `object_detection`, or `unspecified`. | `submit managed`, `submit custom with-upload` | **Required**, Optional |
-| `--model-framework` | The framework of model to train. Options: `tflite`, `tensorflow` | `submit managed` | Optional |
+| `--model-framework` | The framework of model to train. Options: `tflite`, `tensorflow`, `pytorch`, `onnx`. | `submit managed` | **Required** |
 | `--model-labels` | Labels to train on. These will either be classification or object detection labels. | `submit managed` | **Required** |
-| `--model-version` | Set the version of the submitted model. Defaults to current timestamp if unspecified. | `submit managed`, `submit custom from-registry`, `submit custom with-upload` | **Required** |
+| `--model-version` | Set the version of the submitted model. Defaults to current timestamp if unspecified. | `submit managed`, `submit custom from-registry`, `submit custom with-upload` | Optional |
 | `--script-name` | The registry name of the ML training script to use for training. If uploading, this sets the name. | `submit custom from-registry`, `submit custom with-upload` | **Required** |
 | `--version` | The version of the ML training script to use for training. | `submit custom from-registry`, `submit custom with-upload` | **Required** |
 | `--path` | The path to the ML training script to upload. | `submit custom with-upload` | **Required** |
 | `--job-id` | The ID of the training job to get or cancel. You can retrieve this value with `train list`. | `get`, `logs`, `cancel` | **Required** |
-| `--job-status` | Training status to filter for. Can be one of `canceled`, `canceling`, `completed`, `failed`, `in_progress`, `pending`, or `unspecified`. | `list` | **Required** |
-| `--framework` | Framework of the ML training script to upload, can be `tflite`, `tensorflow`, `pytorch`, or `onnx`. | `submit custom with-upload` | Optional |
+| `--job-status` | Training status to filter for. Can be one of `canceled`, `canceling`, `completed`, `failed`, `in_progress`, `pending`, or `unspecified`. | `list` | Optional |
+| `--framework` | Framework of the ML training script to upload, can be `tflite`, `tensorflow`, `pytorch`, or `onnx`. | `submit custom with-upload` | **Required** |
+| `--container-version` | Docker container version for training. Use `viam train containers list` to see available versions. | `submit custom from-registry`, `submit custom with-upload` | **Required** |
 | `--args` | Pass custom comma-separated arguments to the training script. Example: `num_epochs=3,model_type=multi_label`. To include whitespace, enclose the value with whitespace in single and double quotes. Example: `num_epochs=3,labels="'green_square blue_star'"`. | `submit custom from-registry`, `submit custom with-upload` | Optional |
 
+### `update`
+
+The `update` command updates the CLI to the latest version.
+If the CLI was installed with Homebrew, it updates through Homebrew.
+Otherwise, it downloads and replaces the binary directly.
+
+```sh {class="command-line" data-prompt="$"}
+viam update
+```
+
+#### Named arguments
+
+<!-- prettier-ignore -->
+| Argument | Description | Required? |
+| -------- | ----------- | --------- |
+| `--no-progress` | Hide progress output during the update. Default: `false`. | Optional |
+
 ### `version`
 
 The `version` command returns the version of the Viam CLI.
-To update to the latest version of the CLI, run the [installation steps](#install) again to download and install the latest version.
+To update to the latest version of the CLI, run [`viam update`](#update).
 
 ```sh {class="command-line" data-prompt="$"}
 viam version
diff --git a/docs/data-ai/_index.md b/docs/data-ai/_index.md
deleted file mode 100644
index 07064b724e..0000000000
--- a/docs/data-ai/_index.md
+++ /dev/null
@@ -1,65 +0,0 @@
----
-linkTitle: "AI and Data"
-title: "Work with Data and AI"
-weight: 250
-layout: "docs"
-type: "docs"
-no_list: true
-noedit: true
-open_on_desktop: true
-overview: true
-notoc: true
-description: "Sync and store sensor data, images, and any other binary or timeseries data. Then use ML and AI to turn your data into insights and action."
----
-
-Viam's data and AI capabilities enable you to capture and sync or upload data, build a dataset, train and deploy ML models, and run inference with computer vision.
-Then, you can act or alert on inferences.
-You can also monitor your machines through teleop, power your application logic, or analyze historical data trends.
-
-<div class="img-overlay-wrap aligncenter">
-  <img src="../platform/platform-all.svg" alt="Platform diagram" id="fleet-platform-all" class="aligncenter overview" style="width:800px;height:auto">
-  <img src="../platform/platform-data-capture.svg" alt="Platform diagram with data capture elements highlighted" class="aligncenter overlay" id="data-platform-capture" style="width:800px;height:auto" loading="lazy" >
-  <img src="../platform/platform-data-work.svg" alt="Platform diagram with data usage elements highlighted" class="aligncenter overlay" id="data-platform-work" style="width:800px;height:auto" loading="lazy" >
-  <img src="../platform/platform-data-ai.svg" alt="Platform diagram with AI elements highlighted" class="aligncenter overlay" id="data-platform-ai" style="width:800px;height:auto" loading="lazy" >
-</div>
-
-<div class="hoveraction">
-
-{{< how-to-expand "Capture data" "4" "BEGINNER-FRIENDLY" "" "data-platform-capture" >}}
-{{< cards >}}
-{{% card link="/data-ai/capture-data/capture-sync/" noimage="true" %}}
-{{% card link="/data-ai/capture-data/upload-other-data/" noimage="true" %}}
-{{% card link="/data-ai/capture-data/filter-before-sync/" noimage="true" %}}
-{{% card link="/data-ai/capture-data/conditional-sync/" noimage="true" %}}
-{{% card link="/data-ai/capture-data/lorawan/" noimage="true" %}}
-{{< /cards >}}
-{{< /how-to-expand >}}
-
-{{< how-to-expand "Work with data" "4" "BEGINNER-FRIENDLY" "" "data-platform-work" >}}
-{{< cards >}}
-{{% card link="/data-ai/data/query/" noimage="true" %}}
-{{% card link="/data-ai/data/visualize/" noimage="true" %}}
-{{% card link="/data-ai/data/alert-data/" noimage="true" %}}
-{{% card link="/data-ai/data/export/" noimage="true" %}}
-{{< /cards >}}
-{{< /how-to-expand >}}
-
-{{< how-to-expand "Train an ML model" "5" "INTERMEDIATE" "" "data-platform-ai" >}}
-{{< cards >}}
-{{% card link="/data-ai/train/create-dataset/" noimage="true" %}}
-{{% card link="/data-ai/train/annotate-images/" noimage="true" %}}
-{{% card link="/data-ai/train/train-tf-tflite/" noimage="true" %}}
-{{% card link="/data-ai/train/train/" noimage="true" %}}
-{{< /cards >}}
-{{< /how-to-expand >}}
-
-{{< how-to-expand "Infer with ML models" "4" "INTERMEDIATE" "" "data-platform-ai" >}}
-{{< cards >}}
-{{% card link="/data-ai/ai/deploy/" noimage="true" %}}
-{{% card link="/data-ai/ai/run-inference/" noimage="true" %}}
-{{% card link="/data-ai/ai/alert/" noimage="true" %}}
-{{% card link="/data-ai/ai/act/" noimage="true" %}}
-{{< /cards >}}
-{{< /how-to-expand >}}
-
-</div>
diff --git a/docs/data-ai/ai/_index.md b/docs/data-ai/ai/_index.md
deleted file mode 100644
index 13387e9738..0000000000
--- a/docs/data-ai/ai/_index.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-linkTitle: "Infer with ML models"
-title: "Infer with ML models"
-weight: 300
-layout: "empty"
-type: "docs"
-empty_node: true
-open_on_desktop: true
-header_only: true
-canonical: "/data-ai/ai/deploy/"
----
diff --git a/docs/data-ai/ai/act.md b/docs/data-ai/ai/act.md
deleted file mode 100644
index 324066bbc1..0000000000
--- a/docs/data-ai/ai/act.md
+++ /dev/null
@@ -1,447 +0,0 @@
----
-linkTitle: "Act based on inferences"
-title: "Act based on inferences"
-weight: 70
-layout: "docs"
-type: "docs"
-description: "Use the vision service API to act based on inferences."
-date: "2025-10-09"
----
-
-You can use the [vision service API](/dev/reference/apis/services/vision/) to get information about your machine's inferences and program behavior based on that.
-
-This guide will walk you through the steps to create logic for acting based on inferences.
-At the end of each step, you'll learn how to apply the step to a fictional example where you want to stop an arm from moving, when a person is detected in the arm's surroundings.
-
-## Prerequisites
-
-{{% expand "A running machine connected to Viam." %}}
-
-{{% snippet "setup-both.md" %}}
-
-{{% /expand%}}
-
-{{< expand "A configured camera and vision service." >}}
-
-Follow the instructions to [configure a camera](/operate/reference/components/camera/) and [run inference](/data-ai/ai/run-inference/).
-
-{{< /expand >}}
-
-{{% expand "The Viam CLI." %}}
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Install the CLI.**
-
-You must have the Viam CLI installed to generate and upload modules:
-
-{{< readfile "/static/include/how-to/install-cli.md" >}}
-{{% /tablestep %}}
-{{% tablestep %}}
-**Log in with the CLI.**
-
-Run the following command to log in:
-
-```sh {class="command-line" data-prompt="$" data-output="2-10"}
-viam login
-```
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Find your organization ID.**
-
-Run the following command to list your organizations and their IDs:
-
-```sh {class="command-line" data-prompt="$" data-output="2-10"}
-viam organization list
-Organizations for "user@viam.com":
-    User's org (id: a12b3c4d-1234-123a-12a3-a1b23c45d67e)
-```
-
-{{% /tablestep %}}
-{{< /table >}}
-
-{{% /expand%}}
-
-## Create a module
-
-To program your machine's behavior based on the output of a vision service, create a resource that makes use of the vision service as input and controls the resources that should actuate based on the input.
-
-{{< table >}}
-
-{{% tablestep start=1 %}}
-**Generate the module template.**
-
-Replace `<ORGANIZATION-ID>` with your organization ID, which resembles: `a12b3c4d-1234-123a-12a3-a1b23c45d67e`.
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```sh {class="command-line" data-prompt="$" data-output="4-10"}
-viam module generate --language python --model-name intelligent-resource \
-  --name vision-intelligence --public-namespace <ORGANIZATION-ID> --public
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-You can use **any resource type**.
-The choice of resource type affects the API methods that you must implement.
-If you will use the vision service to change the behavior of one resource, choose that resource type.
-If none fits, use the vision service resource type and implement the logic in the `GetClassifications` or `GetDetections` methods.
-
-**Safe arm example**:
-For the use case of using a vision service to stop arm movement when a person is nearby, using the `arm` resource type makes sense.
-Essentially, the resource will wrap the existing arm component's API methods and check for people before moving.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Set up the imports for the resource.**
-
-The CLI generated several files, but you'll only need to modify the file in the <FILE>src/models/</FILE> folder, <FILE>intelligent-resource.py</FILE>, to implement your logic.
-
-Open <FILE>vision-intelligence/src/models/intelligent-resource.py</FILE>.
-This is the template for the resource API to which you will add logic.
-
-To use the vision service, you must import these Python packages:
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python {class="line-numbers linkable-line-numbers" }
-from typing import cast
-from viam.services.vision import *
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-You must also import packages for any other resources you wish to control.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Validate the resource's config.**
-
-Your resource needs to know the name of the vision service to get inferences from, as well as the camera name to use the vision service with.
-You also need to add configuration fields for any other resources you wish to access or control.
-
-The `validate_config` method parses the configuration for the resource and ensures it is valid.
-It also returns a list of required dependencies that informs `viam-server` to ensure this resource only starts once all dependencies are available.
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python {class="line-numbers linkable-line-numbers" data-start="55" }
-    @classmethod
-    def validate_config(
-        cls, config: ComponentConfig
-    ) -> Tuple[Sequence[str], Sequence[str]]:
-        req_deps = []
-        fields = config.attributes.fields
-        if "camera_name" not in fields:
-            raise Exception("missing required camera_name attribute")
-        elif not fields["camera_name"].HasField("string_value"):
-            raise Exception("camera_name must be a string")
-        camera_name = fields["camera_name"].string_value
-        if not camera_name:
-            raise ValueError("camera_name cannot be empty")
-        req_deps.append(camera_name)
-        if "vision_name" not in fields:
-            raise Exception("missing required vision_name attribute")
-        elif not fields["vision_name"].HasField("string_value"):
-            raise Exception("vision_name must be a string")
-        vision_name = fields["vision_name"].string_value
-        if not vision_name:
-            raise ValueError("vision_name cannot be empty")
-        req_deps.append(vision_name)
-        return req_deps, []
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-**Safe arm example**:
-For the safe arm example, you also need to get the name of the existing arm resource which this resource will wrap:
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python {class="line-numbers linkable-line-numbers" data-start="55" }
-    @classmethod
-    def validate_config(
-        cls, config: ComponentConfig
-    ) -> Tuple[Sequence[str], Sequence[str]]:
-        req_deps = []
-        fields = config.attributes.fields
-        # ...
-        if "arm_name" not in fields:
-            raise Exception("missing required arm_name attribute")
-        elif not fields["arm_name"].HasField("string_value"):
-            raise Exception("arm_name must be a string")
-        arm_name = fields["arm_name"].string_value
-        if not arm_name:
-            raise ValueError("arm_name cannot be empty")
-        req_deps.append(arm_name)
-        return req_deps, []
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Initialize all variables.**
-
-`viam-server` calls the `reconfigure` method whenever the module starts or a configuration change occurs.
-Use this method to initialize the vision service and camera name, as well as any other resources you plan to use.
-The dependencies parameter contains all the resources this component can access.
-By using `cast`, you tell Python the type of the resource.
-
-Update the `reconfigure` method to initialize all the variables:
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python {class="line-numbers linkable-line-numbers" data-start="79" }
-    def reconfigure(
-        self, config: ComponentConfig,
-        dependencies: Mapping[ResourceName, ResourceBase]
-    ):
-        camera_name = config.attributes.fields["camera_name"].string_value
-        vision_name = config.attributes.fields["vision_name"].string_value
-
-        # Get the full resource name for the vision service
-        # (rdk:service:vision/object-detector)
-        vision_resource_name = VisionClient.get_resource_name(vision_name)
-
-        # Check if the vision resource exists in dependencies
-        if vision_resource_name not in dependencies:
-            raise KeyError(f"Vision service '{vision_name}' not found in "
-                           f"dependencies. Available resources: "
-                           f"{list(dependencies.keys())}")
-
-        vision_resource = dependencies[vision_resource_name]
-        self.vision_service = cast(VisionClient, vision_resource)
-        self.camera_name = camera_name
-
-        return super().reconfigure(config, dependencies)
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-**Safe arm example**: For the safe arm example, you also need to initialize the arm:
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python {class="line-numbers linkable-line-numbers" data-start="79" }
-    def reconfigure(
-        self, config: ComponentConfig,
-        dependencies: Mapping[ResourceName, ResourceBase]
-    ):
-        # ...
-        arm_name = config.attributes.fields["arm_name"].string_value
-        arm_resource_name = Arm.get_resource_name(arm_name)
-
-        if arm_resource_name not in dependencies:
-            raise KeyError(f"Arm component '{arm_name}' not found in "
-                           f"dependencies. Available resources: "
-                           f"{list(dependencies.keys())}")
-
-        arm_resource = dependencies[arm_resource_name]
-        self.arm = cast(Arm, arm_resource)
-
-        return super().reconfigure(config, dependencies)
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Implement the API methods.**
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-In the <FILE>vision-intelligence/src/models/intelligent-resource.py</FILE> file, find the API methods that you wish to change and add the logic.
-
-Depending on if your vision service implements `GetDetections` or `GetClassifications`, use the relevant method and implement the logic.
-
-{{< tabs >}}
-{{% tab name="Detections" %}}
-
-```python
-detections = await self.vision_service.get_detections_from_camera(self.camera_name)
-for d in detections:
-    if d.confidence > 0.6 and d.class_name == "LABEL":
-        self.logger.info(f"Detection {d.class_name} with confidence {d.confidence}.")
-        # DO SOMETHING
-```
-
-{{% /tab %}}
-{{% tab name="Classifications" %}}
-
-```python
-classifications = await self.vision_service.get_classifications_from_camera(
-    self.camera_name,
-    4)
-for c in classifications:
-    if c.confidence > 0.6 and c.class_name == "LABEL":
-        self.logger.info(f"Classification {c.class_name} with confidence {c.confidence}.")
-        # DO SOMETHING
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-**Safe arm example**:
-The arm wrapper resource uses the vision service to check for people.
-If a person is detected, the resource raises an error, otherwise it passes the command to the arm.
-
-```python
-    async def _is_safe_to_move(self):
-        detections = await self.vision_service.get_detections_from_camera(self.camera_name)
-        for d in detections:
-            if d.confidence > 0.4 and d.class_name == "Person":
-                self.logger.warn(f"Detected {d.class_name} with confidence {d.confidence}.")
-                return False
-        self.logger.warn("No person detected. Safe arm will move.")
-        return True
-
-    async def move_to_position(
-        self,
-        pose: Pose,
-        *,
-        extra: Optional[Dict[str, Any]] = None,
-        timeout: Optional[float] = None,
-        **kwargs
-    ):
-        if await self._is_safe_to_move():
-            await self.arm.move_to_position(pose, extra=extra, timeout=timeout)
-        else:
-            raise ValueError("Person detected. Safe arm will not move.")
-
-    async def move_to_joint_positions(
-        self,
-        positions: JointPositions,
-        *,
-        extra: Optional[Dict[str, Any]] = None,
-        timeout: Optional[float] = None,
-        **kwargs
-    ):
-        if await self._is_safe_to_move():
-            await self.arm.move_to_joint_positions(positions, extra=extra, timeout=timeout)
-        else:
-            raise ValueError("Person detected. Safe arm will not move.")
-```
-
-All other methods pass the method call through to the `self.arm` resource.
-For example:
-
-```python
-    async def do_command(
-        self,
-        command: Mapping[str, ValueTypes],
-        *,
-        timeout: Optional[float] = None,
-        **kwargs
-    ) -> Mapping[str, ValueTypes]:
-        return await self.arm.do_command(command, timeout, **kwargs)
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /tablestep %}}
-{{< /table >}}
-
-## Test and use the module
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Configure your module as a local module.**
-
-The next step is to test the resource on your machine.
-
-Navigate to your machine's **CONFIGURE** page.
-Make sure your machine is showing as live and connected to Viam.
-
-Click the **+** button, select **Local module**, then select **Local module** again.
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-Enter the path to the <file>run.sh</file> file, for example, `/home/naomi/vision-intelligence/run.sh` on Linux or `/Users/naomi/vision-intelligence/run.sh` on macOS.
-Click **Create**.
-
-Save your config.
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Configure your resource as a local component or service.**
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-Click **+**, click **Local module**, then click **Local component** or **Local service** depending on your resource type and fill in the fields as follows:
-
-- model namespace triplet: `<namespace>:vision-intelligence:intelligence-resource`, you can see the full triplet in the module's <FILE>meta.json</FILE> file
-- type: `<resource-type>`
-- name: `resource-1`
-
-Configure the camera and vision service names by pasting the following in the configuration field and updating the names as needed:
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "camera_name": "camera-1",
-  "vision_name": "person-detector"
-}
-```
-
-Save the config.
-
-{{% /tab %}}
-{{< /tabs >}}
-
-Use the **TEST** panel to test the resource.
-
-If you are encountering errors, check the **LOGS** tab for more information.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Upload your module.**
-
-Commit and push your changes to a GitHub repository.
-
-Follow the steps to [upload your module](/operate/modules/deploy-a-module/#3-deploy-with-cloud-build-recommended) using cloud build.
-When you create a release, your module will be built, packaged, and pushed to the Viam Registry.
-
-If you are not using GitHub or cloud build, see [package and deploy](/operate/modules/deploy-a-module/) and [Update an existing module](/operate/modules/advanced/manage-modules/#update-automatically-from-a-github-repo-with-cloud-build) for more information on alternatives.
-
-Once uploaded, remove the local module and local resource, and add the resource from the registry.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Trigger the logic.**
-
-Depending on the logic you've implemented, you must now ensure the new methods get called.
-
-If your resource is a wrapper resource, make sure you update any references to the previous resource in components, services, triggers, and jobs that use the resource.
-
-If your logic works differently, you need to decide how this logic gets called, whether by another component or service or by a {{< glossary_tooltip term_id="job" text="job" >}}.
-
-**Safe arm example**:
-In the arm example, the arm is moved by a motion service.
-The motion service is currently configured to use the pre-existing arm.
-To change that, you'd update the component name in the motion service configuration.
-
-{{% /tablestep %}}
-{{< /table >}}
-
-## Examples
-
-To see a different example that uses a vision service to determine behavior and has the logic triggered with a {{< glossary_tooltip term_id="job" text="job" >}}, see the [Desk Safari Tutorial](/operate/hello-world/tutorial-desk-safari/).
diff --git a/docs/data-ai/ai/alert.md b/docs/data-ai/ai/alert.md
deleted file mode 100644
index 944263b536..0000000000
--- a/docs/data-ai/ai/alert.md
+++ /dev/null
@@ -1,221 +0,0 @@
----
-linkTitle: "Alert on inferences"
-title: "Alert on inferences"
-weight: 60
-layout: "docs"
-type: "docs"
-description: "Use machine learning and send alerts when an inference meets certain criteria."
-date: "2025-10-10"
----
-
-Triggers can send alerts in the form of email notifications or webhook requests when new data syncs to the cloud.
-
-This guide shows you how to set up an alert system that notifies you when specific objects or classifications are detected in your camera feed.
-The process involves three resources:
-
-1. **Filtered Camera**: Filters images passed to the data management service
-2. **Data Management**: Syncs filtered images to the cloud
-3. **Triggers**: Sends alerts when data syncs
-
-For example, a trigger could alert you when a camera feed detects an anomaly.
-
-### Prerequisites
-
-Before setting up alerts, you need:
-
-{{% expand "A running machine connected to Viam." %}}
-
-{{% snippet "setup-both.md" %}}
-
-{{% /expand %}}
-
-{{< expand "A configured camera and vision service." >}}
-
-You'll need a working vision service that can detect objects or classifications.
-The filtered camera will use this service to determine which images to capture.
-Follow the instructions to [configure a camera](/operate/reference/components/camera/) and [run inference](/data-ai/ai/run-inference/).
-
-{{< /expand >}}
-
-## Configure a filtered camera
-
-The [`filtered-camera`](https://app.viam.com/module/viam/filtered-camera) {{< glossary_tooltip term_id="module" text="module" >}} functions as a normal camera unless used with the data management service.
-When you configure the data management service to capture and sync images from the camera, the camera will only pass images to the data management service if they meet the defined criteria.
-The camera module takes a vision service and applies it to a camera feed using the generated predictions to filter the output for the data management service.
-
-Configure the filtered camera module to capture images when specific predictions occur:
-
-1. Navigate to your machine's **CONFIGURE** tab.
-
-1. Click the **+** (Create) button next to your main part in the left-hand menu and select **Component or service**.
-   Start typing `filtered-camera` and select **camera / filtered-camera** from the results.
-   Click **Add module**.
-
-1. Name your filtering camera something like `objectfilter-cam` and click **Create**.
-
-1. Paste a configuration into the attributes field:
-
-   {{< tabs >}}
-   {{% tab name="Template" %}}
-
-   Replace the `<camera_name>` and `<vision_service_name>` values with the names of your camera and vision service.
-
-   **Choose your detection type**:
-
-   - For **object detection** (bounding boxes around objects): Use the `objects` configuration with the label you want to alert on and remove `classifications`
-   - For **classification** (image-level labels): Use the `classifications` configuration with the label you want to alert on and remove `objects`
-
-   The confidence threshold (0.0-1.0) determines how certain the vision model must be before capturing photos.
-   For example, a confidence threshold of `0.6` only captures photos when the vision model is at least 60% sure that it has correctly identified the desired label.
-
-   ```json {class="line-numbers linkable-line-numbers"}
-   {
-     "camera": "<camera_name>",
-     "vision_services": [
-       {
-         "vision": "<vision_service_name>",
-         "classifications": { "<label>": 0.5 },
-         "objects": { "<label>": 0.5 }
-       }
-     ]
-   }
-   ```
-
-   {{% /tab %}}
-   {{% tab name="Example: Hard hat detection" %}}
-   For example, if using the YOLOv8 model (named `yolo`) for hard hat detection as demonstrated in the [Monitor Helmet Usage tutorial](/tutorials/projects/helmet/):
-
-   ```json {class="line-numbers linkable-line-numbers"}
-   {
-     "camera": "my_webcam",
-     "vision_services": [
-       {
-         "vision": "yolo",
-         "objects": {
-           "NO-Hardhat": 0.6
-         }
-       }
-     ]
-   }
-   ```
-
-   {{% /tab %}}
-   {{% /tabs %}}
-
-1. Click **Save** in the top right corner of the screen to save your changes.
-
-For more information, see the [`filtered-camera` module README](https://app.viam.com/module/viam/filtered-camera).
-
-{{% alert title="Tip" color="tip" %}}
-Viam provides a way to monitor detections, classifications, and confidence levels from a live vision service.
-To view this information, navigate to the vision service card and expand the **TEST** panel.
-You can use this to verify your confidence level configuration.
-{{% /alert %}}
-
-## Configure data capture and sync
-
-The [data management service](/data-ai/capture-data/capture-sync/#configure-data-capture-and-sync-for-individual-resources) captures data and syncs it to the Viam cloud.
-This step connects your filtered camera to the cloud so that detected images can trigger alerts.
-
-Configure data capture on the `filtered-camera` resource to capture images of detections or classifications:
-
-1. Add the data management service to your machine:
-
-   Navigate to your machine's **CONFIGURE** tab.
-
-   Click the **+** (Create) button next to your main part in the left-hand menu and select **Component or service**.
-   Enter "data" and select **data management**.
-   Name your data management service `data-manager` and click **Create**.
-
-   Leave all the default data service attributes as they are and click **Save** in the top right corner of the screen to save your changes.
-
-1. Enable data capture on your filtered camera:
-   Locate the `objectfilter-cam` panel.
-
-   Click **Add method**.
-   Click the **Type** dropdown and select **GetImages**.
-   Set the capture frequency to `0.2` images per second (equivalent to one image every 5 seconds).
-   You can adjust the frequency to suit your use case.
-
-## Configure a trigger on your machine
-
-Triggers send webhook requests or email notifications when certain events happen:
-
-- Your filtered camera captures an image when it detects the specified objects or classifications
-- The data management service syncs that image to the cloud
-- A trigger detects the sync event and sends your alert
-
-Since the filtered camera only captures images that meet the specified criteria, it only syncs images when a label is identified.
-Therefore, if you configure a filtered camera to capture images when an anomaly is detected, an image of the anomaly gets synced, a trigger fires, and an alert is sent.
-
-Follow these steps to configure a trigger to alert when `filtered-camera` syncs an image:
-
-1. Go to the **CONFIGURE** tab of your machine.
-   Click the **+** (Create) button in the left side menu and select **Trigger**.
-
-1. Enter a name and click **Create**.
-
-1. In the **Type** dropdown, select **Data has been synced to the cloud**.
-
-1. In the **Data Types** dropdown, select **Binary (image)**.
-
-   {{<imgproc src="/tutorials/helmet/trigger.png" resize="x600" style="width: 500px" declaredimensions=true alt="The trigger created with 'Data has been synced to the cloud' as the type and 'Binary (image)' as the data type." class="shadow imgzoom" >}}
-
-1. Add notification methods to the **Webhooks** or **Alert options** sub-panels:
-
-   To add an email notification for specific email addresses:
-
-   1. Toggle **Email specific addresses** on and add the email addresses you wish to be notified whenever this trigger fires.
-   1. Set the alert frequency.
-
-   To add an email notification for all machine owners:
-
-   1. Toggle **Email all machine owners** on.
-   1. Set the alert frequency.
-
-   To add a webhook notification:
-
-   1. Click **Add Webhook**.
-
-   1. Add the URL of your cloud function.
-   1. Write your cloud function to process the [webhook data](/data-ai/reference/triggers-configuration/#webhook-attributes).
-      Use your cloud function to process data or interact with external APIs, such as Twilio, PagerDuty, or Zapier.
-
-1. Configure the notification frequency (for example, maximum one alert per hour).
-
-1. Click **Save** in the top right corner of the screen to save your configuration.
-
-## Testing
-
-1. **Verify your setup**:
-
-   - Make sure `viam-server` is running on your machine
-   - Confirm your vision service is working by checking the **TEST** panel
-   - Ensure your filtered camera configuration matches your vision service's output labels
-
-2. **Test the detection**:
-
-   - Present the camera with an object or situation that should trigger the alert
-   - Watch the vision service **TEST** panel to confirm detections are occurring
-   - Check that the confidence levels meet your threshold
-
-3. **Monitor the data flow**:
-   - The data management service attempts to get an image from the filtered camera based on the configured capture interval
-   - Once the data management service captures an image, the image will sync when the next sync interval is reached
-   - At this point you will receive your email or webhook alert
-
-### Troubleshooting
-
-#### No alerts received?
-
-1. Check the **LOGS** tab
-1. Check that your vision service is detecting objects with sufficient confidence
-1. Verify your filtered camera configuration matches the vision service output
-1. Ensure the data management service is capturing images (check the data tab)
-1. Confirm your trigger configuration is correct
-
-#### Too many alerts?
-
-If you're getting too many false positives, increase your confidence threshold in the filtered camera configuration.
-
-If you receive too many alerts and want to limit them to once per hour maximum, adjust the notification frequency in your trigger settings.
diff --git a/docs/data-ai/ai/deploy.md b/docs/data-ai/ai/deploy.md
deleted file mode 100644
index 5f6e2ff6e9..0000000000
--- a/docs/data-ai/ai/deploy.md
+++ /dev/null
@@ -1,100 +0,0 @@
----
-linkTitle: "Deploy model"
-title: "Deploy a model"
-weight: 40
-layout: "docs"
-type: "docs"
-modulescript: true
-description: "The Machine Learning (ML) model service allows you to deploy machine learning models to your machine."
-aliases:
-  - /how-tos/train-deploy-ml/
-  - /services/ml/
-  - /registry/ml/
-  - /services/ml/upload-model/
-  - /services/ml/edit/
-  - /ml/edit/
-  - /manage/data/upload-model/
-  - /manage/ml/upload-model/
-  - /ml/upload-model/
-  - /services/ml/ml-models/
-  - /registry/ml-models/
-  - /manage/ml/
-  - /how-tos/train-deploy-ml/
-  - /ml/deploy/
-  - /ml/
-  - /services/ml/deploy/
-  - /how-tos/deploy-ml/
-  - /manage/data/deploy-model/
-date: "2025-10-09"
----
-
-Use a machine learning (ML) model service to deploy an ML model to your machine.
-
-## What is an ML model service?
-
-An ML model service is a Viam service that runs machine learning models on your machine. The service works with models trained on Viam or elsewhere, and supports various frameworks including TensorFlow Lite, ONNX, TensorFlow, and PyTorch.
-
-## Supported frameworks and hardware
-
-Viam currently supports the following frameworks:
-
-<!-- prettier-ignore -->
-| Model Framework | ML Model Service | Hardware Support | Description |
-| --------------- | --------------- | ------------------- | ----------- |
-| [TensorFlow Lite](https://www.tensorflow.org/lite) | [`tflite_cpu`](https://app.viam.com/module/viam/tflite_cpu) | linux/amd64, linux/arm64, darwin/arm64, darwin/amd64 | Quantized version of TensorFlow that has reduced compatibility for models but supports more hardware. Uploaded models must adhere to the [model requirements](https://app.viam.com/module/viam/tflite_cpu). |
-| [ONNX](https://onnx.ai/) | [`onnx-cpu`](https://app.viam.com/module/viam/onnx-cpu), [`triton`](https://app.viam.com/module/viam/mlmodelservice-triton-jetpack) |  Nvidia GPU, linux/amd64, linux/arm64, darwin/arm64 | Universal format that is not optimized for hardware-specific inference but runs on a wide variety of machines. |
-| [TensorFlow](https://www.tensorflow.org/) | [`tensorflow-cpu`](https://app.viam.com/module/viam/tensorflow-cpu), [`triton`](https://app.viam.com/module/viam/mlmodelservice-triton-jetpack) | Nvidia GPU, linux/amd64, linux/arm64, darwin/arm64 | A full framework designed for more production-ready systems. |
-| [PyTorch](https://pytorch.org/) | [`torch-cpu`](https://app.viam.com/module/viam/torch-cpu), [`triton`](https://app.viam.com/module/viam/mlmodelservice-triton-jetpack) | Nvidia GPU, linux/arm64, darwin/arm64 | A full framework that was built primarily for research. Because of this, it is much faster to do iterative development with (the model doesn't have to be predefined) but it is not as "production ready" as TensorFlow. It is the most common framework for open-source models because it is the go-to framework for ML researchers. |
-
-{{< alert title="Note" color="note" >}}
-For some ML model services, like the [Triton ML model service](https://github.com/viamrobotics/viam-mlmodelservice-triton/) for Jetson boards, you can configure the service to use either the available CPU or a dedicated GPU.
-{{< /alert >}}
-
-## Deploy your ML model
-
-1. Navigate to the **CONFIGURE** tab of one of your machines.
-2. Add an ML model service that supports the ML model you want to use.
-   - For example, use the `ML model / TFLite CPU` service for TFlite ML models that you trained with Viam's built-in training.
-3. Click **Select model** and select a model from your organization or the registry.
-4. Save your config.
-5. Use the **Test** panel to test your model.
-
-### Available ML model services
-
-{{<resources_svc api="rdk:service:mlmodel" type="ML model">}}
-
-## Available machine learning models
-
-You can use these publicly available machine learning models:
-
-{{<mlmodels>}}
-
-### Model sources
-
-The service works with models from various sources:
-
-- You can [train TensorFlow or TensorFlow Lite](/data-ai/train/train-tf-tflite/) or [other model frameworks](/data-ai/train/train/) on data from your machines.
-- You can use [ML models](https://app.viam.com/registry?type=ML+Model) from the [registry](https://app.viam.com/registry).
-- You can upload externally trained models from a model file on the [**MODELS** tab](https://app.viam.com/models).
-- You can use models trained outside the Viam platform whose files are on your machine.
-  See the documentation for the ML model service you're using (pick one that supports your model framework) for instructions on this.
-
-{{< alert title="Add support for other models" color="tip" >}}
-ML models must be designed in particular shapes to work with the `mlmodel` [classification](/operate/reference/services/vision/mlmodel/) or [detection](/operate/reference/services/vision/mlmodel/) models of Viam's [vision service](/operate/reference/services/vision/).
-See [ML Model Design](/data-ai/reference/mlmodel-design/) to design a modular ML model service with models that work with vision.
-{{< /alert >}}
-
-### Deploy a specific version of an ML model
-
-When you add a model to the ML model service in the app interface, it automatically uses the latest version.
-In the ML model service panel, you can change the version in the version dropdown.
-Save your config to use your specified version of the ML model.
-
-## Next steps
-
-On its own, the ML model service only runs the model.
-After deploying your model, you need to configure an additional service to use the deployed model.
-For example, you can configure an [`mlmodel` vision service](/operate/reference/services/vision/) to visualize the inferences your model makes.
-Follow our docs to [run inference](/data-ai/ai/run-inference/) to add an `mlmodel` vision service and see inferences.
-
-For other use cases, consider [creating custom functionality with a module](/operate/modules/write-a-driver-module/).
diff --git a/docs/data-ai/ai/run-inference.md b/docs/data-ai/ai/run-inference.md
deleted file mode 100644
index 458979c17f..0000000000
--- a/docs/data-ai/ai/run-inference.md
+++ /dev/null
@@ -1,168 +0,0 @@
----
-linkTitle: "Run inference"
-title: "Run inference"
-weight: 50
-layout: "docs"
-type: "docs"
-modulescript: true
-aliases:
-  - /how-tos/detect-people/
-  - /get-started/detect-people/
-  - /how-tos/detect-color/
-  - /services/vision/
-  - /ml/vision/detection/
-  - /ml/vision/classification/
-  - /ml/vision/segmentation/
-  - /ml/vision/
-  - /get-started/quickstarts/detect-people/
-description: "Run machine learning inference locally on your robot or remotely in the cloud using vision services, ML model services, or SDKs."
-date: "2025-09-12"
----
-
-Inference is the process of generating output from a machine learning (ML) model.
-
-You can run inference [locally on a Viam machine](#machine-inference), or [remotely in the Viam cloud](#cloud-inference).
-
-## Machine inference
-
-When you have [deployed an ML model](/data-ai/ai/deploy/) on your machine, you can run inference on your machine [directly with the ML model service](#using-an-ml-model-service-directly) or [using a vision service](#using-a-vision-service) that interprets the inferences.
-
-Entry-level devices such as the Raspberry Pi 4 can run small ML models, such as TensorFlow Lite (TFLite).
-More powerful hardware, including the Jetson Xavier or Raspberry Pi 5 with an AI HAT+, can process larger models, including TensorFlow and ONNX.
-If your hardware does not support the model you want to run, see [Cloud inference](#cloud-inference).
-
-### Using an ML model service directly
-
-{{< tabs >}}
-{{% tab name="Web UI" %}}
-
-1. Visit your machine's **CONFIGURE** or **CONTROL** page.
-1. Expand the **TEST** area of the ML model service panel to view the tensor output.
-
-{{< imgproc src="/tutorials/data-management/tensor-output.png" alt="Example tensor output" resize="x1000" class="shadow imgzoom fill" >}}
-
-{{% /tab %}}
-{{% tab name="Python" %}}
-
-The following code passes an image to an ML model service, and uses the [`Infer`](/dev/reference/apis/services/ml/#infer) method to make inferences:
-
-{{< read-code-snippet file="/static/include/examples-generated/run-inference.snippet.run-inference.py" lang="py" class="line-numbers linkable-line-numbers" data-line="82-85" >}}
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-The following code passes an image to an ML model service, and uses the [`Infer`](/dev/reference/apis/services/ml/#infer) method to make inferences:
-
-{{< read-code-snippet file="/static/include/examples-generated/run-inference.snippet.run-inference.go" lang="go" class="line-numbers linkable-line-numbers" data-line="161-164" >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-### Using a vision service
-
-There are a range of vision services that interpret images.
-Some vision services apply an ML model to a stream of images from a camera to:
-
-- detect objects (using bounding boxes)
-- classify (using tags)
-
-To use a vision service:
-
-1. Navigate to your machine's **CONFIGURE** page.
-1. Click the **+** icon next to your main machine part and select **Component or service**.
-1. Select a vision service.
-   For more information on the vision service, see its entry in the [Viam registry](https://app.viam.com/registry).
-1. Configure your vision service.
-   If your vision service does not include an ML model, you need to [deploy an ML model to your machine](/data-ai/ai/deploy/) and select it when configuring your vision service.
-
-{{% expand "Click to search available vision services" %}}
-
-{{<resources_svc api="rdk:service:vision" type="vision">}}
-
-{{% /expand%}}
-
-{{% expand "Click to view example vision services" %}}
-
-<!-- prettier-ignore -->
-| Example | Description |
-| ------- | ----------- |
-| Detect a variety of objects | Use the [`viam:vision:mlmodel`](/operate/reference/services/vision/mlmodel/) vision service with the `EfficientDet-COCO` ML model to detect a variety of objects, including people, bicycles, and apples, in a camera feed. |
-| Detect license plates | Use the [`viam-soleng:vision:openalpr`](https://app.viam.com/module/viam-soleng/viamalpr) vision service to detect license plates in images. This service includes its own ML model. |
-
-{{% /expand%}}
-
-{{< tabs >}}
-{{% tab name="Web UI" %}}
-
-1. Visit your machine's **CONFIGURE** or **CONTROL** page.
-1. Expand the **TEST** area of the vision service panel.
-
-   The feed shows an overlay of detected objects or classifications on top of a live camera feed.
-
-   {{< imgproc src="/tutorials/data-management/blue-star.png" alt="Detected blue star" resize="x200" class="shadow" >}}
-   {{< imgproc src="/tutorials/filtered-camera-module/viam-figure-preview.png" alt="Detection of a viam figure with a confidence score of 0.97" resize="x200" class="shadow" >}}
-
-{{% /tab %}}
-{{% tab name="Python" %}}
-
-The following code passes an image from a camera to a vision service and uses the [`GetClassifications`](/dev/reference/apis/services/vision/#getclassifications) method:
-
-{{< read-code-snippet file="/static/include/examples-generated/run-vision-service.snippet.run-vision-service.py" lang="py" class="line-numbers linkable-line-numbers" data-line="36-37" >}}
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-The following code passes an image from a camera to a vision service and uses the [`GetClassifications`](/dev/reference/apis/services/vision/#getclassifications) method:
-
-{{< read-code-snippet file="/static/include/examples-generated/run-vision-service.snippet.run-vision-service.go" lang="go" class="line-numbers linkable-line-numbers" data-line="62-65" >}}
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-The following code passes an image from a camera to a vision service and uses the [`GetClassifications`](/dev/reference/apis/services/vision/#getclassifications) method:
-
-{{< read-code-snippet file="/static/include/examples-generated/run-vision-service.snippet.run-vision-service.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="32-38" >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-## Cloud inference
-
-Cloud inference enables you to run machine learning models in the Viam cloud, instead of on a local machine.
-Cloud inference provides more computing power than edge devices, enabling you to run more computationally-intensive models or achieve faster inference times.
-
-You can run cloud inference using any TensorFlow and TensorFlow Lite model in the Viam registry, including unlisted models owned by or shared with you.
-
-To run cloud inference, you must pass the following:
-
-- the binary data ID and organization of the data you want to run inference on
-- the name, version, and organization of the model you want to use for inference
-
-You can obtain the binary data ID from the [**DATA** tab](https://app.viam.com/data/view) and the organization ID by running the CLI command `viam org list`.
-You can find the model information on the [**MODELS** tab](https://app.viam.com/models).
-
-```sh {class="command-line" data-prompt="$" data-output="2-18"}
-viam infer --binary-data-id <binary-data-id> --model-name <model-name> --model-org-id <org-id-that-owns-model> --model-version "2025-04-14T16-38-25" --org-id <org-id-that-executes-inference>
-Inference Response:
-Output Tensors:
-  Tensor Name: num_detections
-    Shape: [1]
-    Values: [1.0000]
-  Tensor Name: classes
-    Shape: [32 1]
-    Values: [...]
-  Tensor Name: boxes
-    Shape: [32 1 4]
-    Values: [...]
-  Tensor Name: confidence
-    Shape: [32 1]
-    Values: [...]
-Annotations:
-Bounding Box Format: [x_min, y_min, x_max, y_max]
-  No annotations.
-```
-
-The command returns a list of detected classes or bounding boxes depending on the output of the ML model you specified, as well as a list of confidence values for those classes or boxes.
-The bounding box output uses proportional coordinates between 0 and 1, with the origin `(0, 0)` in the top left of the image and `(1, 1)` in the bottom right.
-
-For more information, see [`viam infer`](/dev/tools/cli/#infer).
diff --git a/docs/data-ai/capture-data/_index.md b/docs/data-ai/capture-data/_index.md
deleted file mode 100644
index 83a00bef4d..0000000000
--- a/docs/data-ai/capture-data/_index.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-linkTitle: "Capture data"
-title: "Capture data"
-weight: 100
-layout: "empty"
-type: "docs"
-empty_node: true
-open_on_desktop: true
-header_only: true
-noedit: true
-canonical: "/data-ai/capture-data/capture-sync/"
----
diff --git a/docs/data-ai/capture-data/advanced/_index.md b/docs/data-ai/capture-data/advanced/_index.md
deleted file mode 100644
index 5f372a4c4f..0000000000
--- a/docs/data-ai/capture-data/advanced/_index.md
+++ /dev/null
@@ -1,9 +0,0 @@
----
-linkTitle: "Advanced"
-title: "Advanced"
-weight: 200
-layout: "empty"
-type: "docs"
-empty_node: true
-canonical: "/data-ai/capture-data/advanced/advanced-data-capture-sync/"
----
diff --git a/docs/data-ai/capture-data/advanced/advanced-data-capture-sync.md b/docs/data-ai/capture-data/advanced/advanced-data-capture-sync.md
deleted file mode 100644
index 0744bcf6cd..0000000000
--- a/docs/data-ai/capture-data/advanced/advanced-data-capture-sync.md
+++ /dev/null
@@ -1,679 +0,0 @@
----
-linkTitle: "Advanced data capture and sync configurations"
-title: "Advanced data capture and sync configurations"
-tags: ["data management", "data", "services"]
-weight: 10
-layout: "docs"
-type: "docs"
-platformarea: ["data"]
-description: "Advanced data capture and data sync configurations."
-date: "2025-02-10"
-updated: "2025-12-04"
----
-
-Some data use cases require advanced configuration beyond the attributes accessible in the UI.
-You can use raw JSON to configure additional attributes for both data management and data capture.
-You can also configure data capture for remote parts.
-
-## Cloud data retention
-
-Configure how long your synced data remains stored in the cloud:
-
-- **Retain data up to a certain size (for example, 100GB) or for a specific length of time (for example, 14 days):** Set `retention_policy` at the resource level.
-  See the `retention_policy` field in [data capture configuration attributes](/data-ai/capture-data/advanced/advanced-data-capture-sync/#click-to-view-data-capture-attributes).
-- **Delete data captured by a machine when you delete the machine:** Control whether your cloud data is deleted when a machine or machine part is removed.
-  See the `delete_data_on_part_deletion` field in the [data management service configuration attributes](/data-ai/capture-data/advanced/advanced-data-capture-sync/#click-to-view-data-management-attributes).
-
-## Sync optimization
-
-**Configurable sync threads:** You can control how many concurrent sync operations occur by adjusting the `maximum_num_sync_threads` setting.
-Higher values may improve throughput on more powerful hardware, but raising it too high may introduce instability on resource-constrained devices.
-
-**Wait time before syncing arbitrary files:** If you choose to sync arbitrary files (beyond those captured by the data management service), the `file_last_modified_millis` configuration attribute specifies how long a file must remain unmodified before the data manager considers it for syncing.
-The default is 10 seconds.
-
-## Advanced data management service configuration
-
-To configure the data manager in JSON, see the following example configurations:
-
-{{< tabs >}}
-{{% tab name="viam-server" %}}
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "components": [],
-  "services": [
-    {
-      "name": "my-data-manager",
-      "api": "rdk:service:data_manager",
-      "model": "rdk:builtin:builtin",
-      "attributes": {
-        "sync_interval_mins": 1,
-        "capture_dir": "",
-        "tags": [],
-        "capture_disabled": false,
-        "sync_disabled": true,
-        "delete_data_on_part_deletion": true,
-        "delete_every_nth_when_disk_full": 5,
-        "maximum_num_sync_threads": 250
-      }
-    }
-  ]
-}
-```
-
-{{% /tab %}}
-{{% tab name="viam-micro-server" %}}
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "components": [],
-  "services": [
-    {
-      "name": "my-data-manager",
-      "api": "rdk:service:data_manager",
-      "model": "rdk:builtin:builtin",
-      "attributes": {
-        "capture_dir": "",
-        "tags": [],
-        "additional_sync_paths": [],
-        "sync_interval_mins": 3
-      }
-    }
-  ]
-}
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-The following attributes are available for the data management service:
-
-{{< expand "Click to view data management attributes" >}}
-
-<!-- prettier-ignore -->
-| Name               | Type   | Required? | Description | `viam-micro-server` Support |
-| ------------------ | ------ | --------- | ----------- | ------------------- |
-| `capture_disabled` | bool   | Optional | Toggle data capture on or off for the entire machine {{< glossary_tooltip term_id="part" text="part" >}}. Note that even if capture is on for the whole part, if it is not on for any individual {{< glossary_tooltip term_id="component" text="component" >}}, data is not being captured. <br> Default: `false` | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| `capture_dir`      | string | Optional | Path to the directory on your machine where you want to store captured data. If you change the directory for data capture, only new data is stored in the new directory. Existing data remains in the directory where it was stored. <br> Default: `~/.viam/capture` | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| `tags` | array of strings | Optional | Tags to apply to all images or tabular data captured by this machine part. May include alphanumeric characters, underscores, and dashes. |  |
-| `sync_disabled` | bool | Optional | Toggle cloud sync on or off for the entire machine {{< glossary_tooltip term_id="part" text="part" >}}. <br> Default: `false` |  |
-| `additional_sync_paths` | string array | Optional | Paths to any other directories on your machine from which you want to sync data to the cloud. Once data is synced from a directory, it is automatically deleted from your machine. We recommend using absolute paths. For relative paths, see [How sync works](/data-ai/capture-data/advanced/how-sync-works/#cant-find-the-directory-data-is-stored-in-click-here). |  |
-| `sync_interval_mins` | float | Optional | Time interval in minutes between syncing to the cloud. Viam does not impose a minimum or maximum on the frequency of data syncing. However, in practice, your hardware or network speed may impose limits. <br> Default: `0.1`, meaning once every 6 seconds. |  <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| `selective_syncer_name` | string | Optional | The name for the sensor that should determine selective sync. Also add this sensor to the `depends_on` field. For more information, see [Configure the data manager to sync based on sensor](/data-ai/capture-data/conditional-sync/#configure-the-data-manager-to-sync-based-on-sensor). |  |
-| `delete_data_on_part_deletion` | bool | Optional | Whether deleting this {{< glossary_tooltip term_id="machine" text="machine" >}} or {{< glossary_tooltip term_id="part" text="machine part" >}} should result in deleting all the data captured by that machine part. <br> Default: `false` | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| `delete_every_nth_when_disk_full` | int | Optional | How many files to delete when local storage meets the [fullness criteria](/data-ai/capture-data/advanced/how-sync-works/#storage). The data management service will delete every Nth file that has been captured upon reaching this threshold. Use JSON mode to configure this attribute. <br> Default: `5`, meaning that every fifth captured file will be deleted. |   |
-| `maximum_num_sync_threads` | int | Optional | Max number of CPU threads to use for syncing data to the Viam Cloud. <br> Default: [runtime.NumCPU](https://pkg.go.dev/runtime#NumCPU)/2 so half the number of logical CPUs available to viam-server |   |
-| `mongo_capture_config.uri` | string | Optional | The [MongoDB URI](https://www.mongodb.com/docs/v6.2/reference/connection-string/) to which data capture will attempt to write tabular data after it is enqueued to be written to disk. When non-empty, data capture will write tabular data to the configured MongoDB database and collection at that URI.<br>See `mongo_capture_config.database` and `mongo_capture_config.collection` below for database and collection defaults.<br>See [Capture directly to your own MongoDB cluster](/data-ai/capture-data/advanced/advanced-data-capture-sync/#capture-directly-to-your-own-mongodb-cluster) for example configurations.|   |
-| `mongo_capture_config.database` | string | Optional | When `mongo_capture_config.uri` is non-empty, changes the database data capture will write tabular data to. <br> Default: `"sensorData"`   |   |
-| `mongo_capture_config.collection` | string | Optional | When `mongo_capture_config.uri` is non-empty, changes the collection data capture will write tabular data to.<br> Default: `"readings"`   |   |
-| `cache_size_kb` | float | Optional | `viam-micro-server` only. The maximum amount of storage (in kilobytes) allocated to a data collector. <br> Default: `1` KB. |  <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| `file_last_modified_millis` | float | Optional | The amount of time to pass since arbitrary files were last modified until they are synced. Normal <file>.capture</file> files are synced as soon as they are able to be synced. <br> Default: `10000` milliseconds. |   |
-| `disk_usage_deletion_threshold` | float | Optional | The disk usage ratio at or above which files will be deleted if the capture directory makes up at least the specified `capture_dir_deletion_threshold` of the disk usage. If disk usage is at or above the disk usage threshold, but the capture directory is below the capture directory threshold, then file deletion will not occur but a warning will be logged periodically. Default: `0.9`. |  |
-| `capture_dir_deletion_threshold` | float | Optional | The ratio of disk usage made up by the capture directory at or above which files will be deleted if the disk usage ratio is also above the `disk_usage_deletion_threshold`. If the ratio of disk usage of the capture directory is at or above the threshold but the disk usage is below the disk usage threshold, then file deletion will not occur but a warning will be logged periodically. Default: `0.5`. |   |
-
-{{< /expand >}}
-
-You can edit the JSON directly by switching to **JSON** mode in the UI.
-
-## Advanced data capture configuration
-
-{{< alert title="Caution" color="caution" >}}
-
-Avoid configuring data capture to higher rates than your hardware can handle, as this leads to performance degradation.
-
-{{< /alert >}}
-
-{{< tabs >}}
-{{% tab name="Part or sub-part" %}}
-
-{{< tabs >}}
-{{% tab name="viam-server" %}}
-
-This example configuration captures data from the `GetImages` method of a camera:
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "services": [
-    ...
-    ,
-    {
-      "name": "data_manager",
-      "api": "rdk:service:data_manager",
-      "model": "rdk:builtin:builtin",
-      "attributes": {
-        "sync_interval_mins": 5,
-        "capture_dir": "",
-        "sync_disabled": false,
-        "tags": []
-      }
-    }
-  ],
-  "remotes": [
-    {
-        ...
-    }
-  ],
-  "components": [
-        ...
-    ,
-    {
-      "service_configs": [
-        {
-          "type": "data_manager",
-          "attributes": {
-            "capture_methods": [
-              {
-                "capture_frequency_hz": 0.333,
-                "disabled": false,
-                "method": "GetImages",
-                "additional_params": {
-                  "reader_name": "cam1"
-                }
-              }
-            ],
-            "retention_policy": {
-              "days": 5
-            }
-          }
-        }
-      ],
-      "model": "webcam",
-      "name": "cam",
-      "api": "rdk:component:camera",
-      "attributes": {
-        "video_path": "video0"
-      },
-      "depends_on": [
-        "local"
-      ]
-    },
-    ...
-  ]
-}
-```
-
-{{% /tab %}}
-{{% tab name="viam-micro-server" %}}
-
-This example configuration captures data from the `Readings` method of a temperature sensor and wifi signal sensor:
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "services": [
-    {
-      "attributes": {
-        "capture_dir": "",
-        "tags": [],
-        "additional_sync_paths": [],
-        "sync_interval_mins": 3
-      },
-      "name": "dm",
-      "api": "rdk:service:data_manager",
-      "model": "rdk:builtin:builtin"
-    }
-  ],
-  "components": [
-    {
-      "api": "rdk:component:sensor",
-      "model": "tmp36",
-      "attributes": {
-        "analog_reader": "temp",
-        "num_readings": 15
-      },
-      "depends_on": [],
-      "service_configs": [
-        {
-          "attributes": {
-            "capture_methods": [
-              {
-                "capture_frequency_hz": 0.2,
-                "cache_size_kb": 10,
-                "additional_params": {},
-                "method": "Readings"
-              }
-            ]
-          },
-          "type": "data_manager"
-        }
-      ],
-      "name": "tmp36"
-    },
-    {
-      "api": "rdk:component:sensor",
-      "model": "wifi-rssi",
-      "attributes": {},
-      "service_configs": [
-        {
-          "type": "data_manager",
-          "attributes": {
-            "capture_methods": [
-              {
-                "additional_params": {},
-                "method": "Readings",
-                "capture_frequency_hz": 0.1,
-                "cache_size_kb": 10
-              }
-            ]
-          }
-        }
-      ],
-      "name": "my-wifi-sensor"
-    }
-  ]
-}
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-Example configuration for a vision service:
-
-This example configuration captures data from the `CaptureAllFromCamera` method of the vision service:
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "components": [
-    {
-      "name": "camera-1",
-      "api": "rdk:component:camera",
-      "model": "webcam",
-      "attributes": {}
-    }
-  ],
-  "services": [
-    {
-      "name": "vision-1",
-      "api": "rdk:service:vision",
-      "model": "mlmodel",
-      "attributes": {
-        "mlmodel_name": "my_mlmodel_service",
-        "camera_name": "camera-1"
-      },
-      "service_configs": [
-        {
-          "type": "data_manager",
-          "attributes": {
-            "capture_methods": [
-              {
-                "method": "CaptureAllFromCamera",
-                "capture_frequency_hz": 1,
-                "additional_params": {
-                  "mime_type": "image/jpeg",
-                  "camera_name": "camera-1",
-                  "min_confidence_score": "0.7"
-                }
-              }
-            ]
-          }
-        }
-      ]
-    },
-    {
-      "name": "data_manager-1",
-      "api": "rdk:service:data_manager",
-      "model": "rdk:builtin:builtin",
-      "attributes": {
-        "sync_interval_mins": 0.1,
-        "capture_dir": "",
-        "tags": [],
-        "additional_sync_paths": []
-      }
-    },
-    {
-      "name": "mlmodel-1",
-      "api": "rdk:service:mlmodel",
-      "model": "viam:mlmodel-tflite:tflite_cpu",
-      "attributes": {}
-    }
-  ],
-  "modules": [
-    {
-      "type": "registry",
-      "name": "viam_tflite_cpu",
-      "module_id": "viam:tflite_cpu",
-      "version": "0.0.3"
-    }
-  ]
-}
-```
-
-The following attributes are available for data capture configuration:
-
-{{< expand "Click to view data capture attributes" >}}
-
-<!-- prettier-ignore -->
-| Name               | Type   | Required? | Description |
-| ------------------ | ------ | --------- | ----------- |
-| `capture_frequency_hz` | float   | **Required** | Frequency in hertz at which to capture data. For example, to capture a reading every 2 seconds, enter `0.5`. |
-| `method` | string | **Required** | Depends on the type of component or service. See [Supported components and services](/data-ai/capture-data/capture-sync/#click-to-see-resources-that-support-data-capture-and-cloud-sync). **Note:** For tabular data, Viam enforces a maximum size of 4MB for any single reading. |
-| `retention_policy` | object | Optional | Option to configure how long data collected by this component or service should remain stored in the Viam Cloud. You must set this in JSON mode. See the JSON example for a camera component. <br> **Options:** `"days": <int>`, `"binary_limit_gb": <int>`, `"tabular_limit_gb": <int>`. <br> Days are in UTC time. Setting a retention policy of 1 day means that data stored now will be deleted the following day **in UTC time**. You can set either or both of the size limit options; size is in gigabytes. The `retention_policy` does not affect logs. For information about logs, see [Logging](/operate/reference/viam-server/#logging). |
-| `recent_data_store` | object | Optional | Configure a rolling time frame of recent data to store in a [hot data store](/data-ai/data/hot-data-store/) for faster access. Example: `{ "stored_hours": 24 }` |
-| `additional_params` | object | Optional | Varies based on the method. For example, `DoCommand` requires `docommand_input` with an object of the command object to pass to `DoCommand`, and `GetImages` can optionally intake a `filter_source_names` list of strings to indicate which source names to return images from. |
-| `disabled` | boolean | Optional | Whether data capture is disabled. |
-
-{{< /expand >}}
-
-You can edit the JSON directly by switching to **JSON** mode in the UI.
-
-{{% /tab %}}
-{{% tab name="Remote parts" %}}
-
-Viam supports data capture from {{< glossary_tooltip term_id="resource" text="resources" >}} on {{< glossary_tooltip term_id="remote-part" text="remote parts" >}}.
-For example, if you use a {{< glossary_tooltip term_id="part" text="part" >}} that does not have a Linux operating system or does not have enough storage or processing power to run `viam-server`, you can still process and capture the data from that part's resources by adding it as a remote part.
-
-Currently, you can only configure data capture from remote resources in your JSON configuration.
-To add them to your JSON configuration, you must explicitly add a `service_config` for the data manager in the `remote` object in the `remotes` array.
-The service config array must contain an object with `type: data_manager` and an `attributes` object with an array of `capture_methods`.
-Each capture method object contains the following fields:
-
-<!-- prettier-ignore -->
-| Key | Type | Description |
-| --- | ---- | ----------- |
-| `name` | string | The name specifies the fully qualified name of the part. Example: `"rdk:component:sensor/spacesensor"`. |
-| `additional_params` | Object | Varies based on the method. For example, `DoCommand` requires `docommand_input` with an object of the command object to pass to `DoCommand`, and `GetImages` can optionally intake a `filter_source_names` list of strings to indicate which source names to return images from. |
-| `disabled` | boolean | Whether data capture for the method is disabled. |
-| `method` | string | Depends on the type of component or service. See [Supported components and services](/data-ai/capture-data/capture-sync/#click-to-see-resources-that-support-data-capture-and-cloud-sync). **Note:** For tabular data, Viam enforces a maximum size of 4MB for any single reading. |
-| `capture_frequency_hz` | float | Frequency in hertz at which to capture data. For example, to capture a reading every 2 seconds, enter `0.5`. |
-| `cache_size_kb` | float | `viam-micro-server` only. The maximum amount of storage (in kilobytes) allocated to a data collector. <br> Default: `1` KB. |
-
-{{< expand "Click to view example JSON configuration for an ESP32 board that will be established as a remote part" >}}
-
-The following example shows the configuration of the part that we will establish as a remote, in this case an [ESP32 board](/operate/reference/components/board/esp32/).
-This config is just like that of a non-remote part; the remote connection is established by the main part (in the next expandable example).
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "components": [
-    {
-      "name": "my-esp32",
-      "model": "esp32",
-      "api": "rdk:component:board",
-      "attributes": {
-        "pins": [27],
-        "analogs": [
-          {
-            "pin": "34",
-            "name": "A1"
-          },
-          {
-            "pin": "35",
-            "name": "A2"
-          }
-        ]
-      },
-      "service_configs": [
-        {
-          "type": "data_manager",
-          "attributes": {
-            "capture_methods": [
-              {
-                "method": "Analogs",
-                "additional_params": {
-                  "reader_name": "A1"
-                },
-                "cache_size_kb": 10,
-                "capture_frequency_hz": 10
-              },
-              {
-                "method": "Analogs",
-                "additional_params": {
-                  "reader_name": "A2"
-                },
-                "cache_size_kb": 10,
-                "capture_frequency_hz": 10
-              }
-            ]
-          }
-        }
-      ]
-    }
-  ]
-}
-```
-
-{{< /expand >}}
-
-{{< expand "Click to view the JSON configuration for capturing data from two analog readers and a pin of the board's GPIO" >}}
-
-The following example of a configuration with a remote part captures data from two analog readers that provide a voltage reading and from pin 27 of the GPIO of the board that we configured in the previous example:
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "services": [
-    {
-      "name": "data_manager",
-      "api": "rdk:service:data_manager",
-      "model": "rdk:builtin:builtin",
-      "attributes": {
-        "capture_dir": "",
-        "sync_disabled": true,
-        "sync_interval_mins": 5,
-        "tags": ["tag1", "tag2"]
-      }
-    }
-  ],
-  "components": [],
-  "remotes": [
-    {
-      "name": "esp-home",
-      "address": "esp-home-main.33vvxnbbw9.viam.cloud:80",
-      "service_configs": [
-        {
-          "type": "data_manager",
-          "attributes": {
-            "capture_methods": [
-              // Captures data from two analog readers (A1 and A2)
-              {
-                "method": "Analogs",
-                "capture_frequency_hz": 1,
-                "cache_size_kb": 10,
-                "name": "rdk:component:board/my-esp32",
-                "additional_params": { "reader_name": "A1" },
-                "disabled": false
-              },
-              {
-                "method": "Analogs",
-                "capture_frequency_hz": 1,
-                "cache_size_kb": 10,
-                "name": "rdk:component:board/my-esp32",
-                "additional_params": { "reader_name": "A2" },
-                "disabled": false
-              },
-              // Captures data from pin 27 of the board's GPIO
-              {
-                "method": "Gpios",
-                "capture_frequency_hz": 1,
-                "cache_size_kb": 10,
-                "name": "rdk:component:board/my-esp32",
-                "additional_params": {
-                  "pin_name": "27"
-                },
-                "disabled": false
-              }
-            ]
-          }
-        }
-      ],
-      "secret": "REDACTED"
-    }
-  ]
-}
-```
-
-{{< /expand >}}
-
-{{< expand "Click to view the JSON configuration for capturing data from a camera" >}}
-
-The following example of a configuration with a remote part captures data from the `GetImages` method of a camera:
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "services": [
-    {
-      "name": "data_manager",
-      "api": "rdk:service:data_manager",
-      "model": "rdk:builtin:builtin",
-      "attributes": {
-        "capture_dir": "",
-        "sync_disabled": true,
-        "sync_interval_mins": 5,
-        "tags": []
-      }
-    }
-  ],
-  "components": [],
-  "remotes": [
-    {
-      "name": "pi-test-main",
-      "address": "pi-test-main.vw3iu72d8n.viam.cloud",
-      "service_configs": [
-        {
-          "type": "data_manager",
-          "attributes": {
-            "capture_methods": [
-              {
-                "capture_frequency_hz": 1,
-                "name": "rdk:component:camera/cam",
-                "disabled": false,
-                "method": "GetImages",
-                "additional_params": {
-                  "filter_source_names": ["color"],
-                  "reader_name": "cam1"
-                }
-              }
-            ]
-          }
-        }
-      ],
-      "secret": "REDACTED"
-    }
-  ]
-}
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{< /expand >}}
-
-## Capture directly to your own MongoDB cluster
-
-You can configure direct capture of tabular data to a MongoDB instance alongside disk storage on your edge device.
-This can be useful for powering real-time dashboards before data is synced from the edge to the cloud.
-The MongoDB instance can be a locally running instance or a cluster in the cloud.
-
-Configure using the `mongo_capture_config` attributes in your data manager service.
-You can configure data sync to a MongoDB instance separately from data sync to the Viam Cloud.
-
-{{< expand "Click to view sample configuration with MongoDB data store." >}}
-
-This sample configuration captures fake sensor readings both to the configured MongoDB URI as well as to the `~/.viam/capture` directory on disk.
-It does not sync the data to the Viam Cloud.
-
-```json
-{
-  "components": [
-    {
-      "name": "sensor-1",
-      "api": "rdk:component:sensor",
-      "model": "rdk:builtin:fake",
-      "attributes": {},
-      "service_configs": [
-        {
-          "type": "data_manager",
-          "attributes": {
-            "capture_methods": [
-              {
-                "method": "Readings",
-                "capture_frequency_hz": 0.5,
-                "additional_params": {}
-              }
-            ]
-          }
-        }
-      ]
-    }
-  ],
-  "services": [
-    {
-      "name": "data_manager-1",
-      "api": "rdk:service:data_manager",
-      "attributes": {
-        "mongo_capture_config": {
-          "uri": "mongodb://127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000"
-        }
-      }
-    }
-  ]
-}
-```
-
-{{< /expand >}}
-
-{{< expand "Click to view sample configuration with MongoDB data store and sync to the Viam Cloud." >}}
-
-This sample configuration captures fake sensor readings both to the configured MongoDB URI as well as to the `~/.viam/capture` directory on disk.
-It syncs data to the Viam Cloud every 0.1 minutes.
-
-```json
-{
-  "components": [
-    {
-      "name": "sensor-1",
-      "api": "rdk:component:sensor",
-      "model": "rdk:builtin:fake",
-      "attributes": {},
-      "service_configs": [
-        {
-          "type": "data_manager",
-          "attributes": {
-            "capture_methods": [
-              {
-                "method": "Readings",
-                "capture_frequency_hz": 0.5,
-                "additional_params": {}
-              }
-            ]
-          }
-        }
-      ]
-    }
-  ],
-  "services": [
-    {
-      "name": "data_manager-1",
-      "api": "rdk:service:data_manager",
-      "attributes": {
-        "mongo_capture_config": {
-          "uri": "mongodb://127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000"
-        },
-        "additional_sync_paths": [],
-        "sync_interval_mins": 0.1,
-        "capture_dir": "",
-        "capture_disabled": false,
-        "sync_disabled": false,
-        "tags": []
-      }
-    }
-  ]
-}
-```
-
-{{< /expand >}}
-
-When `mongo_capture_config.uri` is configured, data capture will attempt to connect to the configured MongoDB server and write captured tabular data to the configured `mongo_capture_config.database` and `mongo_capture_config.collection` (or their defaults if unconfigured) after enqueuing that data to be written to disk.
-
-If writes to MongoDB fail for any reason, data capture will log an error for each failed write and continue capturing.
-
-Failing to write to MongoDB doesn't affect capturing and syncing data to cloud storage other than adding capture latency.
-
-{{< alert title="Caution" color="caution" >}}
-
-- Capturing directly to MongoDB may write data to MongoDB that later fails to be written to disk (and therefore never gets synced to cloud storage).
-- Capturing directly to MongoDB does not retry failed writes to MongoDB. As a consequence, it is NOT guaranteed all data captured will be written to MongoDB.
-  This can happen in cases such as MongoDB being inaccessible to `viam-server` or writes timing out.
-- Capturing directly to MongoDB may reduce the maximum frequency that data capture can capture data due to the added latency of writing to MongoDB.
-  If your use case needs to support very high capture rates, this feature may not be appropriate.
-
-{{< /alert >}}
diff --git a/docs/data-ai/capture-data/advanced/how-sync-works.md b/docs/data-ai/capture-data/advanced/how-sync-works.md
deleted file mode 100644
index e93845fbe3..0000000000
--- a/docs/data-ai/capture-data/advanced/how-sync-works.md
+++ /dev/null
@@ -1,123 +0,0 @@
----
-linkTitle: "How sync works"
-title: "How sync works"
-tags: ["data management", "data", "services"]
-weight: 12
-layout: "docs"
-type: "docs"
-platformarea: ["data"]
-description: "Data capture and sync work differently for viam-server and viam-micro-server."
-date: "2024-12-18"
-updated: "2025-12-04"
----
-
-Data capture and cloud sync work differently for `viam-server` and `viam-micro-server`.
-
-{{< tabs >}}
-{{% tab name="viam-server" %}}
-
-The data is captured locally on the machine's storage and, by default, stored in the <FILE>~/.viam/capture</FILE> directory:
-
-<!-- prettier-ignore -->
-| Architecture | Default directory |
-| ------------ | ----------------- |
-| Windows | With `viam-agent`: <FILE>C:\Windows\system32\config\systemprofile\.viam\capture</FILE>. Manual installation: <FILE>C:\Users\admin\.viam\capture</FILE>. |
-| Linux | When running with root or sudo users: <FILE>/root/.viam/capture</FILE>. |
-| macOS | <FILE>/Users/\<username\>/.viam/capture</FILE>. |
-
-{{% expand "Can't find the directory data is stored in? Click here." %}}
-
-The relative path for the data capture directory depends on where `viam-server` is run from, as well as the operating system of the machine.
-
-To find the `$HOME` value, check your machine's logs on startup, which will log it in the environment variables:
-
-```sh
-2025-01-15T14:27:26.073Z    INFO    rdk    server/entrypoint.go:77    Starting viam-server with following environment variables    {"HOME":"/home/johnsmith"}
-```
-
-{{% /expand%}}
-
-If a machine restarts for any reason, data capture automatically resumes and any data already stored but not yet synced is synced.
-
-The service can capture data from multiple resources at the same or different frequencies.
-The service does not impose a lower or upper limit on the frequency of data collection.
-However, in practice, your hardware may impose limits on the frequency of data collection.
-Avoid configuring data capture to higher rates than your hardware can handle, as this could lead to performance degradation.
-
-Data capture is frequently used with cloud sync.
-You can start and stop capture and sync independently.
-You can also enable cloud sync without data capture and it will sync data in the capture directory, as well as the additional sync paths configured in the `viam-server` config.
-If you place data like images or files in the `~/.viam/capture` directory or another directory set up for sync with the data manager, for example with the `"additional_sync_paths"` config attribute, it will sync this data to the cloud.
-
-{{% /tab %}}
-{{% tab name="viam-micro-server" %}}
-
-The data is captured in the ESP32's flash memory until it is uploaded to the Viam Cloud.
-
-If the machine restarts before all data is synced, all unsynced data captured since the last sync point is lost.
-
-The service can capture data from multiple resources at the same or different frequencies.
-The service does not impose a lower or upper limit on the frequency of data collection.
-However, in practice, high frequency data collection (> 100Hz) requires special considerations on the ESP32.
-
-{{% /tab %}}
-{{< /tabs >}}
-
-## Security
-
-The data management service uses {{< glossary_tooltip term_id="grpc" text="gRPC" >}} calls to send and receive data, so your data is encrypted while in flight.
-When data is stored in the cloud, it is encrypted at rest by the cloud storage provider.
-
-## Data integrity
-
-Viam's data management service is designed to safeguard against data loss, data duplication, and otherwise compromised data.
-
-If the internet becomes unavailable or the machine needs to restart during the sync process, the sync is interrupted.
-If the sync process is interrupted, the service will retry uploading the data at exponentially increasing intervals until the interval between retries reaches one hour, at which point the service retries the sync every hour.
-When the connection is restored and sync resumes, the service continues sync where it left off without duplicating data.
-If the interruption happens mid-file, sync resumes from the beginning of that file.
-
-To avoid syncing files that are still being written to, the data management service only syncs arbitrary files that haven't been modified in the previous 10 seconds.
-This default can be changed with the [`file_last_modified_millis` config attribute](/data-ai/capture-data/advanced/advanced-data-capture-sync/#click-to-view-data-management-attributes).
-
-## Automatic data deletion
-
-If cloud sync is enabled, the data management service deletes captured data from the disk once it has successfully synced to the cloud.
-
-{{< alert title="Warning" color="warning" >}}
-
-If your robot is offline and can't sync and your machine's disk fills up beyond a certain threshold, the data management service will delete captured data to free up additional space and maintain a working machine.
-
-{{< /alert >}}
-
-The data management service will also automatically delete local data in the event your machine's local storage fills up.
-Local data is automatically deleted when _all_ of the following conditions are met:
-
-- Data capture is enabled on the data management service
-- Local disk usage percentage is greater than or equal to 90%
-- The Viam capture directory is at least 50% of the current local disk usage
-
-If local disk usage is greater than or equal to 90%, but the Viam capture directory is not at least 50% of that usage, a warning log message will be emitted instead and no action will be taken.
-
-Automatic file deletion only applies to files in the specified Viam capture directory, which is set to `~/.viam/capture` by default.
-Data outside of this directory is not touched by automatic data deletion.
-
-If your machine captures a large amount of data, or frequently goes offline for long periods of time while capturing data, consider moving the Viam capture directory to a larger, dedicated storage device on your machine if available.
-You can change the capture directory using the `capture_dir` attribute.
-
-You can also control how local data is deleted if your machine's local storage becomes full, using the `delete_every_nth_when_disk_full` attribute.
-
-## Storage
-
-Data that is successfully synced to the cloud is automatically deleted from local storage.
-
-When a machine loses its internet connection, it cannot resume cloud sync until it can reach the Viam Cloud again.
-
-{{<imgproc src="/services/data/data_management.png" resize="x1100" declaredimensions=true alt="Data is captured on the machine, uploaded to the cloud, and then deleted off local storage." class="imgzoom" >}}
-
-To ensure that the machine can store all data captured while it has no connection, you need to provide enough local data storage.
-
-For information about automatic data deletion when storage fills up, see [Automatic data deletion](#automatic-data-deletion) above.
-
-Data capture supports capturing tabular data directly to MongoDB in addition to capturing to disk.
-For more information, see [Capture directly to MongoDB](/data-ai/capture-data/advanced/advanced-data-capture-sync/#capture-directly-to-your-own-mongodb-cluster).
diff --git a/docs/data-ai/capture-data/capture-sync.md b/docs/data-ai/capture-data/capture-sync.md
deleted file mode 100644
index 2a5a7e4cb3..0000000000
--- a/docs/data-ai/capture-data/capture-sync.md
+++ /dev/null
@@ -1,144 +0,0 @@
----
-linkTitle: "Capture and sync edge data"
-title: "Capture and sync edge data"
-tags: ["data management", "data", "services"]
-weight: 10
-layout: "docs"
-type: "docs"
-platformarea: ["data"]
-description: "Capture data from a resource on your machine and sync the data to the cloud."
-date: "2024-12-03"
-updated: "2025-12-04"
-aliases:
-  - /services/data/capture/
-  - /data/capture/
-  - /build/micro-rdk/data_management/
-  - /services/data/capture/
-  - /services/data/cloud-sync/
-  - /data/cloud-sync/
-  - /services/data/capture-sync/
-  - /how-tos/sensor-data/
-  - /services/data/
-  - fleet/data-management/
-  - /manage/data-management/
-  - /services/data-management/
-  - /manage/data/
-  - /data-management/
-  - /services/data/
-  - /data/
-  - /manage/data/export/
-  - /data/export/
-  - /services/data/export/
-  - /manage/data/view/
-  - /data/view/
-  - /services/data/view/
-  - /how-tos/collect-data/
-  - /how-tos/collect-sensor-data/
-  - /get-started/quickstarts/collect-data/
-  - /use-cases/collect-sensor-data/
-  - /use-cases/image-data/
-  - /get-started/collect-data/
-  - /fleet/data-management/
----
-
-You can use the data management service to capture data from [supported components and services](/data-ai/capture-data/capture-sync/#click-to-see-resources-that-support-data-capture-and-cloud-sync), then sync it to the cloud.
-You can also [sync data from arbitrary folders on your machine](/data-ai/capture-data/upload-other-data/#sync-data-from-another-directory).
-
-## How data capture and data sync work
-
-The data management service writes data from your configured Viam resources to local storage on your edge device and syncs data from the edge device to the cloud:
-
-- The data management service writes captured data to local edge device storage (<file>~/.viam/capture</file> by default).
-- The data management service syncs data to the Viam cloud at a configured sync interval using encrypted gRPC calls and deletes it from the disk once synced.
-- You can capture and sync data independently; one can run without the other.
-
-For more information, see [How sync works](/data-ai/capture-data/advanced/how-sync-works/).
-
-<img src="/data-manager.svg" alt="Diagram showing data being captured, synced, and removed." class="aligncenter overview imgzoom" style="width:800px;height:auto" >
-
-## Configure data capture and sync for individual resources
-
-1. Navigate to a configured {{< glossary_tooltip term_id="resource" text="resource" >}} in **Builder** mode.
-1. Find the **Data capture** section in the resource panel.
-1. Click **+ Add method**.
-
-   {{< imgproc src="/tutorials/data-management/add-method.png" alt="Disable data capture toggle" resize="800x" style="width:500px" class="shadow imgzoom" >}}
-
-1. If you see a **Capture disabled on data management service** warning, click **Enable capture on data management service**.
-1. Select a **Method** to capture data from.
-
-   {{< alert title="Camera capture methods" color="note" >}}
-   Camera components provide two similar, but distinct capture methods:
-
-   - **GetImages**: Returns an image per camera sensor for 3D cameras (for example, "color" as JPEG for RGB sensors, "depth" as a depth map for depth sensors), or a single image for webcams, RTSP cameras etc.
-
-   {{< /alert >}}
-
-1. Set the capture **Frequency** in hertz, for example to `0.2` with `GetImages` on a camera to capture an image every 5 seconds.
-1. **Save** your config.
-
-You can add multiple methods with different capture frequencies.
-
-{{< expand "Click to see resources that support data capture and cloud sync" >}}
-
-The following components and services support data capture and cloud sync:
-
-{{< readfile "/static/include/data/capture-supported.md" >}}
-
-{{< alert title="Support notice" color="note" >}}
-Some models do not support all options, for example webcams do not capture point clouds.
-{{< /alert >}}
-
-{{< /expand >}}
-
-For instructions on configuring data capture and sync with JSON, see [Advanced data capture and sync configurations](/data-ai/capture-data/advanced/advanced-data-capture-sync/).
-
-## View captured data
-
-1. Navigate to the [**DATA** tab](https://app.viam.com/data/view).
-1. Select the [**Images**](https://app.viam.com/data/view?view=images), [**Files**](https://app.viam.com/data/view?view=files), [**Point clouds**](https://app.viam.com/data/view?view=point+clouds), or [**Sensors**](https://app.viam.com/data/view?view=sensors) subtab.
-1. Filter data by location, type, and more.
-
-## Stop data capture or data sync
-
-### Stop data capture for a specific resource
-
-1. Navigate to the **Data capture** section of your resource's configuration card.
-1. Toggle the configured capture method's switch to **Off**.
-
-   {{< imgproc src="/tutorials/data-management/disable-capture-resource.png" alt="Disable data capture toggle" resize="500x" class="shadow" >}}
-
-1. **Save** your config.
-
-### Stop data capture for all resources
-
-1. Navigate to the **Data capture** section of the data management service configuration card.
-1. Toggle the **Capturing** switch to **Off**.
-
-   {{< imgproc src="/tutorials/data-management/disable-capture.png" alt="Disable data capture toggle" resize="300x" class="shadow" >}}
-
-1. **Save** your config.
-
-### Disable data sync
-
-1. Navigate to the **Cloud sync** section of the data management service configuration card.
-1. Toggle the **Syncing** switch to **Off**.
-
-   {{< imgproc src="/tutorials/data-management/disable-sync.png" alt="Disable data sync toggle" resize="300x" class="shadow" >}}
-
-1. **Save** your config.
-
-{{< alert title="Tip: More ways to control data capture or sync" color="tip" >}}
-
-For other ways to control data synchronization, see:
-
-- [Conditional sync](/data-ai/capture-data/conditional-sync/)
-- [Retention policies](/data-ai/capture-data/advanced/advanced-data-capture-sync/#cloud-data-retention)
-- [Sync optimization](/data-ai/capture-data/advanced/advanced-data-capture-sync/#sync-optimization)
-
-{{< /alert >}}
-
-## Next steps
-
-For more information on available configuration attributes and options like capturing directly to MongoDB or conditional sync, see [Advanced data capture and sync configurations](/data-ai/capture-data/advanced/advanced-data-capture-sync/).
-To leverage AI, you can [create a dataset](/data-ai/train/create-dataset/) with the data you've captured.
diff --git a/docs/data-ai/capture-data/conditional-sync.md b/docs/data-ai/capture-data/conditional-sync.md
deleted file mode 100644
index 73f2fdfb91..0000000000
--- a/docs/data-ai/capture-data/conditional-sync.md
+++ /dev/null
@@ -1,324 +0,0 @@
----
-title: "Conditional cloud sync"
-linkTitle: "Conditional sync"
-description: "Trigger cloud sync to sync captured data when custom conditions are met."
-type: "docs"
-weight: 20
-tags: ["data management", "cloud", "sync"]
-images: ["/services/icons/data-cloud-sync.svg"]
-icon: true
-aliases:
-  - /data/trigger-sync/
-  - /how-tos/trigger-sync/
-  - /services/data/trigger-sync/
-  - /how-tos/conditional-sync/
-languages: []
-viamresources: ["sensor", "data_manager"]
-platformarea: ["data", "registry"]
-date: "2024-12-04"
-updated: "2025-12-04"
----
-
-By default, `viam-server` checks for new data to sync at the configured interval (`sync_interval_mins`).
-You can additionally configure sync to only happen when certain conditions are met.
-For example:
-
-- Only sync when on WiFi
-- Sync when conditions are met or events are detected
-- Sync during certain time windows
-
-To sync only when certain conditions are met, you must provide the data manager a sensor that returns `"should_sync": true` when sync should happen and `"should_sync": false` otherwise.
-
-This page shows you the implementation of a sensor which only allows sync during a defined time interval.
-You can use it as the basis of your own custom logic.
-
-You can also view the [trigger-sync-examples module](https://github.com/viam-labs/trigger-sync-examples-v2) for more examples.
-
-## Prerequisites
-
-{{% expand "A running machine connected to Viam. Click to see instructions." %}}
-
-{{% snippet "setup-both.md" %}}
-
-{{% /expand%}}
-
-{{< expand "Enable data capture and sync on your machine." >}}
-
-Add the [data management service](/data-ai/capture-data/capture-sync/#configure-data-capture-and-sync-for-individual-resources):
-
-On your machine's **CONFIGURE** tab, click the **+** icon next to your machine part in the left-hand menu and select **Component or service**.
-
-Select the `data management / RDK` service and click **Create**.
-You can leave the default data sync interval of `0.1` minutes to sync every 6 seconds.
-Also leave both **Capturing** and **Syncing** toggles in the "on" position.
-
-{{< /expand >}}
-
-{{% expand "Create a sensor module. Click to see instructions." %}}
-
-Start by [creating a sensor module](/operate/modules/write-a-driver-module/).
-
-Your sensor should have access to the information you need to determine if your machine should sync or not.
-Based on that data, make the sensor return true when the machine should sync and false when it should not.
-
-For example, if you want your machine to sync data only during a specific time interval, your sensor needs to be able to access the time as well as be configured with the time interval during which you would like to sync data.
-It can then return true during the specified sync time interval and false otherwise.
-
-{{% /expand%}}
-
-## Return `should_sync` as a reading from a sensor
-
-{{< alert title="Note" color="note" >}}
-If you are using a pre-built module like `sync-at-time:timesyncsensor`, you can skip this section and go directly to [Add your sensor to determine when to sync](#add-your-sensor-to-determine-when-to-sync).
-This section is for users who want to create their own custom sensor module.
-{{< /alert >}}
-
-The following example implementation of the `Readings()` method returns `"should_sync": true` if the current time is in a specified time window, and `"should_sync": false` otherwise.
-
-```go {class="line-numbers linkable-line-numbers" data-line="34,40,41,46"}
-func (s *timeSyncer) Readings(context.Context, map[string]interface{}) (map[string]interface{}, error) {
-    currentTime := time.Now()
-    var hStart, mStart, sStart, hEnd, mEnd, sEnd int
-    n, err := fmt.Sscanf(s.start, "%d:%d:%d", &hStart, &mStart, &sStart)
-
-    if err != nil || n != 3 {
-        s.logger.Error("Start time is not in the format HH:MM:SS.")
-        return nil, err
-    }
-    m, err := fmt.Sscanf(s.end, "%d:%d:%d", &hEnd, &mEnd, &sEnd)
-    if err != nil || m != 3 {
-        s.logger.Error("End time is not in the format HH:MM:SS.")
-        return nil, err
-    }
-
-    zone, err := time.LoadLocation(s.zone)
-    if err != nil {
-        s.logger.Error("Time zone cannot be loaded: ", s.zone)
-        return nil, err
-    }
-
-    startTime := time.Date(currentTime.Year(), currentTime.Month(), currentTime.Day(),
-        hStart, mStart, sStart, 0, zone)
-    endTime := time.Date(currentTime.Year(), currentTime.Month(), currentTime.Day(),
-        hEnd, mEnd, sEnd, 0, zone)
-
-    // Handle time windows that span midnight (e.g., 23:00 to 01:00)
-    // If end time is earlier than or equal to start time, the window spans midnight
-    if endTime.Before(startTime) || endTime.Equal(startTime) {
-        // Add 24 hours to endTime to account for midnight crossover
-        endTime = endTime.Add(24 * time.Hour)
-    }
-
-    readings := map[string]interface{}{"should_sync": false}
-    readings["time"] = currentTime.String()
-
-    // Check if current time is within the sync window
-    if currentTime.After(startTime) && currentTime.Before(endTime) {
-        s.logger.Debug("Syncing")
-        readings["should_sync"] = true
-        return readings, nil
-    }
-
-    // Otherwise, do not sync.
-    s.logger.Debug("Not syncing. Current time not in sync window: " + currentTime.String())
-    return readings, nil
-}
-```
-
-{{< alert title="Note" color="note" >}}
-You can return other readings alongside the `should_sync` value.
-{{< /alert >}}
-
-You must also update the `Config` and resource struct to include the required attributes and update the `init()` and `Validate()` functions appropriately.
-Check the [implementation of the sensor on GitHub](https://github.com/viam-labs/sync-at-time/blob/main/module.go) for more detailed information.
-
-For additional examples, see the `Readings` function of the [time-interval-trigger code](https://github.com/viam-labs/trigger-sync-examples-v2/blob/main/time-interval-trigger/selective_sync/selective_sync.go) and the [color-trigger code](https://github.com/viam-labs/trigger-sync-examples-v2/blob/main/color-trigger/selective_sync/selective_sync.go).
-
-## Add your sensor to determine when to sync
-
-This section shows how to add and configure [`sync-at-time:timesyncsensor`](https://app.viam.com/module/naomi/sync-at-time).
-If you created your own sensor module following the previous section, you will need to follow similar steps with your module:
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Add the sensor to your machine**
-
-On your machine's **CONFIGURE** tab, click the **+** button next to your machine part in the left menu.
-Select **Component or service**, then search for and select the `sync-at-time:timesyncsensor` model provided by the [`sync-at-time` module](https://app.viam.com/module/naomi/sync-at-time).
-
-Click **Add module**, then enter a name or use the suggested name for your sensor and click **Create**.
-
-{{% /tablestep %}}
-
-<!-- markdownlint-disable-file MD034 -->
-
-{{% tablestep %}}
-**Configure your time frame**
-
-Go to the new component panel and copy and paste the following attribute template into your sensor’s attributes field:
-
-{{< tabs >}}
-{{% tab name="Template" %}}
-
-```json
-{
-  "start": "HH:MM:SS",
-  "end": "HH:MM:SS",
-  "zone": "<TIMEZONE>"
-}
-```
-
-{{% /tab %}}
-{{% tab name="Example" %}}
-
-```json
-{
-  "start": "18:29:00",
-  "end": "18:30:00",
-  "zone": "CET"
-}
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-The following attributes are available for the `naomi:sync-at-time:timesyncsensor` sensor:
-
-<div class="td-content">
-
-<!-- prettier-ignore -->
-| Name    | Type   | Required? | Description |
-| ------- | ------ | --------- | ----------- |
-| `start` | string | **Required** | The start time for the time frame during which you want to sync. Example: `"14:10:00"`.  |
-| `end`   | string | **Required** | The end of the sync time frame, for example: `"15:35:00"`. |
-| `zone`  | string | **Required** | The time zone for the `start` and `end` time, for example: `"CET"`. |
-
-{{< /tablestep >}}
-{{< /table >}}
-
-</div>
-<br>
-
-In the next step, you will configure the data manager to take the sensor into account when syncing.
-
-## Configure the data manager to sync based on sensor
-
-On your machine's **CONFIGURE** tab, switch to **JSON** mode and add a `selective_syncer_name` field with the name of the sensor you configured, and add the sensor to the `depends_on` field:
-
-{{< tabs >}}
-{{% tab name="JSON Template" %}}
-
-```json {class="line-numbers linkable-line-numbers" data-line="9,14"}
-{
-  "name": "data_manager-1",
-  "api": "rdk:service:data_manager",
-  "model": "rdk:builtin:builtin",
-  "attributes": {
-    "additional_sync_paths": [],
-    "capture_dir": "",
-    "capture_disabled": false,
-    "selective_syncer_name": "<SENSOR-NAME>",
-    "sync_disabled": false,
-    "sync_interval_mins": 0.1,
-    "tags": []
-  },
-  "depends_on": ["<SENSOR-NAME>"]
-}
-```
-
-{{% /tab %}}
-{{% tab name="JSON Example" %}}
-
-```json {class="line-numbers linkable-line-numbers" data-line="7,12"}
-{
-  "name": "datamanager",
-  "api": "rdk:service:data_manager",
-  "model": "rdk:builtin:builtin",
-  "attributes": {
-    "additional_sync_paths": [],
-    "selective_syncer_name": "timesensor",
-    "sync_interval_mins": 0.1,
-    "capture_dir": "",
-    "tags": []
-  },
-  "depends_on": ["timesensor"]
-}
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% expand "Click to view a full configuration example" %}}
-
-```json {class="line-numbers linkable-line-numbers" data-line="12-21,25-37,40-45"}
-{
-  "components": [
-    {
-      "name": "camera-1",
-      "api": "rdk:component:camera",
-      "model": "webcam",
-      "attributes": {
-        "video_path": "0x114000005a39331"
-      }
-    },
-    {
-      "name": "timesensor",
-      "api": "rdk:component:sensor",
-      "model": "naomi:sync-at-time:timesyncsensor",
-      "attributes": {
-        "start": "18:29:00",
-        "end": "18:30:00",
-        "zone": "CET"
-      }
-    }
-  ],
-  "services": [
-    {
-      "name": "data_manager-1",
-      "api": "rdk:service:data_manager",
-      "model": "rdk:builtin:builtin",
-      "attributes": {
-        "capture_dir": "",
-        "tags": [],
-        "additional_sync_paths": [],
-        "selective_syncer_name": "timesensor",
-        "sync_interval_mins": 0.1
-      },
-      "depends_on": ["timesensor"]
-    }
-  ],
-  "modules": [
-    {
-      "type": "registry",
-      "name": "naomi_sync-at-time",
-      "module_id": "naomi:sync-at-time",
-      "version": "3.0.3"
-    }
-  ]
-}
-```
-
-{{% /expand%}}
-
-You have now configured sync to happen during a specific time slot.
-
-## Test your sync configuration
-
-To test your setup, [configure a webcam](/operate/reference/components/camera/webcam/) or another component and [enable data capture on the component](/data-ai/capture-data/capture-sync/#configure-data-capture-and-sync-for-individual-resources).
-Make sure to physically connect any hardware parts to the computer controlling your machine.
-For a camera component, use the `GetImages` method.
-The data manager will now capture data.
-Go to the [**CONTROL** tab](/manage/troubleshoot/teleoperate/default-interface/#web-ui).
-You should see the sensor.
-Click on `GetReadings`.
-
-{{<imgproc src="/services/data/timesensor.png" resize="800x" declaredimensions=true alt="Control tab with sensor panel" style="width: 500px" class="imgzoom shadow" >}}
-
-If you are in the time frame for sync, the time sync sensor will return `true`.
-If you are not in the time frame, it will return `false`.
-
-To verify that sync is working:
-
-1. If the sensor returns `true` and data has been captured, go to the [**Data** tab](https://app.viam.com/data/view) to see your synced data.
-2. If the sensor returns `false` but you want to test sync, adjust the configuration of your time sync sensor to include the current time.
-3. Check again on the **CONTROL** tab to verify the sensor reading, and on the **Data** tab to confirm data is syncing.
diff --git a/docs/data-ai/capture-data/filter-before-sync.md b/docs/data-ai/capture-data/filter-before-sync.md
deleted file mode 100644
index 5c23c16603..0000000000
--- a/docs/data-ai/capture-data/filter-before-sync.md
+++ /dev/null
@@ -1,124 +0,0 @@
----
-linkTitle: "Filter data"
-title: "Filter data before sync"
-weight: 13
-layout: "docs"
-type: "docs"
-description: "Use filtering to collect and sync only certain images."
-aliases:
-  - /how-tos/image-data/
-  - /tutorials/projects/filtered-camera/
-updated: "2025-12-04"
----
-
-You can use filtering to selectively capture only images that contain certain objects or people, using a machine learning (ML) model.
-You can also [create data filtering modules](/tutorials/configure/pet-photographer/) to filter other data or use registry modules other contributors have created.
-
-The following steps use the [`filtered_camera`](https://app.viam.com/module/viam/filtered-camera) module.
-
-{{% alert title="Prerequisites" color="note" %}}
-Before starting, make sure you have:
-
-- A configured camera component on your machine. See [Configure a camera](/operate/reference/components/camera/) if you need to set one up.
-- The data management service configured. See [Capture and sync edge data](/data-ai/capture-data/capture-sync/) for instructions.
-  {{% /alert %}}
-
-If you want to create your own filtering module, see [Create a Data Filtering Module](/tutorials/configure/pet-photographer/).
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Add an ML model service to your machine**
-
-Add an ML model service on your machine that is compatible with the ML model you want to use, for example [TFLite CPU](https://github.com/viam-modules/mlmodel-tflite).
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Select a suitable ML model**
-
-Click **Select model** on the ML model service configuration panel, then select an [existing model](https://app.viam.com/registry?type=ML+Model) you want to use, or click **Upload a new model** to upload your own.
-If you're not sure which model to use, you can use [`EfficientDet-COCO`](https://app.viam.com/ml-model/viam-labs/EfficientDet-COCO) from the **Registry**, which can detect people and animals, among other things.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Add a vision service to use with the ML model**
-
-You can think of the vision service as the bridge between the ML model service and the output from your camera.
-
-Add and configure the `vision / ML model` service on your machine.
-From the **Select model** dropdown, select the name of your ML model service (for example, `mlmodel-1`).
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Configure the filtered camera**
-
-The `filtered-camera` {{< glossary_tooltip term_id="modular-resource" text="modular component" >}} pulls the stream of images from your camera component and applies the vision service to it.
-
-Configure a `filtered-camera` component on your machine, following the [attribute guide in the README](https://github.com/erh/filtered_camera?tab=readme-ov-file#configure-your-filtered-camera).
-Use the name of your camera component as the `"camera"` to pull images from, and select the name of the vision service you just configured as your `"vision"` service.
-Then add all or some of the labels your ML model uses as classifications or detections in `"classifications"` or `"objects"`.
-
-For example, if you are using the `EfficientDet-COCO` model, you could use a configuration like the following to only capture images when a person is detected with more than 80% confidence in your camera stream.
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "camera": "camera-1",
-  "vision_services": [
-    {
-      "vision": "vision-1",
-      "objects": {
-        "Person": 0.8
-      }
-    }
-  ],
-  "window_seconds": 0
-}
-```
-
-You can also add a buffer window with `window_seconds`, which controls the duration of a buffer of images captured before a successful match.
-If you were to set `window_seconds` to `3`, the camera would also capture and sync images from the 3 seconds before a person appeared in the camera stream.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Configure data capture and sync on the filtered camera**
-
-Configure data capture and sync on the filtered camera following the same process as described in [Capture and sync edge data](/data-ai/capture-data/capture-sync/#configure-data-capture-and-sync-for-individual-resources).
-The filtered camera will only capture image data that passes the filters you configured in the previous step.
-
-Turn off data capture on your original camera component if you haven't already, so that you don't capture duplicate or unfiltered images.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Save to start capturing**
-
-Save the config.
-With cloud sync enabled, captured data is automatically uploaded to Viam after a short delay.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**View filtered data on Viam**
-
-Once you save your configuration, place an object that your ML model can detect within view of your camera.
-
-Images that pass your filter will be captured and will sync at the specified sync interval, which may mean you have to wait and then refresh the page for data to appear.
-Your images will begin to appear under the **DATA** tab.
-
-If no data appears after the sync interval, check the [**Logs**](/manage/troubleshoot/troubleshoot/#check-logs) and ensure that the condition for filtering is met.
-You can test the vision service from the [**CONTROL** tab](/manage/troubleshoot/teleoperate/default-interface/) to see its classifications and detections live.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**(Optional) Trigger sync with custom logic**
-
-By default, the captured data syncs at the regular interval you specified in the data capture config.
-If you need to trigger sync in a different way, see [Conditional cloud sync](/data-ai/capture-data/conditional-sync/) for a documented example of syncing data only at certain times of day.
-
-{{% /tablestep %}}
-{{< /table >}}
-
-## Stop data capture on the filtered camera
-
-If this is a test project, make sure you stop data capture to avoid [incurring fees](https://www.viam.com/product/pricing) for capturing large amounts of test data.
-
-In the **Data capture** section of your filtered camera's configuration, toggle the switch to **Off**.
-
-Click the **Save** button in the top right corner of the page to save your config.
diff --git a/docs/data-ai/capture-data/lorawan.md b/docs/data-ai/capture-data/lorawan.md
deleted file mode 100644
index 3271ba98bc..0000000000
--- a/docs/data-ai/capture-data/lorawan.md
+++ /dev/null
@@ -1,686 +0,0 @@
----
-title: "Create a LoRaWAN network"
-linkTitle: "Create a LoRaWAN network"
-weight: 60
-type: "docs"
-description: "Configure a gateway and nodes to communicate over the LoRaWAN protocol."
-tags: ["sensor", "components", "lorawan", "gateway", "node"]
-icon: true
-images: ["/icons/components/sensor.svg"]
----
-
-[LoRaWAN (Long Range Wide Area Network)](https://lora-alliance.org/) enables sensor communication spanning kilometers with minimal power usage.
-
-To collect LoRaWAN sensor data with Viam, use the [`lorawan`](https://app.viam.com/module/viam/lorawan) {{< glossary_tooltip term_id="module" text="module" >}}.
-
-## Hardware requirements
-
-- A [supported LoRaWAN gateway](https://github.com/viam-modules/lorawan?tab=readme-ov-file#lorawan-gateway-models-provided)
-- A [supported LoRaWAN node](https://github.com/viam-modules/lorawan?tab=readme-ov-file#lorawan-sensor-models-provided)
-
-## Architecture
-
-You can use Viam to create LoRaWAN networks containing one gateway and multiple nodes.
-In a LoRaWAN network, information flows in two directions:
-
-- **uplinks** transmit from nodes to gateways
-- **downlinks** transmit from gateways to nodes
-
-![A LoRaWAN network consisting of a single gateway and multiple nodes](/components/sensor/lorawan.png)
-
-### Nodes
-
-Nodes pair LoRaWAN transmitters and receivers with a sensor.
-Instead of physically connecting to a machine over GPIO pins or USB, nodes communicate with your machine using the wireless LoRaWAN protocol.
-LoRaWAN supports communication over distances of up to 10 kilometers.
-Nodes typically run on battery power; a single coin cell battery can power a node for weeks or months.
-
-### Gateway
-
-A gateway collects data generated by LoRaWAN nodes and acts as a network server.
-The gateway is the device that communicates with nodes over LoRaWAN and that connects to Viam.
-Viam can sync the data from the gateway and the LoRaWAN nodes to Viam, where you can aggregate and visualize your data.
-
-## Add a gateway
-
-To start your network, you need a gateway.
-The `lorawan` module supports the following varieties of gateway hardware:
-
-- Peripherals built on the SX1302 or SX1303 chips connected to an SBC, such as the [Waveshare SX1302 Gateway HAT](https://www.waveshare.com/wiki/SX1302_LoRaWAN_Gateway_HAT)
-- Dedicated machines such as the Raspberry Pi CM4-based [RAK7391 WisGate Connect](https://docs.rakwireless.com/product-categories/wisgate/rak7391/overview/)
-
-If you choose the RAK7391:
-
-1. Complete the [RAKPiOS quickstart](https://docs.rakwireless.com/product-categories/software-apis-and-libraries/rakpios/quickstart/) to flash your RAK7391 with an operating system and connect it to the Internet.
-1. [Install `viam-server`](/operate/install/setup/).
-
-If you choose a peripheral:
-
-1. Follow our guide to [install `viam-server` on your SBC](/operate/install/setup/).
-1. Enable SPI on your machine:
-
-   ```console
-   sudo raspi-config nonint do_spi 0
-   ```
-
-1. Follow the instructions provided by your peripheral manufacturer (for example, the [Waveshare SX1302 LoRaWAN Gateway HAT instructions](https://www.waveshare.com/wiki/SX1302_LoRaWAN_Gateway_HAT)) to physically connect your peripheral to your SBC.
-   For supported models, there is no need to configure drivers and software; `viam-server` handles software configuration for you.
-
-After setting up your gateway hardware, complete the following steps to configure your gateway:
-
-{{< tabs >}}
-{{% tab name="Builder" %}}
-
-Open your machine's page in [Viam](https://app.viam.com) and navigate to the **CONFIGURE** tab.
-
-First, add a `board` component:
-
-1. In the left-hand menu, click the **+** icon next to your machine part and select **Component or service**.
-1. Select the `board` type, then select the model that matches your machine.
-   For instance, if you connected a peripheral gateway to a Raspberry Pi 5, choose `raspberry-pi:rpi5`.
-   If you have a RAK7391, choose `raspberry-pi:rpi` to represent the internal Raspberry Pi Compute Module 4.
-1. Click **Add module**, and enter a name for your board.
-1. Click **Create** to add the module and board component to your machine.
-
-Next, add a `lorawan` gateway component:
-
-1. Click the **+** icon again to add another component.
-1. Select the `sensor` type, then select the `lorawan` model that matches the name of your gateway.
-   If your SX1302- or SX1303-based peripheral lacks a dedicated model, choose `lorawan:sx1302-hat-generic`.
-1. Click **Add module**, and enter a name for your gateway.
-1. Click **Create**.
-1. Click **Save** in the top right to apply your changes.
-
-{{% /tab %}}
-{{% tab name="JSON Configuration" %}}
-
-In the `components` section of your machine configuration, add the following objects:
-
-```json
-{
-  "name": "<lorawan-gateway-board>",
-  "api": "rdk:component:board",
-  "model": "viam:raspberry-pi:<your-pi-model>",
-  "attributes": {}
-},
-{
-  "name": "<your-gateway-name>",
-  "api": "rdk:component:sensor",
-  "model": "viam:lorawan:<gateway-sensor-name>",
-  "attributes": {
-    "board": "<lorawan-gateway-board>",
-    "spi_bus": "<spi-bus-number>",
-    "region_code": "<region-code>"
-  }
-}
-```
-
-Choose an appropriate board model from the [board components registry](/operate/reference/components/board/).
-
-Choose an appropriate gateway model from the following options:
-
-- `viam:lorawan:sx1302-waveshare-hat`: Waveshare LoRaWAN SX1302 Gateway HAT
-- `viam:lorawan:sx1302-hat-generic`: generic model for all other peripherals built using the SX1302 or SX1303 chips
-- `viam:lorawan:rak7391`: RAK7391 WisGate Connect
-
-Configure attributes based on the descriptions below:
-
-{{% /tab %}}
-{{< /tabs >}}
-
-You must configure the following attributes for SX1302- and SX1303-based LoRaWAN gateways:
-
-- `board`: The name of the [board component](/operate/reference/components/board/) that the peripheral is connected to. Used for GPIO pin control.
-- `reset_pin`: GPIO pin used for peripheral reset. Not configurable for `sx1302-waveshare-hat`.
-
-For generic peripherals, you must also configure `spi_bus`, `power_en_pin`, and `path`. For a full list of attributes, see the [module README](https://github.com/viam-modules/lorawan?tab=readme-ov-file#configuration-for-lorawan-gateways).
-
-You must configure the following attributes for RAK7391 gateways:
-
-- `board`: The name of the [board component](/operate/reference/components/board/) that represents the Raspberry Pi Compute Module inside the RAK7391. Used for GPIO pin control.
-
-## Add a node
-
-Complete the following steps to configure your node:
-
-{{< tabs >}}
-{{% tab name="Builder" %}}
-
-1. Navigate to the **CONFIGURE** tab of your machine's page in the [Viam app](https://app.viam.com).
-1. Click the **+** icon next to your machine part in the left-hand menu and select **Component or service**.
-1. Select the `sensor` type, then type `lorawan` and select the `lorawan` model that matches the name of your node.
-   If the name of your node does not appear in the list, choose the generic `lorawan:node` option.
-1. Click **Add module**, and enter a name for your node.
-1. Click **Create** to add the model and module to your machine.
-1. Configure the model attributes as described below, according to the node type.
-1. Click **Save** in the top right to apply your changes.
-
-{{% /tab %}}
-{{% tab name="JSON Configuration" %}}
-
-In the `components` section of your machine configuration, add the following object, depending on your preferred [activation protocol](#activation-protocols):
-
-{{< tabs >}}
-{{% tab name="OTAA" %}}
-
-```json
-{
-  "name": "<your-node-name>",
-  "api": "rdk:component:sensor",
-  "model": "viam:lorawan:<node-name>",
-  "attributes": {
-    "dev_eui": <device-eui>,
-    "app_key": <application-key>,
-    "gateways": [<gateway-name>]
-  }
-}
-```
-
-{{% /tab %}}
-{{% tab name="ABP" %}}
-
-```json
-{
-  "name": "<your-node-name>",
-  "api": "rdk:component:sensor",
-  "model": "viam:lorawan:<node-name>",
-  "attributes": {
-    "join_type": "ABP",
-    "dev_addr": <device-address>,
-    "app_s_key": <application-session-key>,
-    "network_s_key": <network-session-key>,
-    "gateways": [<gateway-name>]
-  }
-}
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-Choose an appropriate node model from the following options:
-
-- `viam:lorawan:dragino-LHT65N`: Dragino LHT65N temperature and humidity sensor.
-- `viam:lorawan:dragino-WQSLB`: Dragino WQS-LB water quality sensor
-- `viam:lorawan:milesight-ct101`: Milesight CT101 current sensor
-- `viam:lorawan:milesight-em310-tilt`: Milesight EM310-TILT sensor
-- `viam:lorawan:node`: Any LoRaWAN sensor that is:
-  - Class A
-  - supports either the `US915` or `EU868` frequency bands
-  - uses LoRaWAN MAC specification version 1.0.3
-
-Configure attributes based on the descriptions below:
-
-{{% /tab %}}
-{{< /tabs >}}
-
-Configure the following attributes for OTAA nodes:
-
-- `join_type`: (Optional) The [activation protocol](#activation-protocols) used to secure this network. Default: "OTAA". Options: "OTAA", "ABP".
-- `dev_eui`: The **device EUI (Extended Unique Identifier)**, a unique 64-bit identifier for the LoRaWAN device in hexadecimal format (16 characters). Found on your device or in device packaging.
-- `app_key`: The 128-bit hexadecimal AES **application key** used for device authentication and session key derivation. Found in the device datasheet.
-- `gateways`: An array containing the names of the [gateway component](#add-a-gateway) in your Viam configuration.
-
-You must configure the following attributes for ABP nodes:
-
-- `dev_addr`: The 32-bit hexadecimal **device address** used to identify this device in uplink messages. Found in the device datasheet or in device packaging.
-- `app_s_key`: The 128-bit hexadecimal **application session key** used to decrypt uplink messages. Found in the device datasheet or in device packaging.
-- `network_s_key`: The 128-bit hexadecimal **network session key** used to decrypt uplink messages. Found in the device datasheet or in device packaging.
-- `gateways`: An array containing the names of the [gateway component](#add-a-gateway) in your Viam configuration.
-
-For the generic `viam:lorawan:node` model, you must also configure `decoder_path` for the [decoder script](#decoder-script).
-
-{{% alert title="Tip" color="tip" %}}
-
-Device-specific models for Milesight nodes provide default values for `app_key` (for OTAA), `network_s_key` and `app_s_key` (for ABP), `fport`, `decoder_path`, and `uplink_interval_mins`.
-If you use a Milesight node, omit these fields from your configuration.
-
-{{% /alert %}}
-
-For a full list of attributes, see the [module README](https://github.com/viam-modules/lorawan?tab=readme-ov-file#configuration-for-lorawan-nodes).
-
-### Activation protocols
-
-LoRaWAN networks can use any of the following protocols for communication:
-
-<!-- prettier-ignore -->
-| Name | Value | Key | Session Key | Configuration |
-| ---- | ----- | --- | ----------- | ------------- |
-| Over-The-Air Activation | `OTAA` | Dynamic, generated at join time | Automatically rotated | <ul><li> `dev_eui` </li><li> `app_key` </li></ul> |
-| Activation By Personalization | `ABP` | Static | Static unless manually rotated | <ul><li> `dev_addr` </li><li> `network_s_key` </li><li> `app_s_key` </li></ul> |
-
-To specify an activation protocol for your network, use the `join_type` field.
-
-### Decoder script
-
-When a LoRaWAN device transmits data, it sends compressed binary payloads to minimize power consumption and airtime.
-Decoder scripts convert this binary data into structured, human-readable formats like JSON.
-
-Each manufacturer uses different encoding schemes depending on the data transmitted by a device.
-For example:
-
-- A temperature sensor might encode 23.5°C as a hexadecimal value like `0x00EB`.
-- A GPS tracker might pack latitude and longitude into 8 bytes.
-
-Without a decoder script, your application receives meaningless byte sequences like `0x00EB1337` instead of useful data like `{"temperature": 23.5, "humidity": 42.0 }`.
-
-Device manufacturers typically provide scripts for each device. For examples, see the following GitHub repositories:
-
-- [Milesight](https://github.com/Milesight-IoT/SensorDecoders)
-- [Dragino](https://github.com/dragino/dragino-end-node-decoder)
-
-### Frame port
-
-{{% alert title="Info" color="info" %}}
-
-Only configure an `fport` value for your node if the documentation for your device instructs you to do so.
-
-{{% /alert %}}
-
-Frame port (`fport`) is an 8-bit field in the LoRaWAN MAC payload structure that defines the data type contained within the frame payload.
-Frame ports identify the kind of data passed in an uplink or downlink message so it can be routed to the correct handler, which helps keep LoRaWAN traffic fast, simple, and efficient.
-
-Use the `fport` field of a node configuration to specify the frame port value that the node expects to use for downlink communication.
-When you specify an `fport` value for a node, gateways use that value as the frame port for all downlink communication with the node.
-
-## Control nodes
-
-You can use [DoCommand](/dev/reference/sdks/docommand/) to configure, control, and calibrate your LoRaWAN nodes.
-The `lorawan` module supports the following commands:
-
-### Restart node
-
-{{< tabs >}}
-{{% tab name="Viam web app" %}}
-
-To restart a node from the Viam web UI, send the following DoCommand input in the **CONTROL** tab of your machine page:
-
-```json
-{
-  "restart_sensor": ""
-}
-```
-
-{{% /tab %}}
-{{% tab name="SDK" %}}
-
-The following example shows how to restart a node from an SDK:
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python
-node = await robot.get_component(Sensor.get_resource_name("<your_node_name>"))
-
-# restart node
-await node.do_command({"restart_sensor": {}})
-```
-
-{{% /tab %}}
-{{% tab name="Flutter" %}}
-
-```dart
-final node = Sensor.fromRobot(robot, '<your_node_name>');
-
-// restart node
-await node.doCommand({ 'restart_sensor': {} });
-```
-
-{{% /tab %}}
-
-{{% tab name="TypeScript" %}}
-
-```typescript
-const node = new SensorClient(client, "<your_node_name>");
-
-// restart node
-await node.doCommand({ restart_sensor: {} });
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-### Send a downlink message to a node
-
-{{< tabs >}}
-{{% tab name="Viam web app" %}}
-
-To send a downlink message to a node from the Viam web UI, specify a hexadecimal string in the following DoCommand input in the **CONTROL** tab of your machine page:
-
-```json
-{
-  "send_downlink": "48656C6C6F"
-}
-```
-
-{{% /tab %}}
-{{% tab name="SDK" %}}
-
-The following example shows how to send downlink messages to a node from an SDK:
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python
-node = await robot.get_component(Sensor.get_resource_name("<your_node_name>"))
-
-# send downlink message in hexadecimal
-await node.do_command({"send_downlink": "48656C6C6F"})
-```
-
-{{% /tab %}}
-{{% tab name="Flutter" %}}
-
-```dart
-final node = Sensor.fromRobot(robot, '<your_node_name>');
-
-// send downlink message in hexadecimal
-await node.doCommand({ 'send_downlink': '48656C6C6F' });
-```
-
-{{% /tab %}}
-
-{{% tab name="TypeScript" %}}
-
-```typescript
-const node = new SensorClient(client, "<your_node_name>");
-
-// send downlink message in hexadecimal
-await node.doCommand({ send_downlink: "48656C6C6F" });
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-### Configure the transmission interval
-
-The transmission interval controls how often a node communicates with the gateway.
-
-{{< tabs >}}
-{{% tab name="Viam web app" %}}
-
-To change the transmission interval of a node from the Viam web UI, send the following DoCommand input in the **CONTROL** tab of your machine page:
-
-```json
-{
-  "set_interval": 300.0
-}
-```
-
-{{% /tab %}}
-{{% tab name="SDK" %}}
-
-The following example shows how to change the transmission interval of a node from an SDK:
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python
-node = await robot.get_component(Sensor.get_resource_name("<your_node_name>"))
-
-# set data transmission interval in seconds
-await node.do_command({"set_interval": 300.0})
-```
-
-{{% /tab %}}
-{{% tab name="Flutter" %}}
-
-```dart
-final node = Sensor.fromRobot(robot, '<your_node_name>');
-
-// set data transmission interval in seconds
-await node.doCommand({ 'set_interval': 300.0 });
-```
-
-{{% /tab %}}
-
-{{% tab name="TypeScript" %}}
-
-```typescript
-const node = new SensorClient(client, "<your_node_name>");
-
-// set data transmission interval in seconds
-await node.doCommand({ set_interval: 300.0 });
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-### Calibrate the Dragino WQS-LB water quality sensor
-
-To use a Dragino WQS-LB, you must calibrate the sensor.
-For other sensors, see the manufacturer's instructions.
-
-{{% alert title="Info" color="info" %}}
-
-For more information about calibration, consult the [user manual](https://wiki.dragino.com/xwiki/bin/view/Main/User%20Manual%20for%20LoRaWAN%20End%20Nodes/WQS-LB--LoRaWAN_Water_Quality_Sensor_Transmitter_User_Manual/).
-
-{{% /alert %}}
-
-{{< tabs >}}
-{{% tab name="Viam web app" %}}
-
-To send calibration commands from the Viam web app, send the following DoCommand input in the **CONTROL** tab of your machine page:
-
-```json
-{
-  "<command>": value
-}
-```
-
-{{% /tab %}}
-{{% tab name="SDK" %}}
-
-The following example shows how to send calibration commands to the Dragino WQS-LB sensor:
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python
-node = await robot.get_component(Sensor.get_resource_name("<your_node_name>"))
-
-await node.do_command({"<command>": "<value>"})
-```
-
-{{% /tab %}}
-{{% tab name="Flutter" %}}
-
-```dart
-final node = Sensor.fromRobot(robot, '<your_node_name>');
-
-await node.doCommand({'<command>': '<value>' });
-```
-
-{{% /tab %}}
-
-{{% tab name="TypeScript" %}}
-
-```typescript
-const node = new SensorClient(client, "<your_node_name>");
-
-await node.doCommand({ <command>: <value> });
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-The Dragino WQS-LB supports the following calibration commands:
-
-- `calibrate_ph`
-- `calibrate_ec`
-- `calibrate_t`
-- `calibrate_orp`
-
-Use the calibration processes below to calibrate your sensor with these commands:
-
-#### Calibrate the pH probe
-
-The pH probe uses a three-point calibration process:
-
-1. Wash the electrode with distilled water
-1. Place the electrode in a 9.18 standard buffer solution.
-1. Wait at least one transmission interval.
-   View the sensor output in the **TEST** panel.
-   Once the data stabilizes, send the following downlink to the node:
-
-   ```json
-   {
-     "calibrate_ph": 9
-   }
-   ```
-
-1. Wash the electrode with distilled water
-1. Place the electrode in a 6.86 standard buffer solution.
-1. Wait at least one transmission interval.
-   View the sensor output in the **TEST** panel.
-   Once the data stabilizes, send the following downlink to the node:
-
-   ```json
-   {
-     "calibrate_ph": 6
-   }
-   ```
-
-1. Wash the electrode with distilled water.
-1. Place the electrode in a 4.01 standard buffer solution.
-1. Wait at least one transmission interval.
-   View the sensor output in the **TEST** panel.
-   Once the data stabilizes, send the following downlink to the node:
-
-   ```json
-   {
-     "calibrate_ph": 4
-   }
-   ```
-
-#### Calibrate the electrical conductivity probe
-
-The EC probe uses a one-point calibration process. You can configure the EC probe in the following modes:
-
-- For K=1, to measure conductivity from 0-2000 μS/cm at a resolution of 1 μS/cm:
-
-  1. Wash the electrode with distilled water.
-  1. Place the electrode in a 1413 μS/cm solution.
-  1. Wait at least one transmission interval.
-     View the sensor output in the **TEST** panel.
-     Once the data stabilizes, send the following downlink:
-
-     ```json
-     {
-       "calibrate_ec": 1
-     }
-     ```
-
-- For K=10, to measure conductivity from 10-20000 μS/cm at a resolution of 10 μS/cm:
-
-  1. Wash the electrode with distilled water.
-  1. Place the electrode in a 12.88 mS/cm solution.
-  1. Wait at least one transmission interval.
-     View the sensor output in the **TEST** panel.
-     Once the data stabilizes, send the following downlink:
-
-     ```json
-     {
-       "calibrate_ec": 10
-     }
-     ```
-
-#### Calibrate the turbidity probe
-
-The turbidity probe uses a one-point calibration process:
-
-1. Prepare a 0 NTU, 200 NTU, 400 NTU, 600 NTU, 800 NTU, or 1000 NTU solution.
-1. Place the probe in the solution.
-1. Wait at least one transmission interval.
-   View the sensor output in the **TEST** panel.
-   Once the data stabilizes, send a downlink containing the NTU value to your node:
-
-   ```json
-   {
-     "calibrate_t": <NTU value>
-   }
-   ```
-
-#### Calibrate the ORP probe
-
-The Oxidation-Reduction Potential (ORP) probe uses a two-point calibration process:
-
-1. Wash the electrode with distilled water and place the probe in a 86mV standard buffer.
-1. Wait at least one transmission interval.
-   View the sensor output in the **TEST** panel.
-   Once the data stabilizes, send the following downlink to the node:
-
-   ```json
-   {
-     "calibrate_orp": 86
-   }
-   ```
-
-1. Wash the electrode with distilled water and place the probe in a 256mV standard buffer.
-1. Wait at least one transmission interval.
-   View the sensor output in the **TEST** panel.
-   Once the data stabilizes, send the following downlink to the node:
-
-   ```json
-   {
-     "calibrate_orp": 256
-   }
-   ```
-
-## View captured data
-
-You can query captured data in the Viam app from the **DATA** page.
-To build a dashboard to monitor your captured data using charts and graphs, configure widgets on the **TELEOP** page.
-
-For more information, see [Visualize data](/data-ai/data/visualize/).
-
-## Troubleshooting
-
-### Gateway fails to start
-
-- **Check hardware connections**:
-
-  - If using a HAT, ensure your HAT is properly seated on the SBC's GPIO header.
-  - Check that the antenna is securely connected to your gateway.
-  - On the Waveshare SX1302 LoRaWAN Gateway HAT, check the status LEDs for activity:
-    - **Power LED (red, solid)**: gateway receiving power
-    - **TX LED (red, blinking)**: gateway transmitting data
-    - **RX LED (red, blinking)**: gateway receiving data
-
-- **Verify pin configuration**:
-
-  - If using a HAT, confirm that `reset_pin` and `power_en_pin` in your gateway configuration match the manufacturer's guidelines for your HAT.
-  - Verify that SPI is enabled on your machine.
-  - Check that `spi_bus` is configured for the correct SPI bus.
-
-### Sensor fails to join network
-
-- **Wait 10-15 minutes**:
-  - Nodes can take up to 10-15 minutes to join the network.
-  - If a node doesn't join the network within 30 minutes, try restarting the node.
-- **Verify device identifiers**:
-
-  - Check that `dev_eui` in your node configuration matches the value of your device.
-  - If you use the OTAA activation protocol, confirm that `app_key` matches the application key defined in the device datasheet.
-  - If you use the ABP activation protocol, verify that `app_s_key` and `network_s_key` match the values defined in the device datasheet or device packaging.
-
-- **Check network configuration**:
-
-  - Ensure gateway is running with no error logs.
-  - Verify that the `gateways` field of the node contains an array that contains only a string that exactly matches the name of your gateway in your machine configuration (for example, `"gateways": [ "example-gateway" ]`).
-  - Verify that your gateway and node frequency regions match.
-
-- **Adjust positioning**:
-  - Move node closer to gateway for initial setup.
-  - Check for physical obstructions.
diff --git a/docs/data-ai/capture-data/upload-other-data.md b/docs/data-ai/capture-data/upload-other-data.md
deleted file mode 100644
index 507f972089..0000000000
--- a/docs/data-ai/capture-data/upload-other-data.md
+++ /dev/null
@@ -1,188 +0,0 @@
----
-linkTitle: "Upload data"
-title: "Upload data to Viam"
-images: ["/services/icons/data-folder.svg"]
-weight: 60
-layout: "docs"
-type: "docs"
-languages: ["python"]
-viamresources: ["data_manager"]
-aliases:
-  - /data/upload/
-  - /services/data/upload/
-  - /how-tos/upload-data/
-  - /data-ai/ai/advanced/upload-external-data/
-  - /data-ai/ai/advanced/
-  - /data-ai/train/upload-external-data/
-date: "2024-12-04"
-updated: "2025-09-11"
-description: "Upload data to Viam from your local computer or mobile device using the data client API, Viam CLI, or Viam mobile app."
----
-
-When you configure the data management service, Viam automatically uploads data from the default directory `~/.viam/capture` and any directory you configured.
-If you want to upload data from another directory or source, you can also:
-
-- [Sync a batch of data from another directory](#sync-data-from-another-directory)
-- [Upload data with SDKs](#upload-data-with-sdks)
-- [Upload images with the Viam mobile app](#upload-images-with-the-viam-mobile-app)
-
-## Sync data from another directory
-
-Typically, you configure the data management service to [capture and sync data from your machine at regular intervals](/data-ai/capture-data/capture-sync/).
-However, you can also use the data management service to sync data from a folder.
-This can be a dataset you wish to upload once or data that is periodically written to a folder on your system.
-
-### Prerequisites
-
-{{% expand "A running machine connected to Viam" %}}
-
-{{% snippet "setup-both.md" %}}
-
-{{% /expand%}}
-
-### Instructions
-
-{{% alert title="Data will be removed from the device once uploaded to Viam" color="caution" %}}
-
-If you do not want the data deleted from your machine, copy the data to a new folder and sync that folder instead so that your local copy remains.
-
-{{% /alert %}}
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Add the data management service**
-
-On your machine's **CONFIGURE** tab, click the **+** icon next to your machine part in the left-hand menu and select **Component or service**.
-
-Select the `data management` service and click **Create**.
-On the data management panel, you can see the configuration options.
-You can leave the default data sync interval of `0.1` minutes to sync every 6 seconds.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Configure sync from the additional folder**
-
-In the **Additional paths**, enter the full path to the directory with the data you want to upload, for example, `/Users/Artoo/my_cat_photos`.
-All of the data in the folder will be synced, so be sure that you want to upload all of the contents of the folder before saving your configuration.
-
-Toggle **Syncing** to on (green) if it isn't already on.
-
-Click **Save** in the top right corner of the page.
-
-{{<imgproc src="/services/data/data-sync-temp.png" resize="x1100" declaredimensions=true alt="Data service configured as described." style="width: 600px" class="shadow imgzoom" >}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Confirm that your data uploaded**
-
-Navigate to your [**DATA** page](https://app.viam.com/data/view) and confirm that your data appears there.
-If you don't see your files yet, wait a few moments and refresh the page.
-
-{{% /tablestep %}}
-{{< /table >}}
-
-## Upload data with SDKs
-
-You can use the [Data Client API](/dev/reference/apis/data-client/) to upload files to the Viam Cloud.
-
-Unlike when using the data management service, using the [`FileUploadFromPath`](/dev/reference/apis/data-client/#fileuploadfrompath) method uploads the files even if they already exist in the cloud.
-In other words, it duplicates data if you run it multiple times.
-
-Also unlike data sync, this method _does not_ delete data from your device.
-
-### Instructions
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Get API key**
-
-Go to your organization's setting page and create an API key for a {{< glossary_tooltip term_id="part" text="machine part" >}}, {{< glossary_tooltip term_id="part" text="machine" >}}, {{< glossary_tooltip term_id="location" text="location" >}}, or {{< glossary_tooltip term_id="organization" text="organization" >}}.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Upload a file from a path**
-
-Use the [`FileUploadFromPath`](/dev/reference/apis/data-client/#fileuploadfrompath) method to upload a file.
-
-You must provide a {{< glossary_tooltip term_id="part" text="machine part" >}} ID to associate data with.
-
-{{< tabs >}}
-{{< tab name="Python" >}}
-
-To upload just one file, make a call to [`file_upload_from_path`](/dev/reference/apis/data-client/#fileuploadfrompath):
-
-{{< read-code-snippet file="/static/include/examples-generated/upload-single-file.snippet.upload-single-file.py" lang="py" class="line-numbers linkable-line-numbers" data-line="31-38" >}}
-
-{{% /tab %}}
-{{< tab name="Go" >}}
-
-{{< read-code-snippet file="/static/include/examples-generated/upload-single-file.snippet.upload-single-file.go" lang="go" class="line-numbers linkable-line-numbers" data-line="33-40" >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Run your code**
-
-Save and run your code once.
-Running your code more than once will duplicate the data.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Confirm that your data uploaded**
-
-Navigate to your [**DATA** page](https://app.viam.com/data/view) and confirm that your data appears there.
-
-{{% /tablestep %}}
-{{< /table >}}
-
-## Upload images with the Viam mobile app
-
-Upload images as machine data straight from your phone, skipping the normal data capture and cloud synchronization process, through the [Viam mobile app](/manage/troubleshoot/teleoperate/default-interface/#viam-mobile-app).
-This is useful if you want to capture images for training machine learning models on the go.
-
-### Prerequisites
-
-{{< expand "Download the Viam mobile app and sign into your Viam account" >}}
-
-Install the mobile app from the [App Store](https://apps.apple.com/vn/app/viam-robotics/id6451424162) or [Google Play](https://play.google.com/store/apps/details?id=com.viam.viammobile&hl=en&gl=US).
-
-<a href="https://apps.apple.com/vn/app/viam-robotics/id6451424162" target="_blank">
-  <img src="/appstore.png" width="200px" alt="apple store icon" class="center-if-small" >
-</a>
-
-<a href="https://play.google.com/store/apps/details?id=com.viam.viammobile&hl=en&gl=US" target="_blank">
-  <img src="/googleplay.png" width="200px" alt="google play store icon" class="center-if-small" >
-</a>
-
-{{< /expand >}}
-
-### Instructions
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Navigate to your machine**
-
-In the Viam mobile app, select an organization by clicking on the menu icon in the top left corner.
-
-Tap the **Locations** tab and select a location, then select the machine you want your data to be associated with.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Upload images**
-
-Tap the menu button marked "**...**" in the upper right corner.
-Tap **Upload Images**.
-
-Select each image you want to upload, then tap **Add**.
-
-The uploaded images metadata will contain the machine part you selected.
-However, the uploaded images will not be associated with a component or method.
-
-{{% /tablestep %}}
-{{< /table >}}
-
-## Next steps
-
-If you uploaded a dataset for machine learning, continue to [create a dataset](/data-ai/train/create-dataset/).
diff --git a/docs/data-ai/data/_index.md b/docs/data-ai/data/_index.md
deleted file mode 100644
index e60a4bd7ac..0000000000
--- a/docs/data-ai/data/_index.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-linkTitle: "Work with data"
-title: "Work with data"
-weight: 150
-layout: "empty"
-type: "docs"
-empty_node: true
-open_on_desktop: true
-header_only: true
-canonical: "/data-ai/data/visualize/"
----
diff --git a/docs/data-ai/data/data-pipelines.md b/docs/data-ai/data/data-pipelines.md
deleted file mode 100644
index 3b75559300..0000000000
--- a/docs/data-ai/data/data-pipelines.md
+++ /dev/null
@@ -1,315 +0,0 @@
----
-linkTitle: "Precompute data pipelines"
-title: "Precompute data pipelines"
-weight: 25
-description: "Create scheduled data pipelines that automatically aggregate and process data."
-type: "docs"
-tags: ["data pipelines", "aggregation", "materialized views"]
-icon: true
-images: ["/services/icons/data-capture.svg"]
-viamresources: ["sensor", "data_manager"]
-platformarea: ["data", "cli"]
-date: "2025-07-02"
-updated: "2025-09-12"
----
-
-Data pipelines automatically transform raw sensor readings into summaries and insights at scheduled intervals.
-Precomputing these results makes subsequent queries more efficient.
-
-For example, you might often query the average temperature across multiple sensors for each hour of the day.
-To make these queries faster, you can use a data pipeline to precalculate the results, saving significant computational resources.
-
-Data pipelines work with all available data, even when the data is incomplete.
-If a machine goes offline, data collection continues but sync pauses.
-`viam-server` stores the data locally and syncs later, when the machine reconnects to Viam.
-Once the machine reconnects and syncs the stored data, Viam automatically re-runs any pipeline whose results would change based on the new data.
-
-## Prerequisites
-
-{{% expand "Captured sensor data" %}}
-
-While not a requirement, it's easier to test data pipelines if you have already enabled data capture from at least one component and begun syncing data with Viam before setting up a pipeline.
-
-See [capture sensor data](/data-ai/capture-data/capture-sync/) to capture and sync data to Viam.
-
-{{% /expand%}}
-
-{{% expand "Owner role" %}}
-
-Only users with [organization owner permissions](/manage/manage/rbac/) can create a data pipeline.
-
-{{% /expand%}}
-
-## Pipeline management
-
-### Create a pipeline
-
-To define a data pipeline, specify a name, the associated organization, a schedule, a data source type, and the query:
-
-{{< tabs >}}
-{{% tab name="CLI" %}}
-
-Use [`datapipelines create`](/dev/tools/cli/#datapipelines):
-
-```sh {class="command-line" data-prompt="$" data-continuation-prompt="2-5"}
-viam datapipelines create \
-  --org-id=<org-id> \
-  --name=sensor-counts \
-  --schedule="0 * * * *" \
-  --data-source-type="standard" \
-  --mql='[{"$match": {"component_name": "sensor"}}, {"$group": {"_id": "$location_id", "avg_temp": {"$avg": "$data.readings.temperature"}, "count": {"$sum": 1}}}, {"$project": {"location": "$_id", "avg_temp": 1, "count": 1, "_id": 0}}]' \
-  --enable-backfill=True
-```
-
-To pass your query as a file instead of specifying it inline, pass the `--mql-path` flag instead of `--mql`.
-
-To create a pipeline that reads data from the [hot data store](/data-ai/data/hot-data-store/), specify `--data-source-type hotstorage`.
-
-{{% /tab %}}
-{{% tab name="Python" %}}
-
-Use [`DataClient.CreateDataPipeline`](/dev/reference/apis/data-client/#createdatapipeline):
-
-{{< read-code-snippet file="/static/include/examples-generated/pipeline-create.snippet.pipeline-create.py" lang="py" class="line-numbers linkable-line-numbers" data-line="31-55" >}}
-
-To create a pipeline that reads data from the [hot data store](/data-ai/data/hot-data-store/), set your query's `data_source` to `TabularDataSourceType.TABULAR_DATA_SOURCE_TYPE_HOT_STORAGE`.
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-Use [`DataClient.CreateDataPipeline`](https://pkg.go.dev/go.viam.com/rdk/app#DataClient.CreateDataPipeline):
-
-{{< read-code-snippet file="/static/include/examples-generated/pipeline-create.snippet.pipeline-create.go" lang="go" class="line-numbers linkable-line-numbers" data-line="47-57" >}}
-
-To create a pipeline that reads data from the [hot data store](/data-ai/data/hot-data-store/), set your query's `data_source` field to `TabularDataSourceType.TABULAR_DATA_SOURCE_TYPE_HOT_STORAGE`.
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-Use [`dataClient.CreateDataPipeline`](/dev/reference/apis/data-client/#createdatapipeline):
-
-{{< read-code-snippet file="/static/include/examples-generated/pipeline-create.snippet.pipeline-create.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="18-29" >}}
-
-To create a pipeline that reads data from the [hot data store](/data-ai/data/hot-data-store/), set your query's `dataSource` field to `TabularDataSourceType.TABULAR_DATA_SOURCE_TYPE_HOT_STORAGE`.
-
-{{% /tab %}}
-{{< /tabs >}}
-
-Once configured, the pipeline will be run based on the defined schedule.
-
-#### Schedule format
-
-To create a schedule for your pipeline, specify a [cron expression](https://en.wikipedia.org/wiki/Cron) in UTC.
-The schedule determines both execution frequency and the range of time queried by each execution.
-The following table contains some common schedules:
-
-| Schedule       | Frequency        | Query Time Range    |
-| -------------- | ---------------- | ------------------- |
-| `0 * * * *`    | Hourly           | Previous hour       |
-| `0 0 * * *`    | Daily            | Previous day        |
-| `*/15 * * * *` | Every 15 minutes | Previous 15 minutes |
-
-#### Query limitations
-
-Data pipeline queries only support a subset of MQL aggregation operators.
-For more information, see [Supported aggregation operators](/data-ai/data/query/#supported-aggregation-operators).
-
-#### Common issues
-
-Non-unique IDs will trigger duplicate key errors, preventing the pipeline from saving subsequent results.
-Avoid returning an `_id` value in your pipeline's final group stage unless you can guarantee its uniqueness across all pipeline runs.
-
-The `$group` stage returns an `_id` value by default.
-To remove it, follow any final `$group` stage with a `$project` stage that renames the `_id` field to a different name.
-
-#### Performance considerations
-
-For optimal performance when querying large datasets, see [query optimization and performance best practices](/data-ai/data/query/#query-optimization-and-performance-best-practices).
-
-### Query pipeline results
-
-Once the pipeline has run at least once, you can query its results.
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-To query the processed results of your data pipeline, call [`DataClient.TabularDataByMQL`](/dev/reference/apis/data-client/#tabulardatabymql), using the following parameters:
-
-- `type`: `TabularDataSourceType.TABULAR_DATA_SOURCE_TYPE_PIPELINE_SINK`
-- `pipeline_id`: your pipeline ID
-
-{{< read-code-snippet file="/static/include/examples-generated/pipeline-query.snippet.pipeline-query.py" lang="py" class="line-numbers linkable-line-numbers" data-line="31-44" >}}
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-To query the processed results of your data pipeline, call [`DataClient.TabularDataByMQL`](https://pkg.go.dev/go.viam.com/rdk/app#DataClient.TabularDataByMQL), using the following parameters:
-
-- `Type`: `app.TabularDataSourceTypePipelineSink`
-- `PipelineId`: your pipeline ID
-
-{{< read-code-snippet file="/static/include/examples-generated/pipeline-query.snippet.pipeline-query.go" lang="go" class="line-numbers linkable-line-numbers" data-line="34-37" >}}
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-To query the processed results of your data pipeline, call [`dataClient.TabularDataByMQL`](/dev/reference/apis/data-client/#tabulardatabymql), using the following parameters:
-
-- `type`: `3`
-- `pipelineId`: your pipeline ID
-
-{{< read-code-snippet file="/static/include/examples-generated/pipeline-query.snippet.pipeline-query.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="19-30" >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-### List pipelines
-
-{{< tabs >}}
-{{% tab name="CLI" %}}
-
-Use [`datapipelines list`](/dev/tools/cli/#datapipelines) to fetch a list of pipeline configurations in an organization:
-
-```sh {class="command-line" data-prompt="$" }
-viam datapipelines list --org-id=<org-id>
-```
-
-{{% /tab %}}
-{{% tab name="Python" %}}
-
-Use [`DataClient.ListDataPipelines`](/dev/reference/apis/data-client/#listdatapipelines) to fetch a list of pipeline configurations in an organization:
-
-{{< read-code-snippet file="/static/include/examples-generated/pipeline-list.snippet.pipeline-list.py" lang="py" class="line-numbers linkable-line-numbers" data-line="30" >}}
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-Use [`DataClient.ListDataPipelines`](https://pkg.go.dev/go.viam.com/rdk/app#DataClient.ListDataPipelines) to fetch a list of pipeline configurations in an organization:
-
-{{< read-code-snippet file="/static/include/examples-generated/pipeline-list.snippet.pipeline-list.go" lang="go" class="line-numbers linkable-line-numbers" data-line="27" >}}
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-Use [`dataClient.ListDataPipelines`](/dev/reference/apis/data-client/#listdatapipelines) to fetch a list of pipeline configurations in an organization:
-
-{{< read-code-snippet file="/static/include/examples-generated/pipeline-list.snippet.pipeline-list.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="18" >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-### Enable a pipeline
-
-{{< tabs >}}
-{{% tab name="CLI" %}}
-
-Use [`datapipelines enable`](/dev/tools/cli/#datapipelines) to enable a disabled data pipeline:
-
-```sh {class="command-line" data-prompt="$"}
-viam datapipelines enable --id=<pipeline-id>
-```
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-Use [`DataClient.EnableDataPipeline`](https://pkg.go.dev/go.viam.com/rdk/app#DataClient.EnableDataPipeline) to enable a disabled data pipeline:
-
-{{< read-code-snippet file="/static/include/examples-generated/pipeline-enable.snippet.pipeline-enable.go" lang="go" class="line-numbers linkable-line-numbers" data-line="27" >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-### Disable a pipeline
-
-Disabling a data pipeline lets you pause data pipeline execution without fully deleting the pipeline configuration from your organization.
-The pipeline immediately stops aggregating data.
-
-You can re-enable the pipeline at any time to resume execution.
-When a pipeline is re-enabled, Viam does not backfill missed time windows from the period of time when a pipeline was disabled.
-
-{{< tabs >}}
-{{% tab name="CLI" %}}
-
-Use [`datapipelines disable`](/dev/tools/cli/#datapipelines) to disable a data pipeline:
-
-```sh {class="command-line" data-prompt="$"}
-viam datapipelines disable --id=<pipeline-id>
-```
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-Use [`DataClient.DisableDataPipeline`](https://pkg.go.dev/go.viam.com/rdk/app#DataClient.DisableDataPipeline) to disable a data pipeline:
-
-{{< read-code-snippet file="/static/include/examples-generated/pipeline-disable.snippet.pipeline-disable.go" lang="go" class="line-numbers linkable-line-numbers" data-line="27" >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-### Delete a pipeline
-
-{{< tabs >}}
-{{% tab name="CLI" %}}
-
-Use [`datapipelines delete`](/dev/tools/cli/#datapipelines) to delete a data pipeline, its execution history, and all output generated by that pipeline:
-
-```sh {class="command-line" data-prompt="$"}
-viam datapipelines delete --id=<pipeline-id>
-```
-
-{{% /tab %}}
-{{% tab name="Python" %}}
-
-Use [`DataClient.DeleteDataPipeline`](/dev/reference/apis/data-client/#deletedatapipeline) to delete a data pipeline:
-
-{{< read-code-snippet file="/static/include/examples-generated/pipeline-delete.snippet.pipeline-delete.py" lang="py" class="line-numbers linkable-line-numbers" data-line="30" >}}
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-Use [`DataClient.DeleteDataPipeline`](https://pkg.go.dev/go.viam.com/rdk/app#DataClient.DeleteDataPipeline) to delete a data pipeline:
-
-{{< read-code-snippet file="/static/include/examples-generated/pipeline-delete.snippet.pipeline-delete.go" lang="go" class="line-numbers linkable-line-numbers" data-line="27" >}}
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-Use [`dataClient.DeleteDataPipeline`](/dev/reference/apis/data-client/#deletedatapipeline) to delete a data pipeline:
-
-{{< read-code-snippet file="/static/include/examples-generated/pipeline-delete.snippet.pipeline-delete.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="18" >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-### View pipeline execution history
-
-Data pipeline executions may have any of the following statuses:
-
-- `SCHEDULED`: pending execution
-- `STARTED`: currently processing
-- `COMPLETED`: successfully finished
-- `FAILED`: execution error
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-Use [`DataClient.ListDataPipelineRuns`](/dev/reference/apis/data-client/#listdatapipelineruns) to view information about past and in-progress executions of a pipeline:
-
-{{< read-code-snippet file="/static/include/examples-generated/pipeline-execution.snippet.pipeline-execution.py" lang="py" class="line-numbers linkable-line-numbers" data-line="30" >}}
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-Use [`DataClient.ListDataPipelineRuns`](https://pkg.go.dev/go.viam.com/rdk/app#DataClient.ListDataPipelineRuns) to view information about past executions of a pipeline:
-
-{{< read-code-snippet file="/static/include/examples-generated/pipeline-execution.snippet.pipeline-execution.go" lang="go" class="line-numbers linkable-line-numbers" data-line="27" >}}
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-Use [`dataClient.ListDataPipelineRuns`](/dev/reference/apis/data-client/#listdatapipelineruns) to view information about past executions of a pipeline:
-
-{{< read-code-snippet file="/static/include/examples-generated/pipeline-execution.snippet.pipeline-execution.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="18" >}}
-
-{{% /tab %}}
-{{< /tabs >}}
diff --git a/docs/data-ai/data/hot-data-store.md b/docs/data-ai/data/hot-data-store.md
deleted file mode 100644
index 9429c4dfff..0000000000
--- a/docs/data-ai/data/hot-data-store.md
+++ /dev/null
@@ -1,110 +0,0 @@
----
-linkTitle: "Speed up recent data queries"
-title: "Speed up recent data queries"
-weight: 25
-description: "Store a rolling window of recent data for fast queries while continuing to write all data to blob storage."
-type: "docs"
-tags: ["hot data store", "aggregation", "materialized views"]
-icon: true
-images: ["/services/icons/data-capture.svg"]
-viamresources: ["sensor", "data_manager"]
-platformarea: ["data", "cli"]
-date: "2024-12-03"
-updated: "2025-09-12"
----
-
-The hot data store stores a rolling window of recent data in a database while continuing to write all data to {{< glossary_tooltip term_id="blob-storage" text="blob storage" >}}.
-Queries to the hot data store execute significantly faster than queries to blob storage.
-
-## Configure
-
-{{< tabs >}}
-{{% tab name="Web UI" %}}
-
-1. Find the resource you are capturing data from on the **CONFIGURE** tab
-2. Click on **Advanced**.
-3. Enable **Sync to Hot Data Store**.
-4. Specify a **Time frame**.
-5. Save.
-
-{{% /tab %}}
-{{% tab name="JSON" %}}
-
-To configure the hot data store, add the `recent_data_store` configuration to your component's data capture settings.
-Set the value of the `stored_hours` field to the number of hours of recent data you would like to store.
-For example, the following configuration stores 24 hours of data in the hot data store:
-
-```json {class="line-numbers linkable-line-numbers" data-line="17-19"}
-{
-  "components": [
-    {
-      "name": "sensor-1",
-      "api": "rdk:component:sensor",
-      "model": "rdk:builtin:fake",
-      "attributes": {},
-      "service_configs": [
-        {
-          "type": "data_manager",
-          "attributes": {
-            "capture_methods": [
-              {
-                "method": "Readings",
-                "capture_frequency_hz": 0.5,
-                "additional_params": {},
-                "recent_data_store": {
-                  "stored_hours": 24
-                }
-              }
-            ]
-          }
-        }
-      ]
-    }
-  ]
-}
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-## Query
-
-Queries execute on blob storage by default, which is slower than queries to a hot data store.
-To query data from the hot data store, you must specify it as the data source in your queries.
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-Use [`DataClient.TabularDataByMQL`](/dev/reference/apis/data-client/#tabulardatabymql) with `data_source` set to `TabularDataSourceType.TABULAR_DATA_SOURCE_TYPE_HOT_STORAGE` to query your hot data store:
-
-{{< read-code-snippet file="/static/include/examples-generated/query.snippet.pipeline-query.py" lang="py" class="line-numbers linkable-line-numbers" data-line="" >}}
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-Use [`DataClient.TabularDataByMQL`](https://pkg.go.dev/go.viam.com/rdk/app#DataClient.TabularDataByMQL) with `DataSource` set to `datapb.TabularDataSourceType_TABULAR_DATA_SOURCE_TYPE_HOT_STORAGE` to query your hot data store:
-
-{{< read-code-snippet file="/static/include/examples-generated/query.snippet.pipeline-query.go" lang="go" class="line-numbers linkable-line-numbers" data-line="" >}}
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-Use [`dataClient.TabularDataByMQL`](/dev/reference/apis/data-client/#tabulardatabymql) with `dataSource` set to `TabularDataSourceType.TABULAR_DATA_SOURCE_TYPE_HOT_STORAGE` to query your hot data store:
-
-{{< read-code-snippet file="/static/include/examples-generated/query.snippet.pipeline-query.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="" >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{< alert title="Caution" color="caution" >}}
-
-Queries to the hot data store _only_ return data from the hot data store, which only contains data from the time window you specified in your configuration.
-For example, if you query a hot data store which has 24 hours of the most recent data for temperature data above 25C, and no temperature above 25C was recorded in the last 24 hours, your query would return zero results even if other readings outside that time period contain readings above 25C.
-To query the entire history of your data, use blob storage as the data source in queries.
-
-{{< /alert >}}
-
-### Query limitations
-
-Hot data store queries only support a subset of MQL aggregation operators.
-For more information, see [Supported aggregation operators](/data-ai/data/query/#supported-aggregation-operators).
diff --git a/docs/data-ai/data/query.md b/docs/data-ai/data/query.md
deleted file mode 100644
index b54156e423..0000000000
--- a/docs/data-ai/data/query.md
+++ /dev/null
@@ -1,519 +0,0 @@
----
-linkTitle: "Query data"
-title: "Query data"
-weight: 22
-layout: "docs"
-type: "docs"
-aliases:
-  - /manage/data/query/
-  - /data/query/
-  - /use-cases/sensor-data-query/
-  - /use-cases/sensor-data-query-with-third-party-tools/
-  - /how-tos/sensor-data-query-with-third-party-tools/
-languages: []
-viamresources: ["sensor", "data_manager"]
-platformarea: ["data", "core"]
-date: "2024-12-03"
-updated: "2025-09-12"
-description: "Query sensor data in Viam with SQL or MQL."
----
-
-You can query all sensor data in Viam using {{< glossary_tooltip term_id="sql" text="SQL" >}} and {{< glossary_tooltip term_id="mql" text="MQL" >}}.
-For example, you may sync temperature data from several sensors on one machine or across multiple machines.
-Once synced, you can run queries against that data to search for outliers or edge cases and analyze how the ambient temperature affects your machines' operation.
-
-## Query using Viam
-
-### Prerequisites
-
-{{% expand "Captured sensor data" %}}
-
-See [capture sensor data](/data-ai/capture-data/capture-sync/) to capture and sync data to Viam.
-
-{{% /expand%}}
-
-{{% expand "Owner role" %}}
-
-Only users with [owner permissions](/manage/manage/rbac/) can query data.
-
-{{% /expand%}}
-
-### Query data using Viam
-
-You can query data using the Web UI or with code:
-
-{{< tabs >}}
-{{% tab name="Web UI" %}}
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Query with SQL or MQL**
-
-Navigate to the [**Query** page](https://app.viam.com/data/query).
-Then, select either **SQL** or **MQL**.
-
-Optionally, you can change the data source to query data from a configured [hot data store](/data-ai/data/hot-data-store/).
-
-{{< alert title="Tip: Query Assistant" color="tip" >}}
-For help with writing queries, use the **Query Assistant** button in the top right corner.
-{{< /alert >}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Run your query**
-
-This example query returns the last 5 readings from any component named `sensor-1` in your organization:
-
-{{< tabs >}}
-{{% tab name="SQL" %}}
-
-```sql
-SELECT * FROM readings
-WHERE component_name = 'sensor-1' LIMIT 5
-```
-
-{{% /tab %}}
-{{% tab name="MQL" %}}
-
-Select the **Stages** or **Text** mode:
-
-{{< tabs >}}
-{{% tab name="Stages" %}}
-
-1. Select the `$match` stage for **Stage 1** from the dropdown.
-1. Add the expression to match against:
-
-   ```json
-   { "component_name": "sensor-1" }
-   ```
-
-1. Click **+ Add query stage** to add another aggregation stage.
-1. Select the `$limit` stage for **Stage 2** from the dropdown.
-1. Add the number of documents to limit to:
-
-   ```json
-   5
-   ```
-
-{{% /tab %}}
-{{% tab name="Text" %}}
-
-Add the query in the text field:
-
-```mql
-[
-    { "$match": { "component_name": "sensor-1" } },
-    { "$limit": 5 }
-]
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% expand "Click to see an example that filters by component name and column names." %}}
-
-{{< tabs >}}
-{{% tab name="SQL" %}}
-
-```sh {class="command-line" data-prompt="$" data-output="3-80"}
-SELECT time_received, data, tags FROM readings
-WHERE component_name = 'sensor-1' LIMIT 2
-[
-{
-  "time_received": "2024-07-30 00:04:02.144 +0000 UTC",
-  "data": {
-    "readings": {
-      "units": "μg/m³",
-      "pm_10": 7.6,
-      "pm_2.5": 5.7
-    }
-  },
-  "tags": [
-    "air-quality"
-  ]
-},
-{
-  "time_received": "2024-07-30 00:37:22.192 +0000 UTC",
-  "data": {
-    "readings": {
-      "pm_2.5": 9.3,
-      "units": "μg/m³",
-      "pm_10": 11.5
-    }
-  },
-  "tags": [
-    "air-quality"
-  ]
-}
-]
-```
-
-{{% /tab %}}
-{{% tab name="MQL" %}}
-
-```sh {class="command-line" data-prompt="$" data-output="16-80"}
-[
-  {
-    $match: {
-      component_name: "sensor-1"
-    }
-  }, {
-    $limit: 2
-  }, {
-    $project: {
-        time_received: 1,
-        data: 1,
-        tags: 1
-    }
-  }
-]
-[
-{
-  "time_received": "2024-07-30 00:04:02.144 +0000 UTC",
-  "data": {
-    "readings": {
-      "units": "μg/m³",
-      "pm_10": 7.6,
-      "pm_2.5": 5.7
-    }
-  },
-  "tags": [
-    "air-quality"
-  ]
-},
-{
-  "time_received": "2024-07-30 00:37:22.192 +0000 UTC",
-  "data": {
-    "readings": {
-      "pm_2.5": 9.3,
-      "units": "μg/m³",
-      "pm_10": 11.5
-    }
-  },
-  "tags": [
-    "air-quality"
-  ]
-}
-]
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /expand %}}
-{{% expand "Click to see an example that returns a count of records that match a component name." %}}
-
-{{< tabs >}}
-{{% tab name="SQL" %}}
-
-```sh {class="command-line" data-prompt="$" data-output="3-80"}
-SELECT count(*) FROM readings
-WHERE component_name = 'sensor-1'
-[
-  {
-    "_1": 111550
-  }
-]
-```
-
-{{% /tab %}}
-{{% tab name="MQL" %}}
-
-```sh {class="command-line" data-prompt="$" data-output="11"}
-[
-  {
-    $match: {
-      component_name: "sensor-1"
-    }
-  }, {
-    $count: "count"
-  }
-]
-{ count: 111550 }
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /expand %}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Review results**
-
-Click **Run query** when ready to perform your query and get matching results.
-You can view your query results as a [JSON array](https://json-schema.org/understanding-json-schema/reference/array) below your query.
-Click the table icon to switch to table view.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Save query**
-
-Optionally, you can save queries in the web UI.
-Click on **Saved** and then **Save current query**.
-Fill in a **Name** for your query and click **Save query**.
-
-{{% /tablestep %}}
-{{< /table >}}
-
-{{% /tab %}}
-{{% tab name="Python" %}}
-
-{{< read-code-snippet file="/static/include/examples-generated/data-query.snippet.data-query.py" lang="py" class="line-numbers linkable-line-numbers" data-line="29-47" >}}
-
-{{< expand "Click to see an example that filters by component name and column names." >}}
-
-{{% read-code-snippet file="/static/include/examples-generated/data-query-examples.snippet.data-query-filter.py" lang="py" class="line-numbers linkable-line-numbers" %}}
-
-{{< /expand >}}
-{{< expand "Click to see an example that returns a count of records that match a component name." >}}
-
-{{< read-code-snippet file="/static/include/examples-generated/data-query-examples.snippet.data-query-count.py" lang="py" class="line-numbers linkable-line-numbers" >}}
-
-{{< /expand >}}
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-{{< read-code-snippet file="/static/include/examples-generated/data-query.snippet.data-query.go" lang="go" class="line-numbers linkable-line-numbers" data-line="28-45" >}}
-
-{{< expand "Click to see an example that filters by component name and column names." >}}
-
-{{< read-code-snippet file="/static/include/examples-generated/data-query-examples.snippet.data-query-filter.go" lang="go" class="line-numbers linkable-line-numbers" >}}
-
-{{< /expand >}}
-{{< expand "Click to see an example that returns a count of records that match a component name." >}}
-
-{{< read-code-snippet file="/static/include/examples-generated/data-query-examples.snippet.data-query-count.go" lang="go" class="line-numbers linkable-line-numbers" >}}
-
-{{< /expand >}}
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-{{< read-code-snippet file="/static/include/examples-generated/data-query.snippet.data-query.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="18-31" >}}
-
-{{< expand "Click to see an example that filters by component name and column names." >}}
-
-{{< read-code-snippet file="/static/include/examples-generated/data-query-examples.snippet.data-query-filter.ts" lang="ts" class="line-numbers linkable-line-numbers" >}}
-
-{{< /expand >}}
-{{< expand "Click to see an example that returns a count of records that match a component name." >}}
-
-{{< read-code-snippet file="/static/include/examples-generated/data-query-examples.snippet.data-query-count.ts" lang="ts" class="line-numbers linkable-line-numbers" >}}
-
-{{< /expand >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-## Query using third-party tools
-
-### Prerequisites
-
-{{% expand "Captured sensor data" %}}
-
-See [capture sensor data](/data-ai/capture-data/capture-sync/) to capture and sync data to Viam.
-
-{{% /expand%}}
-
-{{% expand "Viam CLI" %}}
-
-You must have the Viam CLI installed to configure querying with third-party tools.
-
-{{< readfile "/static/include/how-to/install-cli.md" >}}
-
-{{% /expand%}}
-
-{{% expand "Third-party tool for querying data (such as mongosh)" %}}
-
-[Download the `mongosh` shell](https://www.mongodb.com/try/download/shell) or another third-party tool that can connect to a MongoDB data source.
-
-See the [`mongosh` documentation](https://www.mongodb.com/docs/mongodb-shell/) for more information.
-
-{{% /expand%}}
-
-### Configure data query
-
-If you want to query data from third-party tools, you have to configure data query to obtain the credentials you need to connect to the third-party service.
-
-{{< readfile "/static/include/how-to/query-data.md" >}}
-
-### Query data using third-party tools
-
-To query captured data, you can use any third-party tools that support querying from MongoDB, such as the [`mongosh` shell](https://www.mongodb.com/docs/mongodb-shell/) or [MongoDB Compass](https://www.mongodb.com/docs/compass/current/).
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Connect to your Viam organization's data**
-
-Run the following command to connect to your Viam organization's MongoDB instance from `mongosh` using the connection URI you obtained during query configuration:
-
-```sh {class="command-line" data-prompt=">"}
-mongosh "mongodb://db-user-abcd1e2f-a1b2-3c45-de6f-ab123456c123:YOUR-PASSWORD-HERE@data-federation-abcd1e2f-a1b2-3c45-de6f-ab123456c123-0z9yx.a.query.mongodb.net/?ssl=true&authSource=admin"
-```
-
-For information on connecting to your Atlas Data Federation instance from other MQL clients, see the [Connect to your Cluster Tutorial](https://www.mongodb.com/docs/atlas/tutorial/connect-to-your-cluster/).
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Query data from a compatible client**
-
-Once connected, you can run SQL or MQL statements to query captured data directly.
-
-The following query searches the `readings` collection in the `sensorData` database and gets sensor readings from an ultrasonic sensor on a specific `robot_id` where the recorded `distance` measurement is greater than `0.2` meters.
-
-{{< tabs >}}
-{{% tab name="MQL" %}}
-
-```mongodb {class="command-line" data-prompt=">" data-output="10"}
-use sensorData
-db.readings.aggregate(
-    [
-        { $match: {
-            'robot_id': 'abcdef12-abcd-abcd-abcd-abcdef123456',
-            'component_name': 'my-ultrasonic-sensor',
-            'data.readings.distance': { $gt: 0.2 } } },
-        { $count: 'numStanding' }
-    ] )
-[ { numStanding: 215 } ]
-```
-
-See the [MQL documentation](https://www.mongodb.com/docs/manual/tutorial/query-documents/) for more information.
-
-{{% /tab %}}
-{{% tab name="SQL" %}}
-
-```mongodb {class="command-line" data-prompt=">" data-output="11"}
-use sensorData
-db.aggregate(
-[
-    { $sql: {
-        statement: "select count(*) as numStanding from readings \
-            where robot_id = 'abcdef12-abcd-abcd-abcd-abcdef123456' and \
-            component_name = 'my-ultrasonic-sensor' and (CAST (data.readings.distance AS DOUBLE)) > 0.2",
-        format: "jdbc"
-    }}
-] )
-[ { '': { numStanding: 215 } } ]
-```
-
-See the [`$sql` aggregation pipeline stage documentation](https://www.mongodb.com/docs/atlas/data-federation/supported-unsupported/pipeline/sql/) for more information.
-
-{{% /tab %}}
-{{< /tabs >}}
-
-<!-- markdownlint-disable-file MD001 -->
-
-{{< expand "Need to query by date? Click here." >}}
-
-##### Query by date
-
-When using MQL to query your data by date or time range, you can optimize query performance by avoiding the MongoDB `$toDate` expression, using the [BSON `date` type](https://www.mongodb.com/docs/manual/reference/bson-types/#date) instead.
-
-For example, use the following query to search by a date range in the `mongosh` shell.
-Use the JavaScript `Date()` constructor to specify an explicit start timestamp and the current time as the end timestamp:
-
-```mongodb {class="command-line" data-prompt=">"}
-// Switch to sensorData database:
-use sensorData
-
-// Set desired start and end times:
-const startTime = new Date('2024-02-10T19:45:07.000Z')
-const endTime = new Date()
-
-// Run query using $match:
-db.readings.aggregate(
-    [
-        { $match: {
-            time_received: {
-                $gte: startTime,
-                $lte: endTime }
-        } }
-    ] )
-```
-
-{{< /expand>}}
-
-{{% /tablestep %}}
-{{< /table >}}
-
-## Query optimization and performance best practices
-
-1. When querying large datasets, whether from default storage or a [hot data store](/data-ai/data/hot-data-store/), you can improve the query's efficiency by specifying the following parameters in the query:
-
-   - `organization_id`
-   - `location_id`
-   - `machine_id`
-   - `part_id`
-   - `component_type`
-   - `component_name`
-   - `method_name`
-   - `capture_date`
-
-   Viam stores data in blob storage using the pattern `/organization_id/location_id/robot_id/part_id/component_type/component_name/method_name/capture_date/*`.
-   The more specific you can be, starting with the beginning of the path, the faster your query.
-
-1. Filter and reduce the amount of data that needs to be processed early, especially when your query expands the data it works with using operators like `$limit` and `$unwind`.
-   If you don't need all fields, use `$project` early to reduce the fields in the processing dataset.
-   If you only need a certain number of results, use `$limit` early in the pipeline to reduce data processing.
-
-1. If you are frequently querying recent data, use the [hot data store](/data-ai/data/hot-data-store/) which provides faster data access.
-
-1. If you frequently perform the same types of queries, for example for dashboards, use [data pipelines](/data-ai/data/data-pipelines/).
-   Data pipelines allow you to pre-compute a materialized view of your data at specified intervals.
-
-## Supported query languages
-
-### MQL
-
-Viam supports the [MongoDB Query Language](https://www.mongodb.com/docs/manual/tutorial/query-documents/) for querying captured data from MQL-compatible clients such as `mongosh` or MongoDB Compass.
-
-#### Supported aggregation operators
-
-Viam supports the following MongoDB aggregation operators:
-
-<!--
-see whitelistStages in https://github.com/viamrobotics/app/blob/e706a2e3ea57a252f102b37e0ab2b9d6eeed51e0/datamanagement/tabular_data_by_query.go#L64
--->
-
-- `$addFields`
-- `$bucket`
-- `$bucketAuto`
-- `$count`
-- `$densify`
-- `$fill`
-- `$geoNear`
-- `$group`
-- `$limit`
-- `$match`
-- `$project`
-- `$redact`
-- `$replaceRoot`
-- `$replaceWith`
-- `$sample`
-- `$set`
-- `$setWindowFields`
-- `$skip`
-- `$sort`
-- `$sortByCount`
-- `$unset`
-- `$unwind`
-
-### SQL
-
-You can query data with SQL queries using the [MongoDB Atlas SQL dialect](https://www.mongodb.com/docs/atlas/data-federation/query/sql/language-reference/#compatibility-and-limitations), which supports standard SQL query syntax in addition to Atlas-specific capabilities such as `FLATTEN` and `UNWIND`.
-
-SQL queries are subject to the following limitations:
-
-- If a database, table, or column identifier meets any of the following criteria, you must surround the identifier with backticks (`` ` ``) or double quotes (`"`):
-  - begins with a digit (for example `1`)
-  - begins with a [reserved character](https://www.postgresql.org/docs/current/functions-matching.html) (for example `%`)
-  - conflicts with a [reserved SQL keyword](https://en.wikipedia.org/wiki/List_of_SQL_reserved_words) (for example `select`)
-- To include a single quote character in a string literal, use two single quotes (use `o''clock` to represent the literal `o'clock`).
-- The `date` data type is not supported. Use `timestamp` instead.
-
-For a full list of limitations, see the [MongoDB Atlas SQL Interface Language Reference](https://www.mongodb.com/docs/atlas/data-federation/query/sql/language-reference/#compatibility-and-limitations).
diff --git a/docs/data-ai/data/visualize.md b/docs/data-ai/data/visualize.md
deleted file mode 100644
index ea37967f96..0000000000
--- a/docs/data-ai/data/visualize.md
+++ /dev/null
@@ -1,307 +0,0 @@
----
-linkTitle: "Visualize data"
-title: "Visualize data"
-weight: 20
-layout: "docs"
-type: "docs"
-images: ["/services/icons/data-visualization.svg"]
-icon: true
-aliases:
-  - /data/visualize/
-  - /use-cases/sensor-data-visualize/
-  - /how-tos/sensor-data-visualize/
-  - /how-tos/configure-teleop-workspace/
-  - /tutorials/services/visualize-data-grafana/
-viamresources: ["sensor", "data_manager"]
-platformarea: ["data", "fleet"]
-date: "2024-12-04"
-updated: "2025-09-10"
-description: "Use teleop or Grafana to visualize captured sensor data."
----
-
-Once you have used the data management service to [capture data](/data-ai/capture-data/capture-sync/), you can visualize your data using
-
-- a [Teleop](#teleop-dashboard) dashboard
-- a variety of [third-party tools](#third-party-tools), including Grafana, Tableau, Google's Looker Studio, and more
-
-## Teleop dashboard
-
-Create a dashboard to visualize data for machines in your organization.
-
-### Prerequisites
-
-{{% expand "A machine with at least one sensor, camera, or other component that captures data" %}}
-
-Make sure your machine is configured with at least one component that can capture data, for example:
-
-- [Sensor](/operate/reference/components/sensor/)
-- [Movement sensor](/operate/reference/components/movement-sensor/)
-- [Camera](/operate/reference/components/camera/)
-
-{{% /expand%}}
-
-### Create a workspace
-
-1. Navigate to the **FLEET** page's [**TELEOP** tab](https://app.viam.com/teleop).
-   Click **+ Create workspace**.
-
-1. Enter a unique name for your workspace in the top left of the page, replacing the placeholder `untitled-workspace` text.
-
-1. Use the **Select location** dropdown to select the location that contains the machine that you would like to visualize data from.
-
-1. Use the **Select machine** dropdown to select the machine that you would like to visualize data from.
-
-### Add a widget
-
-1. Click **Add widget** and select a widget type to create a new widget on your workspace.
-
-   See [widget types](/manage/troubleshoot/teleoperate/custom-interface/#widget-types) for more information about each type.
-
-1. To configure the widget, click the pencil icon in the top right of your widget:
-
-   {{<imgproc src="/services/data/visualize-widget-configure.png" alt="Click the pencil icon to configure your widget." style="width:500px" resize="1200x" class="imgzoom fill shadow" >}}
-
-You can mix and match multiple widgets to visualize many kinds of data collected by your machine:
-
-{{<imgproc src="/services/data/visualize-workspace.png" resize="1200x" style="width: 700px" class="fill imgzoom shadow" declaredimensions=true alt="Workspace containing multiple widgets displaying sensor data visualizations.">}}
-
-To arrange widgets on your workspace, click and drag the grid icon in the top left of your widget:
-
-{{<imgproc src="/services/data/visualize-widget-move.png" alt="Click the grid icon to move a widget." style="width:500px" resize="1200x" class="imgzoom fill shadow" >}}
-
-## Third party tools
-
-When you sync captured data to Viam, that data is stored in a MongoDB Atlas Data Federation instance.
-You can use third-party visualization tools, such as Grafana, to connect to it and visualize your data, as long as the tool supports [MongoDB Atlas Data Federation](https://www.mongodb.com/docs/atlas/data-federation/query/sql/connect/) as a data store.
-
-To use a third-party visualization tool like Grafana to visualize your data, you must first [configure data query](#configure-data-query).
-
-### Prerequisites
-
-{{% expand "Captured sensor data. Click to see instructions." %}}
-
-Follow the docs to [capture data](/data-ai/capture-data/capture-sync/) from a sensor.
-
-{{% /expand%}}
-
-{{% expand "The Viam CLI to set up data query. Click to see instructions." %}}
-
-You must have the Viam CLI installed to configure querying with third-party tools.
-
-{{< readfile "/static/include/how-to/install-cli.md" >}}
-
-{{% /expand%}}
-
-### Configure data query
-
-Configuring data query will provide you with the credentials you need to connect to your data using a compatible client such as `mongosh`, Grafana, or a third-party visualization service.
-
-{{< readfile "/static/include/how-to/query-data.md" >}}
-
-{{< alert title="Tip" color="tip" >}}
-You may find it useful to browse your data first, before creating a visualization dashboard based on it.
-We recommend [MongoDB Compass](https://www.mongodb.com/products/tools/compass) to connect to your Viam data store.
-Once connected, browse your data using Compass' [Schema Analyzer](https://www.mongodb.com/docs/compass/current/schema/) to see the types of data you have available.
-{{< /alert >}}
-
-### Visualize data with third-party tools
-
-You can use the connection information you obtained when [configuring data query](#configure-data-query) with any third-party tool that supports MongoDB Atlas Data Federation as its data store.
-
-Once connected, you can visualize captured sensor readings as well as any other time-series data, including metadata such as machine ID, organization ID, and tags.
-
-Below are the steps for [Grafana](#grafana) and for [other visualization tools](#other-visualization-tools).
-
-#### Grafana
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Choose Grafana instance**
-
-[Install](https://grafana.com/docs/grafana/latest/setup-grafana/installation/) or set up Grafana.
-You can use either a local instance of Grafana Enterprise or Grafana Cloud.
-The free trial version of Grafana Cloud is sufficient for testing.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Install connector to MongoDB data source**
-
-Navigate to your Grafana web UI.
-Go to **Connections > Add new connection** and add the [Grafana MongoDB data source](https://grafana.com/grafana/plugins/grafana-mongodb-datasource/) plugin to your Grafana instance.
-
-{{% alert title="Note" color="note" %}}
-Be sure to install the MongoDB _data source_, not the _integration_.
-{{% /alert %}}
-
-{{<imgproc src="/tutorials/visualize-data-grafana/search-grafana-plugins.png" resize="800x" style="width: 500px" declaredimensions=true alt="The Grafana plugin search interface showing the results for a search for mongodb" class="shadow imgzoom" >}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Configure a data connection**
-
-On the page of the Grafana MongoDB data source that you just installed, select **Add new data source**.
-
-Enter the following information in the configuration UI for the plugin:
-
-- **Connection string**: Enter the following connection string.
-  Then replace `<MONGODB-ATLAS-DF-HOSTNAME>` with your database hostname as configured with the `viam data database configure` command.
-  The `<DATABASE-NAME>` for sensor data is `sensorData`.
-
-  ```sh {class="command-line" data-prompt="$"}
-  mongodb://<MONGODB-ATLAS-DF-HOSTNAME>/<DATABASE-NAME>?directConnection=true&authSource=admin&tls=true
-  ```
-
-- **User**: Enter the following username, substituting your organization ID for `<YOUR-ORG-ID>`:
-
-  ```sh {class="command-line" data-prompt="$"}
-  db-user-<YOUR-ORG-ID>
-  ```
-
-- **Password**: Enter the password for the database user.
-  This is the password provided when configuring data query.
-
-  {{<imgproc src="/tutorials/visualize-data-grafana/configure-grafana-mongodb-datasource.png" resize="800x" style="width: 500px" declaredimensions=true alt="The Grafana data source plugin configuration page, showing the connection string and username filled in with the configuration determined from the previous steps" class="shadow imgzoom" >}}
-
-For more information on the Grafana MongoDB plugin, see [Configure the MongoDB data source](https://grafana.com/docs/plugins/grafana-mongodb-datasource/latest/configure/).
-
-{{< /tablestep >}}
-{{% tablestep %}}
-**Use Grafana for dashboards**
-
-With your data connection established, Grafana can now access all synced sensor data under your [organization](/dev/reference/glossary/#organization), from any machine.
-
-You can now build dashboards that provide insight into your data.
-
-You can also [query and transform your data](https://grafana.com/docs/grafana/latest/panels-visualizations/query-transform-data/).
-This way, you can visualize different things, such as:
-
-- a single day's data
-- a single machine's or component's data
-- outliers in your data
-
-{{% expand "Click here for resources on building a Grafana Dashboard." %}}
-
-- Local Grafana instance: [Build your first dashboard](https://grafana.com/docs/grafana/latest/getting-started/build-first-dashboard/)
-- Grafana Cloud: [Create a dashboard in Grafana Cloud](https://grafana.com/docs/grafana-cloud/visualizations/dashboards/build-dashboards/create-dashboard/)
-
-{{% /expand%}}
-
-{{< /tablestep >}}
-{{% tablestep %}}
-**Query data from Grafana**
-
-You can also use query language directly in Grafana using the [MongoDB Query Editor](https://grafana.com/docs/plugins/grafana-mongodb-datasource/latest/query-editor/), which enables data query functionality similar to that of the MongoDB shell, `mongosh`.
-
-For example, try the following query to obtain readings from a sensor, replacing `sensor-1` with the name of your component:
-
-```mql
-sensorData.readings.aggregate([
-  {
-    $match: {
-      component_name: "sensor-1",
-      time_received: { $gte: ISODate(${__from}) }
-    }
-  },
-  { $limit: 1000 }
-])
-```
-
-This query uses the Grafana global variable `$__from`, which is populated by the value set from the `From` dropdown menu on your dashboard.
-The value is dynamically updated when you change your desired time range from that dropdown menu.
-See Grafana's [Global variables documentation](https://grafana.com/docs/grafana/latest/dashboards/variables/add-template-variables/#global-variables) for more information.
-
-{{< /tablestep >}}
-{{% tablestep %}}
-**Optimize your queries**
-
-For optimal performance when querying large datasets, see [query optimization and performance best practices](/data-ai/data/query/#query-optimization-and-performance-best-practices).
-
-<!-- markdownlint-disable-file MD034 -->
-
-{{% /tablestep %}}
-{{< /table >}}
-
-#### Other visualization tools
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Install connector to MongoDB data source**
-
-Some visualization clients are able to connect to the Viam MongoDB Atlas Data Federation instance natively, while others require that you install and configure an additional plugin or connector.
-For example, Tableau requires both the [Atlas SQL JDBC Driver](https://www.mongodb.com/try/download/jdbc-driver) as well as the [Tableau Connector](https://www.mongodb.com/try/download/tableau-connector) in order to successfully connect and access data.
-
-Check with the documentation for your third-party visualization tool to be sure you have the required additional software installed to connect to a MongoDB Atlas Data Federation instance.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Configure a data connection**
-
-Most third-party visualization tools require the _connection URI_ (also called the connection string) to that database server, and the _credentials_ to authenticate to that server in order to visualize your data.
-Some third-party tools instead require a _hostname_ and _database name_ of the database server.
-This is what they look like:
-
-{{< tabs >}}
-{{% tab name="Connection URI and credentials" %}}
-
-If your client supports a connection URI, use the following format and replace `YOUR-PASSWORD-HERE` with your database password as configured with the `viam data database configure` command:
-
-```sh {class="command-line" data-prompt="$"}
-mongodb://db-user-abcdef12-abcd-abcd-abcd-abcdef123456:YOUR-PASSWORD-HERE@data-federation-abcdef12-abcd-abcd-abcd-abcdef123456-e4irv.a.query.mongodb.net/?ssl=true&authSource=admin
-```
-
-You can also specify a database name in your connection URI.
-For example, to use the `sensorData` database, the default database name for uploaded sensor data, your connection string would resemble:
-
-```sh {class="command-line" data-prompt="$"}
-mongodb://db-user-abcdef12-abcd-abcd-abcd-abcdef123456:YOUR-PASSWORD-HERE@data-federation-abcdef12-abcd-abcd-abcd-abcdef123456-e4irv.a.query.mongodb.net/sensorData?ssl=true&authSource=admin
-```
-
-{{% /tab %}}
-{{% tab name="Hostname and database name" %}}
-
-If your client doesn't use a connection URI, you can supply the hostname and database name of the database server instead.
-
-Substitute the hostname returned from the `viam data database hostname` command for `<MONGODB-ATLAS-DF-HOSTNAME>` and the desired database name to query for `<DATABASE-NAME>`:
-
-```sh {class="command-line" data-prompt="$"}
-mongodb://<MONGODB-ATLAS-DF-HOSTNAME>/<DATABASE-NAME>?directConnection=true&authSource=admin&tls=true
-```
-
-For example, to use the `sensorData` database, the default name for uploaded data, your connection string would resemble:
-
-```sh {class="command-line" data-prompt="$"}
-mongodb://data-federation-abcdef12-abcd-abcd-abcd-abcdef123456-e4irv.a.query.mongodb.net/sensorData?directConnection=true&authSource=admin&tls=true
-```
-
-Your database user name is of the following form:
-
-```sh {class="command-line" data-prompt="$"}
-db-user-<YOUR-ORG-ID>
-```
-
-Substitute your organization ID for `<YOUR-ORG-ID>`.
-
-{{< /tab >}}
-{{% /tabs %}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Use visualization tools for dashboards**
-
-Some third-party visualization tools support the ability to directly query your data within their platform to generate more granular visualizations of specific data.
-If available, you can use this functionality to visualize different things, such as:
-
-- a single day's data
-- a single machine's or component's data
-- outliers in your data
-
-While every third-party tool is different, you would generally query your data using either {{< glossary_tooltip term_id="sql" text="SQL" >}} or {{< glossary_tooltip term_id="mql" text="MQL" >}}.
-See the [guide on querying data](/data-ai/data/query/) for more information.
-For optimal performance when querying large datasets, see the [query optimization and performance best practices](/data-ai/data/query/#query-optimization-and-performance-best-practices) section.
-
-<!-- markdownlint-disable-file MD034 -->
-
-{{% /tablestep %}}
-{{< /table >}}
-
-{{<youtube embed_url="https://www.youtube-nocookie.com/embed/CGq3XIRQjUQ">}}
diff --git a/docs/data-ai/reference/_index.md b/docs/data-ai/reference/_index.md
deleted file mode 100644
index 84565a4cba..0000000000
--- a/docs/data-ai/reference/_index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-linkTitle: "Reference"
-title: "Reference"
-weight: 500
-layout: "empty"
-type: "docs"
-empty_node: true
-header_only: true
-canonical: "/data-ai/reference/architecture/"
----
diff --git a/docs/data-ai/reference/architecture.md b/docs/data-ai/reference/architecture.md
deleted file mode 100644
index b6bb44b289..0000000000
--- a/docs/data-ai/reference/architecture.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-linkTitle: "Machine-cloud architecture"
-title: "Viam architecture"
-weight: 900
-type: "docs"
-layout: "empty"
-canonical: "/operate/reference/architecture/"
----
diff --git a/docs/data-ai/reference/data-client.md b/docs/data-ai/reference/data-client.md
deleted file mode 100644
index e283551be4..0000000000
--- a/docs/data-ai/reference/data-client.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: "Upload and retrieve data with Viam's data client API"
-linkTitle: "Data client API"
-weight: 30
-type: "docs"
-layout: "empty"
-canonical: "/dev/reference/apis/data-client/"
----
diff --git a/docs/data-ai/reference/data-management-client.md b/docs/data-ai/reference/data-management-client.md
deleted file mode 100644
index 9b25725d0b..0000000000
--- a/docs/data-ai/reference/data-management-client.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: "Data management API"
-linkTitle: "Data management API"
-weight: 30
-type: "docs"
-layout: "empty"
-canonical: "/dev/reference/apis/services/data/"
----
diff --git a/docs/data-ai/reference/glossary.md b/docs/data-ai/reference/glossary.md
deleted file mode 100644
index c1b9504bcd..0000000000
--- a/docs/data-ai/reference/glossary.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: "Glossary"
-linkTitle: "Glossary"
-weight: 999
-type: "docs"
-layout: "empty"
-canonical: "/dev/reference/glossary/"
----
diff --git a/docs/data-ai/reference/ml-model-client.md b/docs/data-ai/reference/ml-model-client.md
deleted file mode 100644
index beeb82c808..0000000000
--- a/docs/data-ai/reference/ml-model-client.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: "ML model API"
-linkTitle: "ML model API"
-weight: 30
-type: "docs"
-layout: "empty"
-canonical: "/dev/reference/apis/services/ml/"
----
diff --git a/docs/data-ai/reference/ml-training-client.md b/docs/data-ai/reference/ml-training-client.md
deleted file mode 100644
index 60053e550e..0000000000
--- a/docs/data-ai/reference/ml-training-client.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: "Work with ML training jobs with Viam's ML training API"
-linkTitle: "ML training client API"
-weight: 40
-type: "docs"
-layout: "empty"
-canonical: "/dev/reference/apis/services/ml/"
----
diff --git a/docs/data-ai/reference/mlmodel-design.md b/docs/data-ai/reference/mlmodel-design.md
deleted file mode 100644
index 44c8a54384..0000000000
--- a/docs/data-ai/reference/mlmodel-design.md
+++ /dev/null
@@ -1,134 +0,0 @@
----
-title: "Design your ML models for vision"
-linkTitle: "ML model service design"
-weight: 60
-type: "docs"
-tags: ["data management", "ml", "model training", "vision"]
-description: "Design your ML Model service to work with Viam's vision services."
-icon: true
-images: ["/services/icons/ml.svg"]
-date: "2022-01-01"
-# updated: ""  # When the content was last entirely checked
-# SME: Bijan Haney
-aliases:
-  - /registry/advanced/mlmodel-design/
-  - /operate/reference/advanced-modules/mlmodel-design/
----
-
-The [Machine Learning (ML) model service](/data-ai/ai/deploy/) allows you to deploy machine learning models to your smart machine.
-Vision services, like [an `"mlmodel"` detector](/dev/reference/apis/services/vision/#detections) or [classifier](/dev/reference/apis/services/vision/#classifications), enable your machines to identify and classify objects in images with the deployed models' predictions.
-
-The two services work closely together, with the vision service relying on the deployed ML model to make inferences.
-If you are [designing your own ML Model service](/data-ai/ai/deploy/), you must try to make your ML models' shapes match the input and output tensors the `mlmodel` vision service expects to work with if you want the two services to coordinate in classification or detection.
-
-To be able to use a deployed ML model, the `mlmodel` vision service checks for descriptions of these characteristics in the [metadata](/dev/reference/apis/services/ml/#metadata) of the model, as defined in [the Python SDK](https://python.viam.dev/autoapi/viam/gen/service/mlmodel/v1/mlmodel_pb2/index.html#viam.gen.service.mlmodel.v1.mlmodel_pb2.Metadata).
-For an example of this, see [Example Metadata](#example-metadata).
-
-## Input tensor: `input_info` in metadata
-
-For both [classification](/dev/reference/apis/services/vision/#classifications) and [detection](/dev/reference/apis/services/vision/#detections) models, the vision service sends a single input tensor to the ML Model with the following structure:
-
-- One input tensor called `"image"` with type `uint8` or `float32` and shape `(1, height, width, 3)`, with the last channel `3` being the RGB bytes of the pixel.
-- If image `height` and `width` are unknown or variable, then `height` and/or `width` `= -1`. During inference runtime the image will have a known height and width.
-
-## Output tensors: `output_info` in metadata
-
-Data can be returned by the ML model in many ways, due to the variety of machine learning models for computer vision.
-The vision service will try to take into account many different forms of models as specified by the metadata of the model.
-If the model does not provide metadata, the vision service will make the following assumptions:
-
-For [classifications](/dev/reference/apis/services/vision/#classifications):
-
-- The model returns 1 tensor, called `"probability"` with shape `(1, n_classifications)`
-- The data is floating point numbers representing probability, between `0` and `1`.
-- If the data is not between `0` and `1`, the vision service computes a softmax over the data, resulting in floating point numbers between `0` and `1` representing probability.
-
-For [detections](/dev/reference/apis/services/vision/#detections):
-
-- The model returns 3 tensors
-  1. `"Location"`: the bounding boxes
-     - Shape: `(1, n_detections, 4)`
-     - Bounding boxes each have shape `(xmin, ymin, xmax, ymax)`
-     - Bounding boxes are the proportion of where the box corner is in the image, using a number between `0` and `1`.
-  2. `"Category"`: the labels on the boxes
-     - Shape: `(1, n_detections)`
-     - Integers representing the index of the label.
-  3. `"Score"`: The confidence scores of the label
-     - Shape: `(1, n_detections)`
-     - Floating point numbers representing probability, between `0` and `1`.
-
-For labels:
-
-- Many computer vision models have an associated 'labelfile.txt' that lists the class labels associated with the model.
-  To get those labels associated with the model, currently the vision service looks at the first element of the `output_info` list in the ML models' metadata and checks for a key called `"labels"` in its `"extra"` struct.
-  The value of that key should be the full path to the label file on the machine.
-  See [Example Metadata](#example-metadata) for an example of this.
-
-  ```sh {class="command-line" data-prompt="$"}
-  label_path = ml_model_metadata.output_info.extra["labels"]
-  ```
-
-### Example metadata
-
-For example, a TF lite detector model that works with the vision service is structured with the following [metadata](/dev/reference/apis/services/ml/#metadata):
-
-```json {class="line-numbers linkable-line-numbers"}
-name: "EfficientDet Lite0 V1"
-type: "tflite_detector"
-description: "Identify which of a known set of objects might be present and provide information about their positions within the given image or a video stream."
-input_info {
-  name: "image"
-  description: "Input image to be detected. The expected image is 320 x 320, with three channels (red, blue, and green) per pixel. Each value in the tensor is a single byte between 0 and 255."
-  data_type: "uint8"
-  shape: 1
-  shape: 320
-  shape: 320
-  shape: 3
-  extra {
-  }
-}
-output_info {
-  name: "location"
-  description: "The locations of the detected boxes."
-  data_type: "float32"
-  extra {
-    fields {
-      key: "labels"
-      value {
-        string_value: "/Users/<username>/.viam/packages/.data/ml_model/effdet0-1685040512967/effdetlabels.txt"
-      }
-    }
-  }
-}
-output_info {
-  name: "category"
-  description: "The categories of the detected boxes."
-  data_type: "float32"
-  associated_files {
-    name: "labelmap.txt"
-    description: "Label of objects that this model can recognize."
-    label_type: LABEL_TYPE_TENSOR_VALUE
-  }
-  extra {
-  }
-}
-output_info {
-  name: "score"
-  description: "The scores of the detected boxes."
-  data_type: "float32"
-  extra {
-  }
-}
-output_info {
-  name: "number of detections"
-  description: "The number of the detected boxes."
-  data_type: "float32"
-  extra {
-  }
-}
-```
-
-## Troubleshooting
-
-- `resource build error: model "rdk:service:vision/test-vision" does not fulfill any method of the vision service. It is neither a detector, nor classifier, nor 3D segmenter resource rdk:service:vision/test-vision model rdk:builtin:mlmodel`: This error indicates that your ML model's output tensor mappings don't match what Viam expects.
-  For instance, for a detector, your model metadata needs to have at least 3 output tensors mapped to "location", "category", and "score".
diff --git a/docs/data-ai/reference/vision-client.md b/docs/data-ai/reference/vision-client.md
deleted file mode 100644
index d28e356b3e..0000000000
--- a/docs/data-ai/reference/vision-client.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: "Vision service API"
-linkTitle: "Vision service API"
-weight: 30
-type: "docs"
-layout: "empty"
-canonical: "/dev/reference/apis/services/vision/"
----
diff --git a/docs/data-ai/train/_index.md b/docs/data-ai/train/_index.md
deleted file mode 100644
index 74445a9583..0000000000
--- a/docs/data-ai/train/_index.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-linkTitle: "Train an ML model"
-title: "Train an ML model"
-weight: 200
-layout: "empty"
-type: "docs"
-empty_node: true
-open_on_desktop: true
-header_only: true
-noedit: true
-canonical: "/data-ai/train/create-dataset/"
----
diff --git a/docs/data-ai/train/annotate-images.md b/docs/data-ai/train/annotate-images.md
deleted file mode 100644
index 0f70249ee7..0000000000
--- a/docs/data-ai/train/annotate-images.md
+++ /dev/null
@@ -1,222 +0,0 @@
----
-linkTitle: "Annotate images"
-title: "Annotate images for training"
-weight: 20
-layout: "docs"
-type: "docs"
-description: "Annotate images to train a machine learning model."
-date: "2025-10-11"
-aliases:
-  - /data-ai/train/capture-annotate-images/
----
-
-To train a machine learning model, you must have a set of annotated images to train on.
-
-## Prerequisites
-
-{{% expand "A machine connected to Viam" %}}
-
-{{% snippet "setup.md" %}}
-
-{{% /expand %}}
-
-{{% expand "A camera, connected to your machine, to capture images" %}}
-
-Follow the guide to configure a [webcam](/operate/reference/components/camera/webcam/) or similar [camera component](/operate/reference/components/camera/).
-
-{{% /expand%}}
-
-{{< alert title="Tip" color="tip" >}}
-
-For the best results, use the same camera for both capturing training data and production deployment.
-
-{{< /alert >}}
-
-## Annotate images
-
-You must annotate images in order to train an ML model on them.
-Viam supports two annotations for images:
-
-- [Tags for whole images (classification)](#add-tags-to-an-image)
-- [Bounding boxes around objects within images (object detection)](#label-objects-within-an-image)
-
-### Add tags to an image
-
-Use tags to add metadata about an entire image, for example whether the quality of a manufacturing output is `good` or `bad`.
-
-{{< alert title="Tip" color="tip" >}}
-
-If you have an ML model, use code to speed up annotating your data, otherwise use the Web UI.
-
-{{< /alert >}}
-
-{{< tabs >}}
-{{% tab name="Web UI" %}}
-
-You can tag your data automatically with an existing ML model, if you have one, or manually:
-
-{{< tabs >}}
-{{% tab name="Automatic" %}}
-
-To use auto-predictions, you must first [add your images to a dataset](/data-ai/train/create-dataset/).
-
-1. Navigate to your [dataset's](https://app.viam.com/datasets/) page.
-1. Click on **Get auto-predictions**.
-1. **Select** a classification model to generate predictions with.
-1. Set the **confidence threshold** above which to create a label prediction.
-1. Click **Get predictions**.
-1. Once predictions have finished generating, click on **Review predictions**.
-1. For each image, **Accept (A)** or **Reject (R)** each prediction.
-
-   {{<imgproc src="/data-ai/review-ui.png" resize="1200x" class="imgzoom shadow" declaredimensions=true alt="UI for reviewing predictions">}}
-
-{{% /tab %}}
-{{% tab name="Manual" %}}
-
-The [**DATA** page](https://app.viam.com/data/view) provides an interface for annotating images.
-
-To tag an image:
-
-1. Click on an image, then click the **+** next to the **Tags** option.
-1. Add one or more tags to your image.
-
-   {{<gif webm_src="/services/data/tag-star.webm" mp4_src="/services/data/tag-star.mp4" alt="Tag image with a full label">}}
-
-1. Repeat these steps for all images in the dataset.
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /tab %}}
-{{% tab name="Python" %}}
-
-Use an ML model to generate tags for an image or set of images.
-Then, pass the tags and image IDs to [`data_client.add_tags_to_binary_data_by_ids`](/dev/reference/apis/data-client/#addtagstobinarydatabyids):
-
-{{< read-code-snippet file="/static/include/examples-generated/tag-images.snippet.tag-images.py" lang="python" class="line-numbers linkable-line-numbers" data-line="" >}}
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-Use an ML model to generate tags for an image or set of images.
-Then, pass the tags and image IDs to [`DataClient.AddTagsToBinaryDataByIDs`](/dev/reference/apis/data-client/#addtagstobinarydatabyids):
-
-{{< read-code-snippet file="/static/include/examples-generated/tag-images.snippet.tag-images.go" lang="go" class="line-numbers linkable-line-numbers" data-line="" >}}
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-Use an ML model to generate tags for an image or set of images.
-Then, pass the tags and image IDs to [`dataClient.addTagsToBinaryDataByIds`](/dev/reference/apis/data-client/#addtagstobinarydatabyids):
-
-{{< read-code-snippet file="/static/include/examples-generated/tag-images.snippet.tag-images.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="" >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-Once you've annotated your dataset, you can [train](/data-ai/train/train-tf-tflite/) an ML model to make inferences.
-
-### Label objects within an image
-
-Use labels to add metadata about objects within an image, for example by drawing bounding boxes around each bicycle in a street scene and adding the bicycle label.
-
-{{< alert title="Tip" color="tip" >}}
-
-If you have an ML model, use code to speed up annotating your data, otherwise use the Web UI.
-
-{{< /alert >}}
-
-{{< tabs >}}
-{{% tab name="Web UI" %}}
-
-You can label your data automatically with an existing ML model, if you have one, or manually:
-
-{{< tabs >}}
-{{% tab name="Automatic" %}}
-
-To use auto-predictions, you must first [add your images to a dataset](/data-ai/train/create-dataset/).
-
-1. Navigate to your [dataset's](https://app.viam.com/datasets/) page.
-1. Click on **Get auto-predictions**.
-1. **Select** a object detection model to generate predictions with.
-1. Set the **confidence threshold** above which to create a label prediction.
-1. Click **Get predictions**.
-1. Once predictions have finished generating, click on **Review predictions**.
-1. For each image, **Accept (A)** or **Reject (R)** each prediction.
-
-   {{<imgproc src="/data-ai/review-ui-detection.png" resize="1200x" class="imgzoom shadow" declaredimensions=true alt="UI for reviewing predictions">}}
-
-{{% /tab %}}
-{{% tab name="Manual" %}}
-
-The [**DATA** page](https://app.viam.com/data/view) provides an interface for annotating images.
-
-To label an object with a bounding box:
-
-1. Click on an image, then click the **Annotate** button in right side menu.
-1. Choose an existing label or create a new label.
-1. Holding the command key (on macOS), or the control key (on Linux and Windows), click and drag on the image to create the bounding box:
-
-   {{<gif webm_src="/services/data/label-figure.webm" mp4_src="/services/data/label-figure.mp4" alt="Add a bounding box around the viam figure in an image">}}
-
-1. Repeat these steps for all images in the dataset.
-
-{{< alert title="Tip" color="tip" >}}
-Once created, you can move, resize, or delete the bounding box.
-{{< /alert >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /tab %}}
-{{% tab name="Python" %}}
-
-Use an ML model to generate bounding boxes for an image.
-Then, separately pass each bounding box and the image ID to [`data_client.add_bounding_box_to_image_by_id`](/dev/reference/apis/data-client/#addboundingboxtoimagebyid):
-
-{{< read-code-snippet file="/static/include/examples-generated/label-images.snippet.label-images.py" lang="python" class="line-numbers linkable-line-numbers" data-line="" >}}
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-Use an ML model to generate bounding boxes for an image.
-Then, separately pass each bounding box and the image ID to [`DataClient.AddBoundingBoxToImageByID`](/dev/reference/apis/data-client/#addboundingboxtoimagebyid):
-
-{{< read-code-snippet file="/static/include/examples-generated/label-images.snippet.label-images.go" lang="go" class="line-numbers linkable-line-numbers" data-line="" >}}
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-Use an ML model to generate bounding boxes for an image.
-Then, separately pass each bounding box and the image ID to [`dataClient.addBoundingBoxToImageById`](/dev/reference/apis/data-client/#addboundingboxtoimagebyid):
-
-{{< read-code-snippet file="/static/include/examples-generated/label-images.snippet.label-images.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="" >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-Once you've annotated your dataset, you can [train](/data-ai/train/train-tf-tflite/) an ML model to make inferences.
-
-## Capture, annotate, and add images to a dataset in a single script
-
-The following example demonstrates how you can capture an image, use an ML model to generate annotations, and then add the image to a dataset.
-You can use this logic to expand and improve your datasets continuously over time.
-Check the annotation accuracy in the **DATA** tab, then re-train your ML model on the improved dataset to improve the ML model.
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-{{< read-code-snippet file="/static/include/examples-generated/capture-annotate-dataset.snippet.capture-annotate-dataset.py" lang="python" class="line-numbers linkable-line-numbers" data-line="" >}}
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-{{< read-code-snippet file="/static/include/examples-generated/capture-annotate-dataset.snippet.capture-annotate-dataset.go" lang="go" class="line-numbers linkable-line-numbers" data-line="" >}}
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-{{< read-code-snippet file="/static/include/examples-generated/capture-annotate-dataset.snippet.capture-annotate-dataset.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="" >}}
-
-{{% /tab %}}
-{{< /tabs >}}
diff --git a/docs/data-ai/train/create-dataset.md b/docs/data-ai/train/create-dataset.md
deleted file mode 100644
index 3605455854..0000000000
--- a/docs/data-ai/train/create-dataset.md
+++ /dev/null
@@ -1,312 +0,0 @@
----
-linkTitle: "Create a training dataset"
-title: "Create a training dataset"
-weight: 10
-layout: "docs"
-type: "docs"
-description: "Create a dataset to train a machine learning model."
-aliases:
-  - /fleet/dataset/
-  - /manage/data/label/
-  - /manage/data/dataset/
-  - /data/dataset/
-  - /data-ai/ai/create-dataset/
-date: "2025-10-11"
----
-
-To train a machine learning model, you will need a dataset that meets the following conditions:
-
-{{< readfile "/static/include/data/dataset-requirements.md" >}}
-
-## Create a dataset
-
-You can create a dataset using the web UI, the CLI, or one of the SDKs:
-
-{{< tabs >}}
-{{% tab name="Web UI" %}}
-
-1. Navigate to the **DATA** page and open the [**DATASETS** tab](https://app.viam.com/datasets).
-
-1. Click the **+ Create dataset** button.
-
-   {{< imgproc src="/services/data/create-dataset.png" alt="The **DATASETS** tab of the **DATA** page, showing the **+ Create dataset** button." resize="800x" style="width:500px" class="imgzoom shadow" >}}
-
-1. Enter a unique name for the dataset.
-
-1. Click **Create dataset**.
-
-{{% /tab %}}
-{{% tab name="CLI" %}}
-
-Run the following [Viam CLI](/dev/tools/cli/) command to create a dataset, replacing the `<org-id>` and `<name>` placeholders with your organization ID and a unique name for the dataset:
-
-```sh {class="command-line" data-prompt="$"}
-viam dataset create --org-id=<org-id> --name=<name>
-```
-
-{{% /tab %}}
-{{% tab name="Python" %}}
-
-To create a dataset, pass a unique dataset name and organization ID to [`data_client.create_dataset`](/dev/reference/apis/data-client/#createdataset):
-
-{{< read-code-snippet file="/static/include/examples-generated/create-dataset.snippet.create-dataset.py" lang="python" class="line-numbers linkable-line-numbers" data-line="31-34" >}}
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-To create a dataset, pass a unique dataset name and organization ID to [`DataClient.CreateDataset`](/dev/reference/apis/data-client/#createdataset):
-
-{{< read-code-snippet file="/static/include/examples-generated/create-dataset.snippet.create-dataset.go" lang="go" class="line-numbers linkable-line-numbers" data-line="30" >}}
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-To create a dataset, pass a unique dataset name and organization ID to [`dataClient.createDataset`](/dev/reference/apis/data-client/#createdataset):
-
-{{< read-code-snippet file="/static/include/examples-generated/create-dataset.snippet.create-dataset.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="27-30" >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-Now that you've created a dataset, you can add images to it.
-
-## Capture images
-
-You can either [capture individual images](#capture-individual-images) or [capture images periodically over time](#capture-images-over-time).
-
-### Capture individual images
-
-{{< tabs >}}
-{{% tab name="Web UI" %}}
-
-You can add images to a dataset directly from a camera or vision component feed in the machine's **CONTROL** or **CONFIGURATION** tabs.
-
-To add an image directly to a dataset from a visual feed, complete the following steps:
-
-1. Open the **TEST** panel of any camera or vision service component to view a feed of images from the camera.
-1. Click the button marked with the camera icon to save the currently displayed image to a dataset:
-   {{< imgproc src="/components/camera/add_image_to_dataset_button.png" alt="A button marked with the outline of a camera, emphasized in red" resize="800x" style="width:500px" class="imgzoom shadow" >}}
-1. Select an existing dataset.
-1. Click **Add** to add the image to the selected dataset.
-1. When you see a success notification that reads "Saved image to dataset", you have successfully added the image to the dataset.
-
-To view images added to your dataset, go to the **DATA** page, open the [**DATASETS** tab](https://app.viam.com/datasets), then select your dataset.
-
-{{% /tab %}}
-{{% tab name="Python" %}}
-
-To capture an image and upload it to Viam, first get an image from your camera through your machine.
-Pass that image and an appropriate set of metadata to [`data_client.binary_data_capture_upload`](/dev/reference/apis/data-client/#binarydatacaptureupload):
-
-{{< read-code-snippet file="/static/include/examples-generated/capture-images.snippet.capture-images.py" lang="python" class="line-numbers linkable-line-numbers" data-line="43-56" >}}
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-To capture an image and upload it to Viam, first get an image from your camera through your machine.
-Pass that image and an appropriate set of metadata to [`DataClient.BinaryDataCaptureUpload`](/dev/reference/apis/data-client/#binarydatacaptureupload):
-
-{{< read-code-snippet file="/static/include/examples-generated/capture-images.snippet.capture-images.go" lang="go" class="line-numbers linkable-line-numbers" data-line="55-82" >}}
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-To capture an image and upload it to Viam, first get an image from your camera through your machine.
-Pass that image and an appropriate set of metadata to [`dataClient.binaryDataCaptureUpload`](/dev/reference/apis/data-client/#binarydatacaptureupload):
-
-{{< read-code-snippet file="/static/include/examples-generated/capture-images.snippet.capture-images.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="41-54" >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-Once you've captured enough images for training, you must [annotate](/data-ai/train/annotate-images/) the images before you can use them to train a model.
-
-### Capture images over time
-
-To capture a large number of images for training an ML model, use the data management service to [capture and sync image data](/data-ai/capture-data/capture-sync/) from your camera.
-
-When you sync with data management, Viam stores the images in the cloud and you can access them on the [**DATA** page](https://app.viam.com/data/).
-To use your captured images for training, [add the images to a dataset](#add-existing-images-to-a-dataset).
-
-{{< alert title="Tip" color="tip" >}}
-
-Once you have enough images, consider disabling data capture to [avoid incurring fees](https://www.viam.com/product/pricing) for capturing large amounts of training data.
-
-{{< /alert >}}
-
-## Add existing images to a dataset
-
-If you have already uploaded images to Viam, you can [add selected images to a dataset](#add-selected-images-to-a-dataset) or [add filtered images to a dataset](#add-filtered-images-to-a-dataset).
-
-### Add selected images to a dataset
-
-{{< tabs >}}
-{{% tab name="Web UI" %}}
-
-You can add images to a dataset from the **Images** tab of the [**DATA** page](https://app.viam.com/data/view):
-
-1. Filter the images with tags or other filters.
-
-1. Select the images you would like to add to your dataset.
-
-1. Click the **Add to dataset** button in the top right.
-
-1. From the **Dataset** dropdown, select the name of your dataset.
-
-1. Click **Add \<n\> images** to add the selected images to the dataset.
-
-{{< alert title="Tip" color="tip" >}}
-
-To select a range of images, select one image, then hold **Ctrl/Cmd** while clicking another image.
-This will select both images as well as the entire range of images between those images.
-
-{{< /alert >}}
-
-{{% /tab %}}
-{{% tab name="CLI" %}}
-
-Use the Viam CLI to filter images by label and add the filtered images to a dataset:
-
-1. Use the dataset ID output by the dataset creation command or run the following command to get a list of dataset names and corresponding IDs:
-
-   ```sh {class="command-line" data-prompt="$"}
-   viam dataset list
-   ```
-
-1. Run the following [command](/dev/tools/cli/#dataset) to add all images labeled with the specified tags to the dataset, replacing the `<dataset-id>` placeholder with the dataset ID:
-
-   ```sh {class="command-line" data-prompt="$"}
-   viam dataset data add filter --dataset-id=<dataset-id> --tags=red_star,blue_square
-   ```
-
-{{% /tab %}}
-{{% tab name="Python" %}}
-
-To add an image to a dataset, find the binary data ID for the image and the dataset ID.
-You can retrieve the binary data IDs from the [**DATA** tab](https://app.viam.com/data/view).
-Click on an image and copy the binary data ID from the **DETAILS** section.
-
-You can retrieve the dataset ID from the [**DATASETS** tab](https://app.viam.com/datasets/).
-Click on the dataset.
-On the dataset page, click the **...** menu next to the dataset name, then click **Copy dataset ID**.
-
-Pass both IDs to [`data_client.add_binary_data_to_dataset_by_ids`](/dev/reference/apis/data-client/#addbinarydatatodatasetbyids):
-
-{{< read-code-snippet file="/static/include/examples-generated/add-to-dataset.snippet.add-to-dataset.py" lang="python" class="line-numbers linkable-line-numbers" data-line="30-33" >}}
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-To add an image to a dataset, find the binary data ID for the image and the dataset ID.
-You can retrieve the binary data IDs from the [**DATA** tab](https://app.viam.com/data/view).
-Click on an image and copy the binary data ID from the **DETAILS** section.
-
-You can retrieve the dataset ID from the [**DATASETS** tab](https://app.viam.com/datasets/).
-Click on the dataset.
-On the dataset page, click the **...** menu next to the dataset name, then click **Copy dataset ID**.
-
-Pass both IDs to [`DataClient.AddBinaryDataToDatasetByIDs`](/dev/reference/apis/data-client/#addbinarydatatodatasetbyids):
-
-{{< read-code-snippet file="/static/include/examples-generated/add-to-dataset.snippet.add-to-dataset.go" lang="go" class="line-numbers linkable-line-numbers" data-line="30-34" >}}
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-To add an image to a dataset, find the binary data ID for the image and the dataset ID.
-You can retrieve the binary data IDs from the [**DATA** tab](https://app.viam.com/data/view).
-Click on an image and copy the binary data ID from the **DETAILS** section.
-
-You can retrieve the dataset ID from the [**DATASETS** tab](https://app.viam.com/datasets/).
-Click on the dataset.
-On the dataset page, click the **...** menu next to the dataset name, then click **Copy dataset ID**.
-
-Pass both IDs to [`dataClient.addBinaryDataToDatasetByIDs`](/dev/reference/apis/data-client/#addbinarydatatodatasetbyids):
-
-{{< read-code-snippet file="/static/include/examples-generated/add-to-dataset.snippet.add-to-dataset.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="26-29" >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-### Add filtered images to a dataset
-
-{{< tabs >}}
-{{% tab name="Web UI" %}}
-
-You can add images to a dataset from the **Images** tab of the [**DATA** page](https://app.viam.com/data/view):
-
-1. Use the filters side menu to select filters. For example, from the **Machine name** dropdown, select the name of a machine.
-1. Click the **Apply** button at the bottom of the left sidebar.
-1. Click to select the images you would like to add to your dataset.
-1. Click the **Add to dataset** button in the top right.
-1. From the **Dataset** dropdown, select the name of your dataset.
-1. Click **Add \<n\> images** to add the selected images to the dataset.
-
-{{< alert title="Tip" color="tip" >}}
-
-To select a range of images, select one image, then hold **Ctrl/Cmd** while clicking another image.
-This will select both images as well as the entire range of images between those images.
-
-{{< /alert >}}
-
-{{% /tab %}}
-{{% tab name="Python" %}}
-
-The following script adds all images captured from a certain machine to a new dataset:
-
-{{< read-code-snippet file="/static/include/examples-generated/add-machine-images-to-dataset.snippet.add-machine-images-to-dataset.py" lang="python" class="line-numbers linkable-line-numbers" data-line="56-61" >}}
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-The following script adds all images captured from a certain machine to a new dataset:
-
-{{< read-code-snippet file="/static/include/examples-generated/add-machine-images-to-dataset.snippet.add-machine-images-to-dataset.go" lang="go" class="line-numbers linkable-line-numbers" data-line="88-92" >}}
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-The following script adds all images captured from a certain machine to a new dataset:
-
-{{< read-code-snippet file="/static/include/examples-generated/add-machine-images-to-dataset.snippet.add-machine-images-to-dataset.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="61-64" >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-## Use an existing dataset
-
-If you have used the `viam dataset export` command to export a dataset or if you've been given a dataset from someone else, you can use the following script to import the dataset.
-If you have a dataset that was not exported with Viam, you will need to make changes to this script.
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-{{% read-code-snippet file="/static/include/examples-generated/use-existing-dataset.snippet.use-existing-dataset.py" lang="python" class="line-numbers linkable-line-numbers" %}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% expand "Looking for test datasets?" %}}
-We have two datasets you can use for testing, one with shapes and the other with a wooden figure:
-
-{{< imgproc src="/tutorials/data-management/shapes-dataset.png" resize="1200x" declaredimensions=true style="width:400px" alt="The shapes dataset." class="imgzoom fill aligncenter shadow" >}}
-
-{{< imgproc src="/tutorials/filtered-camera-module/viam-figure-dataset.png" style="width:400px" alt="The datasets subtab of the data tab in the Viam app, showing a custom 'viam-figure' dataset of 25 images, most containing the wooden Viam figure" class="imgzoom fill aligncenter" resize="1400x" >}}
-
-1. [Download the shapes dataset](https://storage.googleapis.com/docs-blog/dataset-shapes.zip) or [download the wooden figure dataset](https://storage.googleapis.com/docs-blog/dataset-figure.zip).
-1. Unzip the download.
-1. Use the above script.
-
-{{% /expand %}}
-
-## Merge datasets
-
-You can combine two datasets to create a new dataset using the web UI:
-
-1. Navigate to the **DATA** page and open the [**DATASETS** tab](https://app.viam.com/datasets).
-1. Click the **...** menu on the dataset.
-1. Select **Merge...** from the context menu.
-1. Choose the dataset you want to merge with from the dropdown menu.
-1. Enter a name for the new merged dataset.
-1. Click **Merge datasets** to create the new combined dataset.
-   The original datasets remain unchanged after merging.
-   The merge operation creates a new dataset containing all the data from both source datasets.
diff --git a/docs/data-ai/train/train-tf-tflite.md b/docs/data-ai/train/train-tf-tflite.md
deleted file mode 100644
index c6adc9b2d0..0000000000
--- a/docs/data-ai/train/train-tf-tflite.md
+++ /dev/null
@@ -1,197 +0,0 @@
----
-linkTitle: "Train TF or TFLite model"
-title: "Train a TF or TFLite model"
-weight: 50
-type: "docs"
-tags: ["vision", "data", "services"]
-images: ["/services/ml/train.svg"]
-description: "Use your image data to train a model, so your machines can make inferences about their environments."
-aliases:
-  - /use-cases/deploy-ml/
-  - /manage/ml/train-model/
-  - /ml/train-model/
-  - /services/ml/train-model/
-  - /tutorials/data-management-tutorial/
-  - /tutorials/data-management/
-  - /data-management/data-management-tutorial/
-  - /tutorials/services/data-management-tutorial/
-  - /tutorials/services/data-mlmodel-tutorial/
-  - /extend/modular-resources/examples/tflite-module/
-  - /modular-resources/examples/tflite-module/
-  - /registry/examples/tflite-module/
-  - /data-ai/ai/train-tflite/
-  - /data-ai/train/train-tf-tflite/
-languages: []
-viamresources: ["data_manager", "mlmodel", "vision"]
-platformarea: ["ml"]
-date: "2024-12-03"
-updated: "2025-10-13"
----
-
-Many machines have cameras through which they can monitor their environment.
-With machine learning (ML), you can train models on patterns within image data.
-Follow this guide to use your image data to train an ML model, so that your machine can make inferences about its environment.
-
-## Prerequisites
-
-{{% expand "A machine connected to Viam" %}}
-
-{{% snippet "setup.md" %}}
-
-{{% /expand %}}
-
-{{% expand "A dataset that meets training requirements" %}}
-
-To train a model, your dataset must contain the following:
-
-{{< readfile "/static/include/data/dataset-requirements.md" >}}
-
-Follow the guide to [create a dataset](/data-ai/train/create-dataset/).
-
-{{% /expand %}}
-
-## Train a machine learning model
-
-Now that you have a dataset that contains your labeled images, you are ready to train a machine learning model.
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Find your training dataset**
-
-Navigate to your list of [**DATASETS**](https://app.viam.com/datasets) and select the one you want to train on.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Train an ML model**
-
-Click **Train model** and follow the prompts.
-You can train a TFLite model using **Built-in training**.
-
-{{<imgproc src="/services/ml/train-model.png" resize="1200x" declaredimensions=true style="width:500px" alt="The shapes dataset." class="imgzoom fill shadow" >}}
-
-Click **Next steps**.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Select model type**
-
-Select between:
-
-<!-- prettier-ignore -->
-| Type | Description |
-| ---- | ----------- |
-| **TensorFlow Lite (TFLite)** | Best for use on mobile and edge devices with minimal resources. |
-| **TensorFlow (TF)** | Best for general-purpose tasks with more computational power. |
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Fill in the details for your ML model**
-
-Enter a name for your new model.
-
-Select a **Task Type**:
-
-- **Single Label Classification**: The resulting model predicts one of the selected labels or `UNKNOWN` per image.
-  Select this if you only have one label on each image. Ensure that the dataset you are training on also contains unlabeled images.
-- **Multi Label Classification**: The resulting model predicts one or more of the selected labels per image.
-- **Object Detection**: The resulting model predicts either no detected objects or any number of object labels alongside their locations per image.
-
-Select the labels you want to train your model on from the **Labels** section. Unselected labels will be ignored and will not be part of the resulting model.
-
-Click **Train model**.
-
-{{< imgproc src="/tutorials/data-management/train-model.png" alt="The data tab showing the train a model pane" style="width:500px" resize="1200x" class="imgzoom fill shadow" >}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Wait for your model to train**
-
-The model now starts training and you can follow its process on the [**TRAINING** tab](https://app.viam.com/training).
-
-Once the model has finished training, it becomes visible on the [**MODELS** tab](https://app.viam.com/models).
-
-You will receive an email when your model finishes training.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Debug your training job**
-
-From the [**TRAINING** tab](https://app.viam.com/training), click on your training job's ID to see its logs.
-
-{{< alert title="Note" color="note" >}}
-
-Your training script may output logs at the error level but still succeed.
-
-{{< /alert >}}
-
-You can also view logs for your training jobs with the [`viam train logs`](/dev/tools/cli/#train) command.
-
-Training logs expire after 7 days.
-
-{{% /tablestep %}}
-{{< /table >}}
-
-## Test your ML model
-
-{{<gif webm_src="/services/vision/mug-classifier.webm" mp4_src="/services/vision/mug-classifier.mp4" alt="A classification model run against an image containing a mug." max-width="250px" class="alignright">}}
-
-Once your model has finished training, you can test it.
-
-Ideally, you want your ML model to perform with high confidence.
-As you test it, if you notice faulty predictions or confidence scores, you will need to adjust your dataset and retrain your model.
-
-If you trained a _classification_ model, you can test it with the following instructions.
-
-1. Navigate to the [**DATA** page](https://app.viam.com/data/view) and click on the **Images** subtab.
-1. Click on an image to open the side menu, and select the **Actions** tab.
-1. In the **Run model** section, select your model and specify a confidence threshold.
-1. Click **Run model**.
-
-If the results exceed the confidence threshold, the **Run model** section shows a label and the corresponding confidence score.
-
-You can test both TensorFlow Lite detection models and TensorFlow Lite classifier models using the following resources together:
-
-- [a camera](/operate/reference/components/camera/)
-- [a `tflite_cpu` ML model](https://app.viam.com/module/viam/tflite_cpu/) with the model you just trained
-- [an `mlmodel` vision service](/operate/reference/services/vision/mlmodel/) using the `tflite_cpu` model
-
-## Iterate on your ML model
-
-You are unlikely to account for all false positives or false negatives during your first round of training.
-To improve your ML model, try the following steps:
-
-- **More data means better models**: Add images capturing edge cases to your training dataset, annotate them, and retrain your model using the new data.
-- **Include counterexamples**: For detections, use images with and without the object you’re looking to detect.
-  This helps the model distinguish the target object from the background and reduces the chances of false positives by teaching it what the object is not.
-  For classifications, ensure you cover a full range of data the classifier might encounter.
-- **Avoid class imbalance**: Don’t train excessively on one specific type or class, make sure each category has a roughly equal number of images.
-  For instance, if you're training a dog detector, include images of various dog breeds to avoid bias towards one breed.
-  An imbalanced dataset can lead the model to favor one class over others, reducing its overall accuracy.
-- **Match your training images to your intended use case**: Use images that reflect the quality and conditions of your production environment.
-  For example, if you plan to use a low-quality camera in production, train with low-quality images.
-  Similarly, if your model will run all day, capture images in both daylight and nighttime conditions.
-- **Vary your angles and distances**: Include image examples from every angle and distance that the model will see in normal use.
-- **Ensure labeling accuracy**: Make sure the labels or bounding box annotations you give are accurate.
-
-To capture more images and retrain your model using those images, complete the following steps:
-
-1. Add the images to your training dataset.
-   You can use images from existing data on the [**DATA** page](https://app.viam.com/data/) or [capture new images and add them to your training dataset](/data-ai/train/create-dataset/#capture-images).
-
-1. Open your dataset on the **DATASETS** tab and annotate the images.
-
-1. Repeat the [steps to train a machine learning model](/data-ai/train/train-tf-tflite/#train-a-machine-learning-model) and create a new version of your ML model.
-   Your machines will automatically update to the new version of the model soon after release.
-
-## Next steps
-
-Now your machine can make inferences about its environment.
-The next step is to [deploy](/data-ai/ai/deploy/) the ML model and then [act](/data-ai/ai/act/) or [alert](/data-ai/ai/alert/) based on these inferences.
-
-See the following tutorials for examples of using machine learning models to make your machine do things based on its inferences about its environment:
-
-{{< cards >}}
-{{% card link="/operate/hello-world/tutorial-desk-safari/" customTitle="Desk Safari Game" %}}
-{{% card link="/tutorials/projects/helmet/" %}}
-{{% card link="/tutorials/projects/pet-treat-dispenser/" customTitle="Smart Pet Feeder" %}}
-{{< /cards >}}
diff --git a/docs/data-ai/train/train.md b/docs/data-ai/train/train.md
deleted file mode 100644
index 09788eeeba..0000000000
--- a/docs/data-ai/train/train.md
+++ /dev/null
@@ -1,859 +0,0 @@
----
-linkTitle: "Train other models"
-title: "Train other models"
-tags: ["data management", "ml", "model training"]
-weight: 51
-layout: "docs"
-type: "docs"
-aliases:
-  - /services/ml/upload-training-script/
-  - /how-tos/create-custom-training-scripts/
-  - /services/ml/training-scripts/
-  - /registry/training-scripts/
-  - /data-ai/ai/train/
-languages: ["python"]
-viamresources: ["mlmodel", "data_manager"]
-platformarea: ["ml"]
-description: "If you want to train models to custom specifications, write a custom training script and upload it to the Viam Registry."
-date: "2024-12-04"
-updated: "2025-10-13"
----
-
-You can create custom Python training scripts that train machine learning models to your specifications using PyTorch, TensorFlow, TFLite, ONNX, or any other ML framework.
-Once you upload a training script to the [registry](https://app.viam.com/registry?type=Training+Script), you can use it to build ML models in the Viam Cloud based on your datasets.
-
-You can also use training scripts that are already in the registry.
-If you wish to do this, skip to [Submit a training job](#submit-a-training-job).
-
-## Prerequisites
-
-{{% expand "A dataset that contains training data" %}}
-
-For images, follow the instructions to [Create a dataset](/data-ai/train/create-dataset/) to create a dataset and label data.
-
-For other data, use the [Data Client API](/dev/reference/apis/data-client/) to store data in the Viam Cloud.
-
-{{% /expand%}}
-
-{{% expand "The Viam CLI" %}}
-
-You must have the Viam CLI installed to upload training scripts to the registry.
-
-{{< readfile "/static/include/how-to/install-cli.md" >}}
-
-{{% /expand%}}
-
-## Create a training script
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Create files**
-
-Create the following folders and empty files:
-
-```treeview
-my-training/
-├── model/
-|   ├── training.py
-|   └── __init__.py
-└── setup.py
-```
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Add `setup.py` code**
-
-Add the following code to `setup.py`:
-
-```python {class="line-numbers linkable-line-numbers"}
-from setuptools import find_packages, setup
-
-setup(
-    name="my-training",
-    version="0.1",
-    packages=find_packages(),
-    include_package_data=True,
-    install_requires=[
-        # TODO: Add additional required packages
-    ],
-)
-```
-
-{{% /tablestep %}}
-{{< tablestep >}}
-
-<p><strong>Add <code>training.py</code> code</strong></p>
-
-<p>You can set up your training script to use a hard-coded set of labels or allow users to pass in a set of labels when using the training script. Allowing users to pass in labels when using training scripts makes your training script more flexible for reuse.</p>
-<p>Copy one of the following templates into <file>training.py</file>, depending on how you want to handle labels:</p>
-
-{{% expand "Click to see the template without parsing labels (recommended for use with UI)" %}}
-
-```python {class="line-numbers linkable-line-numbers" data-line="134" }
-import argparse
-import json
-import os
-import typing as ty
-from tensorflow.keras import Model  # Add proper import
-import tensorflow as tf  # Add proper import
-
-single_label = "MODEL_TYPE_SINGLE_LABEL_CLASSIFICATION"
-multi_label = "MODEL_TYPE_MULTI_LABEL_CLASSIFICATION"
-labels_filename = "labels.txt"
-unknown_label = "UNKNOWN"
-
-API_KEY = os.environ['API_KEY']
-API_KEY_ID = os.environ['API_KEY_ID']
-
-DEFAULT_EPOCHS = 200
-
-# This parses the required arguments for the training script.
-# The model_dir variable will contain the output directory where
-# the ML model that this script creates should be stored.
-# The data_json variable will contain the metadata for the dataset
-# that you should use to train the model.
-
-
-def parse_args():
-    """Returns the dataset file, model output directory, and num_epochs,
-    if present. These must be parsed as command-line arguments and then used
-    as the model input and output, respectively. The number of epochs can be
-    used to optionally override the default.
-    """
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--dataset_file", dest="data_json",
-                        type=str, required=True)
-    parser.add_argument("--model_output_directory", dest="model_dir",
-                        type=str, required=True)
-    parser.add_argument("--num_epochs", dest="num_epochs", type=int)
-    args = parser.parse_args()
-
-    return args.data_json, args.model_dir, args.num_epochs
-
-
-# This is used for parsing the dataset file (produced and stored in Viam),
-# parse it to get the label annotations
-# Used for training classification models
-def parse_filenames_and_labels_from_json(
-    filename: str, all_labels: ty.List[str], model_type: str
-) -> ty.Tuple[ty.List[str], ty.List[str]]:
-    """Load and parse JSON file to return image filenames and corresponding
-    labels. The JSON file contains lines, where each line has the key
-    "image_path" and "classification_annotations".
-    Args:
-        filename: JSONLines file containing filenames and labels
-        all_labels: list of all N_LABELS
-        model_type: string single_label or multi_label
-    """
-    image_filenames = []
-    image_labels = []
-
-    with open(filename, "rb") as f:
-        for line in f:
-            json_line = json.loads(line)
-            image_filenames.append(json_line["image_path"])
-
-            annotations = json_line["classification_annotations"]
-            labels = [unknown_label]
-            for annotation in annotations:
-                if model_type == multi_label:
-                    if annotation["annotation_label"] in all_labels:
-                        labels.append(annotation["annotation_label"])
-                # For a single-label model, we want at most one label.
-                # If multiple valid labels are present, we arbitrarily select
-                # the last one.
-                if model_type == single_label:
-                    if annotation["annotation_label"] in all_labels:
-                        labels = [annotation["annotation_label"]]
-            image_labels.append(labels)
-    return image_filenames, image_labels
-
-
-# Parse the dataset file (produced and stored in Viam) to get
-# bounding box annotations
-# Used for training object detection models
-def parse_filenames_and_bboxes_from_json(
-    filename: str,
-    all_labels: ty.List[str],
-) -> ty.Tuple[ty.List[str], ty.List[str], ty.List[ty.List[float]]]:
-    """Load and parse JSON file to return image filenames
-    and corresponding labels with bboxes.
-    Args:
-        filename: JSONLines file containing filenames and bboxes
-        all_labels: list of all N_LABELS
-    """
-    image_filenames = []
-    bbox_labels = []
-    bbox_coords = []
-
-    with open(filename, "rb") as f:
-        for line in f:
-            json_line = json.loads(line)
-            image_filenames.append(json_line["image_path"])
-            annotations = json_line["bounding_box_annotations"]
-            labels = []
-            coords = []
-            for annotation in annotations:
-                if annotation["annotation_label"] in all_labels:
-                    labels.append(annotation["annotation_label"])
-                    # Store coordinates in rel_yxyx format so that
-                    # we can use the KerasCV function
-                    coords.append(
-                        [
-                            annotation["y_min_normalized"],
-                            annotation["x_min_normalized"],
-                            annotation["y_max_normalized"],
-                            annotation["x_max_normalized"],
-                        ]
-                    )
-            bbox_labels.append(labels)
-            bbox_coords.append(coords)
-    return image_filenames, bbox_labels, bbox_coords
-
-
-# Build the model
-def build_and_compile_model(
-    labels: ty.List[str], model_type: str, input_shape: ty.Tuple[int, int, int]
-) -> Model:
-    """Builds and compiles a model
-    Args:
-        labels: list of string lists, where each string list contains up to
-        N_LABEL labels associated with an image
-        model_type: string single_label or multi_label
-        input_shape: 3D shape of the input
-    """
-
-    # TODO: Add logic to build and compile model
-
-    return model
-
-
-def save_labels(labels: ty.List[str], model_dir: str) -> None:
-    """Saves labels.txt with the output labels to the specified model directory.
-    Args:
-        labels: list of string lists, where each string list contains up to
-        N_LABEL labels associated with an image
-        model_dir: output directory for model artifacts
-    """
-    filename = os.path.join(model_dir, labels_filename)
-    with open(filename, "w") as f:
-        for label in labels[:-1]:
-            f.write(label + "\n")
-        f.write(labels[-1])
-
-
-def save_model(
-    model: Model,
-    model_dir: str,
-    model_name: str,
-) -> None:
-    """Save model as a TFLite model.
-    Args:
-        model: trained model
-        model_dir: output directory for model artifacts
-        model_name: name of saved model
-    """
-    # Save the model to the output directory
-    file_type = "tflite"  # Add proper file type
-    filename = os.path.join(model_dir, f"{model_name}.{file_type}")
-
-    # Example: Convert to TFLite
-    converter = tf.lite.TFLiteConverter.from_keras_model(model)
-    tflite_model = converter.convert()
-
-    # Save the model
-    with open(filename, "wb") as f:
-        f.write(tflite_model)
-
-
-if __name__ == "__main__":
-    DATA_JSON, MODEL_DIR, NUM_EPOCHS, _ = parse_args()
-
-    IMG_SIZE = (256, 256)
-
-    # Read dataset file.
-    # TODO: change labels to the desired model output.
-    LABELS = ["orange_triangle", "blue_star"]
-
-    # The model type can be changed based on whether you want the model to
-    # output one label per image or multiple labels per image
-    model_type = multi_label
-    image_filenames, image_labels = parse_filenames_and_labels_from_json(
-        DATA_JSON, LABELS, model_type)
-
-    # Validate epochs
-    epochs = (
-        DEFAULT_EPOCHS if NUM_EPOCHS is None
-        or NUM_EPOCHS <= 0 else int(NUM_EPOCHS)
-    )
-
-    # Build and compile the model on the data
-    model = build_and_compile_model(image_labels, model_type, IMG_SIZE + (3,))
-
-    # Save labels.txt file
-    save_labels(LABELS + [unknown_label], MODEL_DIR)
-    # Convert the model to TFLite
-    save_model(
-        model, MODEL_DIR, "classification_model"
-    )
-```
-
-{{% /expand %}}
-
-{{% expand "Click to see the template with parsed labels" %}}
-
-```python {class="line-numbers linkable-line-numbers" data-line="148" }
-import argparse
-import json
-import os
-import typing as ty
-from tensorflow.keras import Model  # Add proper import
-import tensorflow as tf  # Add proper import
-
-single_label = "MODEL_TYPE_SINGLE_LABEL_CLASSIFICATION"
-multi_label = "MODEL_TYPE_MULTI_LABEL_CLASSIFICATION"
-labels_filename = "labels.txt"
-unknown_label = "UNKNOWN"
-
-API_KEY = os.environ['API_KEY']
-API_KEY_ID = os.environ['API_KEY_ID']
-
-DEFAULT_EPOCHS = 200
-
-# This parses the required arguments for the training script.
-# The model_dir variable will contain the output directory where
-# the ML model that this script creates should be stored.
-# The data_json variable will contain the metadata for the dataset
-# that you should use to train the model.
-
-
-def parse_args():
-    """Returns the dataset file, model output directory, labels, and num_epochs,
-    if present. These must be parsed as command-line arguments and then used
-    as the model input and output, respectively. The number of epochs can be
-    used to optionally override the default.
-    """
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--dataset_file", dest="data_json",
-                        type=str, required=True)
-    parser.add_argument("--model_output_directory", dest="model_dir",
-                        type=str, required=True)
-    parser.add_argument("--num_epochs", dest="num_epochs", type=int)
-    parser.add_argument(
-        "--labels",
-        dest="labels",
-        type=str,
-        required=True,
-        help="Space-separated list of labels, \
-            enclosed in single quotes (e.g., 'label1 label2').",
-    )
-    args = parser.parse_args()
-
-    if not args.labels:
-        raise ValueError("Labels must be provided")
-
-    labels = [label.strip() for label in args.labels.strip("'").split()]
-    return args.data_json, args.model_dir, args.num_epochs, labels
-
-
-# This is used for parsing the dataset file (produced and stored in Viam),
-# parse it to get the label annotations
-# Used for training classification models
-
-
-def parse_filenames_and_labels_from_json(
-    filename: str, all_labels: ty.List[str], model_type: str
-) -> ty.Tuple[ty.List[str], ty.List[str]]:
-    """Load and parse JSON file to return image filenames and corresponding
-    labels. The JSON file contains lines, where each line has the key
-    "image_path" and "classification_annotations".
-    Args:
-        filename: JSONLines file containing filenames and labels
-        all_labels: list of all N_LABELS
-        model_type: string single_label or multi_label
-    """
-    image_filenames = []
-    image_labels = []
-
-    with open(filename, "rb") as f:
-        for line in f:
-            json_line = json.loads(line)
-            image_filenames.append(json_line["image_path"])
-
-            annotations = json_line["classification_annotations"]
-            labels = [unknown_label]
-            for annotation in annotations:
-                if model_type == multi_label:
-                    if annotation["annotation_label"] in all_labels:
-                        labels.append(annotation["annotation_label"])
-                # For a single-label model, we want at most one label.
-                # If multiple valid labels are present, we arbitrarily select
-                # the last one.
-                if model_type == single_label:
-                    if annotation["annotation_label"] in all_labels:
-                        labels = [annotation["annotation_label"]]
-            image_labels.append(labels)
-    return image_filenames, image_labels
-
-
-# Parse the dataset file (produced and stored in Viam) to get
-# bounding box annotations
-# Used for training object detection models
-def parse_filenames_and_bboxes_from_json(
-    filename: str,
-    all_labels: ty.List[str],
-) -> ty.Tuple[ty.List[str], ty.List[str], ty.List[ty.List[float]]]:
-    """Load and parse JSON file to return image filenames
-    and corresponding labels with bboxes.
-    Args:
-        filename: JSONLines file containing filenames and bboxes
-        all_labels: list of all N_LABELS
-    """
-    image_filenames = []
-    bbox_labels = []
-    bbox_coords = []
-
-    with open(filename, "rb") as f:
-        for line in f:
-            json_line = json.loads(line)
-            image_filenames.append(json_line["image_path"])
-            annotations = json_line["bounding_box_annotations"]
-            labels = []
-            coords = []
-            for annotation in annotations:
-                if annotation["annotation_label"] in all_labels:
-                    labels.append(annotation["annotation_label"])
-                    # Store coordinates in rel_yxyx format so that
-                    # we can use the KerasCV function
-                    coords.append(
-                        [
-                            annotation["y_min_normalized"],
-                            annotation["x_min_normalized"],
-                            annotation["y_max_normalized"],
-                            annotation["x_max_normalized"],
-                        ]
-                    )
-            bbox_labels.append(labels)
-            bbox_coords.append(coords)
-    return image_filenames, bbox_labels, bbox_coords
-
-
-# Build the model
-def build_and_compile_model(
-    labels: ty.List[str], model_type: str, input_shape: ty.Tuple[int, int, int]
-) -> Model:
-    """Builds and compiles a model
-    Args:
-        labels: list of string lists, where each string list contains up to
-        N_LABEL labels associated with an image
-        model_type: string single_label or multi_label
-        input_shape: 3D shape of the input
-    """
-
-    # TODO: Add logic to build and compile model
-
-    return model
-
-
-def save_labels(labels: ty.List[str], model_dir: str) -> None:
-    """Saves labels.txt with the output labels to the specified model directory.
-    Args:
-        labels: list of string lists, where each string list contains up to
-        N_LABEL labels associated with an image
-        model_dir: output directory for model artifacts
-    """
-    filename = os.path.join(model_dir, labels_filename)
-    with open(filename, "w") as f:
-        for label in labels[:-1]:
-            f.write(label + "\n")
-        f.write(labels[-1])
-
-
-def save_model(
-    model: Model,
-    model_dir: str,
-    model_name: str,
-) -> None:
-    """Save model as a TFLite model.
-    Args:
-        model: trained model
-        model_dir: output directory for model artifacts
-        model_name: name of saved model
-    """
-    # Save the model to the output directory
-    file_type = "tflite"  # Add proper file type
-    filename = os.path.join(model_dir, f"{model_name}.{file_type}")
-
-    # Example: Convert to TFLite
-    converter = tf.lite.TFLiteConverter.from_keras_model(model)
-    tflite_model = converter.convert()
-
-    # Save the model
-    with open(filename, "wb") as f:
-        f.write(tflite_model)
-
-
-if __name__ == "__main__":
-    DATA_JSON, MODEL_DIR, NUM_EPOCHS, LABELS = parse_args()
-
-    IMG_SIZE = (256, 256)
-
-    # Read dataset file.
-    # The model type can be changed based on whether you want the model to
-    # output one label per image or multiple labels per image
-    model_type = multi_label
-    image_filenames, image_labels = parse_filenames_and_labels_from_json(
-        DATA_JSON, LABELS, model_type)
-
-    # Validate epochs
-    epochs = (
-        DEFAULT_EPOCHS if NUM_EPOCHS is None
-        or NUM_EPOCHS <= 0 else int(NUM_EPOCHS)
-    )
-
-    # Build and compile the model on the data
-    model = build_and_compile_model(image_labels, model_type, IMG_SIZE + (3,))
-
-    # Save labels.txt file
-    save_labels(LABELS + [unknown_label], MODEL_DIR)
-    # Convert the model to TFLite
-    save_model(
-        model, MODEL_DIR, "classification_model"
-    )
-```
-
-{{% /expand %}}
-
-{{% /tablestep %}}
-{{< tablestep >}}
-
-<p><strong>Understand template script parsing functionality</strong></p>
-<p>When a training script is run, the Viam platform passes the dataset file for the training and the designated model output directory to the script.</p>
-<p>The template contains functionality to parse the command-line inputs and parse annotations from the dataset file.</p>
-
-{{% expand "Click to see more information on parsing command-line inputs." %}}
-
-The script you are creating must take the following command-line inputs:
-
-- `dataset_file`: a file containing the data and metadata for the training job
-- `model_output_directory`: the location where the produced model artifacts are saved
-
-If you used the training script template that allows users to pass in labels, it also takes the following command-line input:
-
-- `labels`: space-separated list of labels, enclosed in single quotes
-
-The `parse_args()` function in the template parses your arguments.
-
-You can add additional custom command-line inputs by adding them to the `parse_args()` function.
-
-{{% /expand %}}
-
-{{% expand "Click to see more information on parsing annotations from the dataset file." %}}
-
-When you submit a training job to the Viam Cloud, Viam passes a `dataset_file` to the training script when you train an ML model with it.
-The file contains metadata from the dataset used for training, including the file path for each data point and any annotations associated with the data.
-
-Dataset JSON files for image datasets with bounding box labels and classification labels are formatted as follows:
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-    "image_path": "/path/to/data/data1.jpeg",
-    "bounding_box_annotations": [
-        {
-            "annotation_label": "blue_star",
-            "x_min_normalized": 0.38175675675675674,
-            "x_max_normalized": 0.5101351351351351,
-            "y_min_normalized": 0.35585585585585583,
-            "y_max_normalized": 0.527027027027027
-        }
-    ],
-    "classification_annotations": [
-        {
-            "annotation_label": "blue_star"
-        }
-    ]
-}
-{
-    "image_path": "/path/to/data/data2.jpeg",
-    "bounding_box_annotations": [
-        {
-            "annotation_label": "blue_star",
-            "x_min_normalized": 0.2939189189189189,
-            "x_max_normalized": 0.4594594594594595,
-            "y_min_normalized": 0.25225225225225223,
-            "y_max_normalized": 0.5495495495495496
-        }
-    ],
-    "classification_annotations": [
-        {
-            "annotation_label": "blue_star"
-        }
-    ]
-}
-
-{
-    "image_path": "/path/to/data/data3.jpeg",
-    "bounding_box_annotations": [
-        {
-            "annotation_label": "blue_star",
-            "x_min_normalized": 0.03557312252964427,
-            "x_max_normalized": 0.2015810276679842,
-            "y_min_normalized": 0.30526315789473685,
-            "y_max_normalized": 0.5368421052631579
-        },
-        {
-            "annotation_label": "blue_square",
-            "x_min_normalized": 0.039525691699604744,
-            "x_max_normalized": 0.2015810276679842,
-            "y_min_normalized": 0.2578947368421053,
-            "y_max_normalized": 0.5473684210526316
-        }
-    ],
-    "classification_annotations": [
-        {
-            "annotation_label": "blue_star"
-        },
-        {
-            "annotation_label": "blue_square"
-        }
-    ]
-}
-```
-
-In your training script, you must parse the dataset file to extract classification or bounding box annotations from the dataset metadata.
-Depending on whether you are training a classification or detection model, the template script contains the `parse_filenames_and_labels_from_json()` and the `parse_filenames_and_bboxes_from_json()` function.
-
-{{% /expand%}}
-
-<p>If the script you are creating does not use an image dataset, you only need the model output directory.</p>
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Add logic to produce the model artifact**
-
-Fill in the `build_and_compile_model` function.
-In this part of the script, you use data and annotations from the dataset file to build an ML model.
-
-As an example, you can refer to the logic from <file>model/training.py</file> from this [example classification training script](https://github.com/viam-modules/classification-tflite) that trains a classification model using TensorFlow and Keras.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Use a temporary directory for intermediate files**
-
-If you need to create intermediate or other temporary files, you can write those files to `model_output_directory/tmp`.
-Files in `model_output_directory/tmp` do not get uploaded as part of the final model artifact.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Save the model artifact**
-
-In this example template, the training job produces a model artifact.
-The `save_model()` and `save_labels()` functions save that model artifact to the `model_output_directory`.
-
-When the training job completes, Viam checks the output directory for the model artifact, packages the model, and uploads it to the registry.
-
-You must fill in the `save_model()` and `save_labels()` functions.
-
-As an example, refer to the logic from <file>model/training.py</file> from this [example classification training script](https://github.com/viam-modules/classification-tflite) that trains a classification model using TensorFlow and Keras.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Update the main method**
-
-Update the main to call the functions you have just created.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Use Viam APIs in a training script**
-
-To access [Viam APIs](/dev/reference/apis/) within a custom training script, use the environment variables `API_KEY` and `API_KEY_ID` to establish a connection.
-
-```python
-async def connect() -> ViamClient:
-    """Returns an authenticated connection to the ViamClient for the requested
-    org associated with the submitted training job."""
-    # The API key and key ID can be accessed programmatically, using the
-    # environment variable API_KEY and API_KEY_ID. The user does not need to
-    # supply the API keys, they are provided automatically when the training
-    # job is submitted.
-    dial_options = DialOptions.with_api_key(
-        os.environ.get("API_KEY"), os.environ.get("API_KEY_ID")
-    )
-    return await ViamClient.create_from_dial_options(dial_options)
-```
-
-{{% /tablestep %}}
-{{< /table >}}
-
-## Test your training script locally
-
-You can export one of your Viam datasets to test your training script locally.
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Export your dataset**
-
-You can get the dataset ID from the dataset page or using the [`viam dataset list`](/dev/tools/cli/#dataset) command:
-
-```sh {class="command-line" data-prompt="$"}
-viam dataset export --destination=<destination> --dataset-id=<dataset-id> --include-jsonl=true
-```
-
-The dataset will be formatted like the one Viam produces for training.
-Use the `parse_filenames_and_labels_from_json` and `parse_filenames_and_bboxes_from_json` functions to get the images and annotations from your dataset file.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Run your training script locally**
-
-Install any required dependencies and run your training script, specifying the path to the <FILE>dataset.jsonl</FILE> file from your exported dataset:
-
-```sh {class="command-line" data-prompt="$"}
-python3 -m model.training --dataset_file=/path/to/dataset.jsonl \
-    --model_output_directory=. --custom_arg=3
-```
-
-{{% /tablestep %}}
-{{< /table >}}
-
-## Upload your training script
-
-To use your training script on the Viam platform, you must upload it to the Viam Registry.
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Package the training script as a <file>tar.gz</file> source distribution**
-
-Before you can upload your training script to Viam, you must compress your project folder into a tar.gz file:
-
-```sh {class="command-line" data-prompt="$"}
-tar -czvf my-training.tar.gz my-training/
-```
-
-{{% alert title="Tip" color="tip" %}}
-You can refer to the directory structure of this [example classification training script](https://github.com/viam-modules/classification-tflite).
-{{% /alert %}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Upload a training script**
-
-To upload your custom training script to the registry, use the `viam training-script upload` command.
-
-{{< tabs >}}
-{{% tab name="Usage" %}}
-
-```sh {class="command-line" data-prompt="$"}
-viam training-script upload --path=<path-to-tar.gz> \
-  --org-id=<org-id> --script-name=<training-script-name>
-```
-
-{{% /tab %}}
-{{% tab name="Examples" %}}
-
-```sh {class="command-line" data-prompt="$"}
-viam training-script upload --path=my-training.tar.gz \
-  --org-id=<ORG_ID> --script-name=my-training-script
-
-viam training-script upload --path=my-training.tar.gz \
-  --org-id=<ORG_ID> --script-name=my-training \
-  --framework=tensorflow --type=single_label_classification \
-  --description="Custom image classification model" \
-  --visibility=private
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-You can also [specify the version, framework, type, visibility, and description](/dev/tools/cli/#training-script) when uploading a custom training script.
-
-To find your organization's ID, run the following command:
-
-```sh {class="command-line" data-prompt="$"}
-viam organization list
-```
-
-After a successful upload, the CLI displays a confirmation message with a link to view your changes online.
-You can view uploaded training scripts by navigating to the [registry's **Training Scripts** page](https://app.viam.com/registry?type=Training+Script).
-
-{{% /tablestep %}}
-{{< /table >}}
-
-## Submit a training job
-
-After uploading the training script, you can run it by submitting a training job using the web UI, the CLI or the [ML training client API](/dev/reference/apis/ml-training-client/#submittrainingjob).
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Create the training job**
-
-{{< tabs >}}
-{{% tab name="Web UI" min-height="150px" %}}
-Navigate to your list of [**DATASETS**](https://app.viam.com/data/datasets) and select the one you want to train a model on.
-
-Click **Train model** and select **Train on a custom training script**, then follow the prompts.
-
-{{% alert title="Tip" color="tip" %}}
-If you used the version of <file>training.py</file> that allows users to pass in labels, your training job will fail with the error `ERROR training.py: error: the following arguments are required: --labels`.
-To pass labels, you must use the CLI.
-{{% /alert %}}
-
-{{% /tab %}}
-{{% tab name="CLI" %}}
-
-You can use [`viam train submit custom from-registry`](/dev/tools/cli/#positional-arguments-submit) to submit a training job.
-
-For example:
-
-```sh {class="command-line" data-prompt="$"}
-viam train submit custom from-registry --dataset-id=<INSERT DATASET ID> \
-  --org-id=<INSERT ORG ID> --model-name=MyRegistryModel \
-  --model-version=2 --version=1 \
-  --script-name=mycompany:MyCustomTrainingScript \
-  --args=custom_arg1=3,custom_arg2="'green_square blue_star'"
-```
-
-This command submits a training job to the previously uploaded `MyCustomTrainingScript` with another input dataset, which trains `MyRegistryModel` and publishes that to the registry.
-
-You can get the dataset ID from the **DATASET** tab of the **DATA** page or by running the [`viam dataset list`](/dev/tools/cli/#dataset) command.
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Check on training job progress**
-
-You can view your training job on the **DATA** page's [**TRAINING** tab](https://app.viam.com/training).
-
-Once the model has finished training, it becomes visible on the **DATA** page's [**MODELS** tab](https://app.viam.com/models).
-
-You will receive an email when your training job completes.
-
-You can also check your training jobs and their status from the CLI:
-
-```sh {class="command-line" data-prompt="$"}
-viam train list --org-id=<INSERT ORG ID> --job-status=unspecified
-```
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Debug your training job**
-
-From the **DATA** page's [**TRAINING** tab](https://app.viam.com/training), click your training job ID to see its logs.
-
-{{< alert title="Note" color="note" >}}
-
-Your training script may output logs at the error level but still succeed.
-
-{{< /alert >}}
-
-You can also view your training jobs' logs with the [`viam train logs`](/dev/tools/cli/#train) command.
-
-Training logs expire after 7 days.
-
-{{% /tablestep %}}
-{{< /table >}}
-
-To use your new model with machines, you must [deploy it](/data-ai/ai/deploy/) with the appropriate ML model service.
-Then you can use another service, such as the vision service, to [run inference](/data-ai/ai/run-inference/).
diff --git a/docs/data/_index.md b/docs/data/_index.md
new file mode 100644
index 0000000000..531cd36752
--- /dev/null
+++ b/docs/data/_index.md
@@ -0,0 +1,43 @@
+---
+linkTitle: "Manage data"
+title: "Manage data"
+weight: 40
+layout: "docs"
+type: "docs"
+no_list: true
+manualLink: "/data/overview/"
+description: "Record sensor data on your robot, sync it to the cloud, and query, export, or use it for ML training."
+aliases:
+  - /build/data/
+  - /services/data/capture/
+  - /data/capture/
+  - /build/micro-rdk/data_management/
+  - /services/data/cloud-sync/
+  - /data/cloud-sync/
+  - /services/data/capture-sync/
+  - /how-tos/sensor-data/
+  - /services/data/
+  - fleet/data-management/
+  - /manage/data-management/
+  - /services/data-management/
+  - /manage/data/
+  - /data-management/
+  - /manage/data/view/
+  - /data/view/
+  - /services/data/view/
+  - /how-tos/collect-data/
+  - /how-tos/collect-sensor-data/
+  - /get-started/quickstarts/collect-data/
+  - /use-cases/collect-sensor-data/
+  - /use-cases/image-data/
+  - /get-started/collect-data/
+  - /fleet/data-management/
+  - /data-ai/capture-data/capture-sync/
+  - /data/data-capture-reference/
+  - /data/how-sync-works/
+  - /data-ai/capture-data/advanced/how-sync-works/
+  - /data/capture-sync/how-sync-works/
+  - /data-ai/
+  - /data-ai/capture-data/
+  - /data-ai/data/
+---
diff --git a/docs/data/capture-sync/_index.md b/docs/data/capture-sync/_index.md
new file mode 100644
index 0000000000..df574d8515
--- /dev/null
+++ b/docs/data/capture-sync/_index.md
@@ -0,0 +1,10 @@
+---
+linkTitle: "Capture and sync"
+title: "Capture and sync"
+weight: 10
+layout: "docs"
+type: "docs"
+no_list: true
+description: "Capture data from your machines and sync it to the cloud."
+manualLink: "/data/capture-sync/capture-and-sync-data/"
+---
diff --git a/docs/data/capture-sync/capture-and-sync-data.md b/docs/data/capture-sync/capture-and-sync-data.md
new file mode 100644
index 0000000000..442d83a148
--- /dev/null
+++ b/docs/data/capture-sync/capture-and-sync-data.md
@@ -0,0 +1,140 @@
+---
+linkTitle: "Start data capture"
+title: "Start data capture"
+weight: 5
+layout: "docs"
+type: "docs"
+description: "Capture data from any resource and sync it to the cloud."
+date: "2025-01-30"
+aliases:
+  - /data/capture-and-sync-data/
+  - /build/foundation/capture-and-sync-data/
+  - /foundation/capture-and-sync-data/
+---
+
+Configure your machine to automatically record sensor readings, camera images, and other component data, then sync it to the cloud. For an overview of how data capture and sync work, see the [Manage data overview](/data/overview/).
+
+## 1. Open your machine in the Viam app
+
+Go to [app.viam.com](https://app.viam.com) and navigate to your machine.
+Confirm it shows as **Live** in the upper left.
+
+## 2. Enable data capture on a component
+
+1. Find your component (for example, `my-camera`) in the machine configuration.
+2. Click the **Data Capture** button.
+3. If you see a "Data management service missing" banner, click
+   **Create data management service**, click **Save**, navigate back to
+   your component, and click the **Data Capture** button again.
+4. Select the method to capture:
+   - For a camera, select **GetImages**. This captures a frame from the camera
+     each time it fires.
+   - For a sensor, select **Readings**. This records the sensor's current
+     values.
+5. Set the **capture frequency**. This is specified in hertz (captures per
+   second):
+   - `0.5` = one capture every 2 seconds
+   - `0.2` = one capture every 5 seconds
+   - `1` = one capture per second
+   - Start low. For cameras, `0.5` Hz is a reasonable starting point. You can
+     always increase it later.
+6. Click **Save** in the upper right.
+
+After saving, `viam-server` begins capturing immediately. You do not need to
+restart anything.
+
+{{< alert title="Tip" color="tip" >}}
+
+You can add multiple capture methods to a single component (for example,
+capture both `GetImages` and `NextPointCloud` from the same camera), each
+with its own frequency.
+
+{{< /alert >}}
+
+## 3. Capture from additional components (optional)
+
+Repeat step 2 for any other components you want to capture from. Each
+component's data capture is independent -- you can have a camera capturing
+images every 2 seconds and a sensor capturing readings every 10 seconds at the
+same time.
+
+## 4. Sync data from another directory (optional)
+
+You can also sync files from directories outside of the default capture path.
+This is useful for uploading a batch of existing data or syncing files that another process writes to a folder on your machine.
+
+In the data management service configuration, add the directory path to **Additional paths** (or `"additional_sync_paths"` in JSON mode).
+
+{{< alert title="Caution" color="caution" >}}
+
+Data synced from additional paths is deleted from the device after upload, just like captured data.
+If you want to keep a local copy, copy the data to a new folder and sync that folder instead.
+
+{{< /alert >}}
+
+{{<imgproc src="/services/data/data-sync-temp.png" resize="x1100" declaredimensions=true alt="Data service configured with an additional sync path." style="width: 600px" class="shadow imgzoom" >}}
+
+## 5. Verify data is syncing
+
+Wait 30 seconds to a minute for data to accumulate and sync, then:
+
+1. In the Viam app, click the **DATA** tab in the top navigation. The tab opens on the **Images** view by default.
+2. For camera captures, you should see image thumbnails appearing. For sensor data, click the **Sensors** tab to see the latest readings from each machine and resource. To see historical rows of tabular data, click the small search icon next to a resource on the Sensors tab to open the query editor.
+3. Use the filters on the left to narrow by:
+   - **Machine** -- select your specific machine
+   - **Component** -- select the component you configured
+   - **Time range** -- pick a recent window
+
+If you see data flowing in, capture and sync are working correctly.
+
+## Troubleshooting
+
+{{< expand "No data appears in the Data tab" >}}
+
+- **Wait a minute.** Data must be captured locally and then synced to the cloud.
+  The first entries can take 30-60 seconds to appear.
+- **Is the data management service enabled?** Go to your machine's
+  **CONFIGURE** tab and check that the data management service exists and both
+  **Capturing** and **Syncing** are toggled on.
+- **Is capture configured on the component?** Verify that the component's Data
+  capture section shows at least one method with a non-zero frequency.
+- **Is the machine online?** Data syncs only when the machine has a network
+  connection. Check the machine's status indicator in the Viam app.
+
+{{< /expand >}}
+
+{{< expand "Data appears but images are missing or blank" >}}
+
+- Verify the camera works in the test panel first. If the test panel shows
+  nothing, the issue is with the camera configuration, not data capture.
+- Check that the capture method is **GetImages**, not another method.
+
+{{< /expand >}}
+
+{{< expand "Data capture frequency seems wrong" >}}
+
+- The frequency is in hertz (captures per second), not seconds between captures.
+  `0.5` Hz means once every 2 seconds, not twice per second.
+- High-frequency capture (above 1 Hz for cameras) generates large amounts of
+  data. Start with `0.5` Hz or lower unless you need high-frequency capture.
+
+{{< /expand >}}
+
+{{< expand "Local disk filling up" >}}
+
+- By default, captured data is stored in `$HOME/.viam/capture` before syncing
+  (`/root/.viam/capture` when `viam-server` runs as root through `viam-agent`).
+  If sync is disabled or the machine is offline for an extended period, this
+  directory can grow large.
+- Re-enable sync or manually clear the capture directory if needed.
+- Check that the **Syncing** toggle is on in the data management service
+  configuration.
+
+{{< /expand >}}
+
+## What's next
+
+- [Query data](/data/query-data/): write queries, set up data pipelines, and export data
+- [Add computer vision](/vision/configure/): run ML models on your camera feed and capture detection results
+- [Create a dataset](/train/create-a-dataset/): organize captured images into training datasets
+- [Reference](/data/reference/): JSON-level config, retention policies, and sync optimization
diff --git a/docs/data/capture-sync/conditional-sync.md b/docs/data/capture-sync/conditional-sync.md
new file mode 100644
index 0000000000..a07c75a4a3
--- /dev/null
+++ b/docs/data/capture-sync/conditional-sync.md
@@ -0,0 +1,110 @@
+---
+title: "Conditional sync"
+linkTitle: "Conditional sync"
+description: "Control when captured data syncs to the cloud using a sensor that decides whether to sync."
+type: "docs"
+weight: 10
+tags: ["data management", "cloud", "sync"]
+images: ["/services/icons/data-cloud-sync.svg"]
+icon: true
+aliases:
+  - /data/conditional-sync/
+  - /data-ai/capture-data/conditional-sync/
+  - /data/trigger-sync/
+  - /how-tos/trigger-sync/
+  - /services/data/trigger-sync/
+  - /how-tos/conditional-sync/
+viamresources: ["sensor", "data_manager"]
+platformarea: ["data", "registry"]
+date: "2024-12-04"
+updated: "2025-12-04"
+---
+
+By default, the data management service syncs all captured data at a regular interval. Conditional sync lets you control _when_ sync happens, so data accumulates locally until your conditions are met: sync only during off-peak hours, when connected to WiFi, after a sensor reading crosses a threshold, or based on any other logic you define.
+
+## How conditional sync works
+
+Conditional sync uses a sensor component as a gate. You configure a sensor whose `Readings()` method returns `"should_sync": true` or `"should_sync": false`. At each sync interval, the data manager calls `Readings()` on this sensor before uploading. If the result is `true`, sync proceeds. If `false`, the cycle is skipped and data continues to accumulate locally.
+
+The sensor is the only mechanism for conditional sync. There is no built-in rules engine or config-only option. Any logic you need goes in the sensor's `Readings()` implementation. You can use an existing sensor module from the registry or write your own.
+
+{{< alert title="Important" color="caution" >}}
+If `selective_syncer_name` is configured but the sensor cannot be found, **scheduled sync is disabled** until the sensor becomes available. Make sure the sensor is correctly configured and added to the data manager's `depends_on` field.
+{{< /alert >}}
+
+{{< alert title="Conditional sync does not control capture" color="caution" >}}
+Conditional sync only controls _when data is uploaded_. Capture continues writing to local disk at the configured frequency regardless of whether sync is active. If the sync window is short or bandwidth is limited, the backlog from a full capture cycle may not clear in a single window. Monitor the capture directory size on constrained devices. See [Manage local storage](/data/filter-at-the-edge/#manage-local-storage) for storage management guidance.
+{{< /alert >}}
+
+## Configure conditional sync
+
+This example uses the [`sync-at-time/timesyncsensor`](https://app.viam.com/module/naomi/sync-at-time) sensor module to sync data only during a configured time window. You can substitute any sensor that returns `should_sync`.
+
+### 1. Add the sync sensor
+
+1. On your machine's **CONFIGURE** tab, click **+** next to your machine part and select **Component or service**.
+2. Search for **sync-at-time/timesyncsensor** and select the result.
+3. Click **Add module**, enter a name (for example, `timesensor`), and click **Create**.
+4. Configure the time window in the sensor's attributes:
+
+   ```json
+   {
+     "start": "18:00:00",
+     "end": "06:00:00",
+     "zone": "America/New_York"
+   }
+   ```
+
+   | Field   | Type   | Required | Description                                                                                                                                                                           |
+   | ------- | ------ | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+   | `start` | string | Yes      | Start of the sync window in `HH:MM:SS` format.                                                                                                                                        |
+   | `end`   | string | Yes      | End of the sync window in `HH:MM:SS` format.                                                                                                                                          |
+   | `zone`  | string | Yes      | An [IANA Time Zone Database](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) name. Examples: `"America/New_York"`, `"Europe/Berlin"`, `"Asia/Tokyo"`, `"UTC"`, `"CET"`. |
+
+5. Click **Save**.
+
+### 2. Point the data manager at the sensor
+
+The `selective_syncer_name` field is not available in the UI. Switch to **JSON** mode on the **CONFIGURE** tab.
+
+Find the data management service in your config and add two fields:
+
+- `selective_syncer_name`: the name of your sync sensor
+- `depends_on`: include the sensor name so the data manager waits for it to be available
+
+```json {class="line-numbers linkable-line-numbers" data-line="7,12"}
+{
+  "name": "data_manager-1",
+  "api": "rdk:service:data_manager",
+  "model": "rdk:builtin:builtin",
+  "attributes": {
+    "additional_sync_paths": [],
+    "selective_syncer_name": "timesensor",
+    "sync_interval_mins": 0.1,
+    "capture_dir": "",
+    "tags": []
+  },
+  "depends_on": ["timesensor"]
+}
+```
+
+Click **Save**.
+
+### 3. Verify conditional sync is working
+
+1. Confirm data capture is running: check the machine's **LOGS** for capture activity.
+2. If you are outside the sync window, data should accumulate locally but not appear in the **DATA** tab.
+3. When the sync window opens, check the **DATA** tab. Captured data should begin appearing.
+4. If data appears immediately regardless of the window, check that `selective_syncer_name` matches the sensor name exactly and that the sensor is in `depends_on`.
+
+## Build a custom sync sensor
+
+If no existing module fits your use case, you can write a sensor module that implements whatever sync logic you need: check network connectivity, compare sensor readings to a threshold, query an external API, or combine multiple conditions.
+
+The sensor must implement the [sensor API](/hardware/common-components/add-a-sensor/) and return a `"should_sync"` key with a boolean value from `Readings()`. The data manager checks this key at each sync interval. The sensor can return additional readings alongside `should_sync`.
+
+The RDK provides a helper: `datamanager.CreateShouldSyncReading(bool)` returns a properly formatted readings map.
+
+1. Follow the [module development guide](/build-modules/write-a-driver-module/) to create a sensor module.
+2. Implement `Readings()` to return `"should_sync": true` when sync should proceed and `"should_sync": false` otherwise.
+3. Deploy the module and [configure the data manager](#2-point-the-data-manager-at-the-sensor) with your sensor's name.
diff --git a/docs/data/capture-sync/remote-parts-capture.md b/docs/data/capture-sync/remote-parts-capture.md
new file mode 100644
index 0000000000..5071efbbe4
--- /dev/null
+++ b/docs/data/capture-sync/remote-parts-capture.md
@@ -0,0 +1,104 @@
+---
+linkTitle: "Multi-part capture"
+title: "Capture data from multi-part machines"
+weight: 15
+layout: "docs"
+type: "docs"
+description: "Capture and sync data from components on sub-parts and remote parts of a multi-part machine."
+date: "2025-02-10"
+---
+
+Viam machines can be split across multiple computers. When that happens, data capture behaves differently depending on whether the additional computer is a sub-part or a remote part. Understanding which pattern you have is the key to configuring capture correctly.
+
+## Terminology
+
+- **Sub-part**: an additional part of the _same_ machine. Each sub-part runs its own `viam-server` with its own configuration and its own filesystem.
+- **Remote part**: a part of a _different_ machine that yours accesses over the network. A remote part is itself a separate machine in the Viam app.
+
+## How capture differs
+
+|                                       | Sub-part                                     | Remote part                |
+| ------------------------------------- | -------------------------------------------- | -------------------------- |
+| Data manager lives on                 | The sub-part itself                          | The main part              |
+| `.capture` files are written to       | The sub-part's filesystem                    | The main part's filesystem |
+| Sync uploads from                     | The sub-part                                 | The main part              |
+| Where you configure capture           | The sub-part's section of the machine config | The main machine's config  |
+| Captured metadata `part_id` is set to | The sub-part's `part_id`                     | The main part's `part_id`  |
+
+All captured data from a multi-part _machine_ shares the same `robot_id` (machine UUID), so you can query across all parts of one multi-part machine in a single SQL or MQL query. Data from a remote part that belongs to a different machine has a different `robot_id`.
+
+## Sub-parts
+
+Each sub-part is an independent `viam-server` instance with its own configuration and dependency graph. The main part's data manager cannot reach into a sub-part to capture its resources; the sub-part needs its own data manager service.
+
+### Configure data capture on a sub-part
+
+1. In the Viam app, navigate to the sub-part's section of your machine's **CONFIGURE** tab.
+2. Find the component on the sub-part that you want to capture from.
+3. Click the **Data Capture** button on the component.
+4. If you see a "Data management service missing" banner, click
+   **Create data management service**, click **Save**, navigate back to
+   the component, and click the **Data Capture** button again.
+5. Select the capture method and frequency as you would for a local component.
+6. Click **Save**.
+
+The sub-part's `viam-server` writes `.capture` files to its own local capture directory and syncs them to the cloud from there. In the **DATA** tab, the rows appear under the main machine, but the captured metadata carries the sub-part's `part_id`.
+
+## Remote parts
+
+Remote parts appear in the main part's dependency graph, and the main part's data manager can be configured to capture from them exactly like local resources. All capture and sync happens on the main part's host.
+
+### 1. Add the remote part to your main machine
+
+1. In the Viam app, navigate to your main machine's **CONFIGURE** tab.
+2. Click the **+** button next to the main part's name.
+3. Select **Remote part**.
+4. Select the machine and part you want to add as a remote. The Viam app lists parts you have access to.
+5. Click **Save**.
+
+The main machine can now access all components on the remote part. You can verify this on the **CONTROL** tab, where the remote's components appear under the remote's section.
+
+For more details on remote part configuration, including authentication and manual JSON, see the Viam app's **CONFIGURE** tab for your machine.
+
+### 2. Configure data capture on the remote's components
+
+Once the remote part is added, its components appear on the main machine's **CONFIGURE** tab under the remote's section. Configure data capture through the main machine's config, not through the remote machine's config:
+
+1. Find the remote component in the main machine's **CONFIGURE** tab.
+2. Click the **Data Capture** button on the component.
+3. Select the capture method (for example, **GetImages** for a camera, **Readings** for a sensor).
+4. Set the capture frequency.
+5. Click **Save**.
+
+The main part captures and syncs the remote's data. Files are written to the main part's capture directory and uploaded to the cloud from there.
+
+{{< alert title="Do not configure capture on both parts" color="caution" >}}
+If the remote part also has its own data management service with capture enabled on the same components, you will get duplicate `.capture` files and duplicate rows in the cloud. Configure capture on the main part only, and confirm that the remote machine's data manager does not have overlapping capture methods.
+{{< /alert >}}
+
+### 3. Verify data is being captured
+
+Wait 30 seconds to a minute, then:
+
+1. Click the **DATA** tab in the Viam app.
+2. Filter by the main machine's name.
+3. For cameras, captured images appear under **Images**. For sensors, click **Sensors** to see the latest reading per resource.
+4. The captured `component_name` matches the name the component has on the remote part.
+
+If no data appears, check:
+
+- The remote part is online and reachable from the main part (verify on the **CONTROL** tab).
+- The data management service on the main part has capture and sync enabled.
+- The capture method is configured on the remote component in the **main machine's** config, not the remote machine's config.
+
+## Example: capture camera images from a remote Pi
+
+Your main machine runs an arm for pick-and-place operations. A Raspberry Pi at a different location has a camera monitoring the workspace and is registered as its own Viam machine. You want to capture images from the Pi's camera through the main arm machine so all data flows through one capture pipeline.
+
+1. Configure the Pi as its own Viam machine with a webcam component.
+2. On your main arm machine, add the Pi's machine part as a remote part (see [Add the remote part](#1-add-the-remote-part-to-your-main-machine)).
+3. On the main machine's **CONFIGURE** tab, find the Pi's `workspace-cam` component under the remote part section.
+4. Add data capture on `workspace-cam` with method **GetImages** at 0.5 Hz (one image every 2 seconds).
+5. Click **Save**.
+
+The main machine captures images from the Pi's camera and syncs them to the cloud alongside any data captured from its own local components. The Pi itself does not need a data management service for this flow.
diff --git a/docs/data/capture-sync/stop-data-capture.md b/docs/data/capture-sync/stop-data-capture.md
new file mode 100644
index 0000000000..3e077013e6
--- /dev/null
+++ b/docs/data/capture-sync/stop-data-capture.md
@@ -0,0 +1,100 @@
+---
+linkTitle: "Stop data capture"
+title: "Stop or disable data capture"
+weight: 6
+layout: "docs"
+type: "docs"
+description: "Stop capturing data for specific resources, all resources, or disable cloud sync."
+date: "2025-01-30"
+aliases:
+  - /data/stop-data-capture/
+  - /build/foundation/stop-data-capture/
+  - /foundation/stop-data-capture/
+---
+
+Stop data capture temporarily (during maintenance, testing, or debugging) or permanently. You can disable capture for a single resource, turn it off for all resources on a machine, or leave capture running locally but stop syncing to the cloud.
+
+## Stop data capture for a specific resource
+
+To stop capturing data from a single component while leaving other components'
+capture running:
+
+1. Navigate to your machine's **CONFIGURE** tab in the Viam app.
+2. Find the component you want to stop capturing from.
+3. In the **Data Capture** section, toggle the configured capture method's switch to **Off**.
+4. Click **Save**.
+
+The component stops capturing immediately. Other components with data capture
+configured continue capturing normally.
+
+## Stop data capture for all resources
+
+To stop all data capture across your entire machine at once:
+
+1. Navigate to your machine's **CONFIGURE** tab.
+2. Find the **data management** service in your configuration.
+3. Toggle the **Capturing** switch to **Off**.
+4. Click **Save**.
+
+This disables capture for every component on the machine. Individual component
+capture configurations are preserved. When you re-enable capturing, each
+component resumes capturing with its previously configured methods and
+frequencies.
+
+## Disable cloud sync
+
+To stop syncing captured data to the cloud while optionally continuing to
+capture locally:
+
+1. Navigate to your machine's **CONFIGURE** tab.
+2. Find the **data management** service in your configuration.
+3. Toggle the **Syncing** switch to **Off**.
+4. Click **Save**.
+
+With sync disabled, data continues to accumulate in the local capture directory
+(`~/.viam/capture` by default) but is not transmitted to the cloud. When you
+re-enable sync, the backlog of locally captured data syncs automatically.
+
+{{< alert title="Note" color="note" >}}
+
+If you leave sync disabled for an extended period while capture continues,
+the local capture directory can grow large. Monitor disk space on your machine
+if you plan to capture without syncing.
+
+{{< /alert >}}
+
+## Troubleshooting
+
+{{< expand "Data still appearing in the cloud after disabling capture" >}}
+
+- Click **Save** after toggling the switch. Changes don't take effect until saved.
+- Data that was already captured and queued for sync will still sync even after
+  capture is disabled. Wait for the sync backlog to drain.
+
+{{< /expand >}}
+
+{{< expand "Want to delete already-captured data" >}}
+
+Stopping capture prevents new data from being collected, but does not delete
+existing data. To delete data that has already synced to the cloud, use the
+**DATA** tab in the Viam app to filter and delete specific data entries.
+
+{{< /expand >}}
+
+{{< expand "Local capture directory still has files after re-enabling sync" >}}
+
+After re-enabling sync, it may take a few minutes for the backlog to upload.
+Files are removed from the local directory after successful sync. If files
+persist, check that the machine has network connectivity and that the
+**Syncing** switch is on.
+
+{{< /expand >}}
+
+## What's next
+
+- [Filter at the edge](/data/filter-at-the-edge/) -- reduce data
+  volume by filtering before syncing to the cloud.
+- [Create a data pipeline](/data/pipelines/create-a-pipeline/) -- create
+  scheduled pipelines to aggregate and summarize captured data.
+- [Supported resources](/data/reference/#supported-resources) -- which components
+  and services support data capture.
diff --git a/docs/data/capture-sync/upload-other-data.md b/docs/data/capture-sync/upload-other-data.md
new file mode 100644
index 0000000000..b0ab038a42
--- /dev/null
+++ b/docs/data/capture-sync/upload-other-data.md
@@ -0,0 +1,83 @@
+---
+linkTitle: "Upload external data"
+title: "Upload external data"
+images: ["/services/icons/data-folder.svg"]
+weight: 25
+layout: "docs"
+type: "docs"
+languages: ["python", "go"]
+viamresources: ["data_manager"]
+aliases:
+  - /data/upload-other-data/
+  - /data-ai/capture-data/upload-other-data/
+  - /data-ai/ai/advanced/upload-external-data/
+  - /data-ai/ai/advanced/
+  - /data-ai/train/upload-external-data/
+date: "2024-12-04"
+updated: "2025-09-11"
+description: "Upload data to Viam from your local computer or mobile device using the data client API or the Viam mobile app."
+---
+
+The [data management service](/data/capture-sync/capture-and-sync-data/) captures and syncs data from your machines automatically.
+If you have data from other sources (images from your phone, files on your laptop, or data generated by external processes), you can upload it to Viam directly.
+
+| Method                                           | Use case                                                           | Deletes local data? | Duplicates on re-run? |
+| ------------------------------------------------ | ------------------------------------------------------------------ | ------------------- | --------------------- |
+| [Directory sync](#sync-files-from-a-directory)   | Sync files that another process writes to a folder on your machine | **Yes**             | No                    |
+| [SDK upload](#upload-with-sdks)                  | Programmatic upload from any computer                              | No                  | Yes                   |
+| [Mobile app](#upload-images-with-the-mobile-app) | Quick image upload from your phone for ML training                 | No                  | No                    |
+
+## Sync files from a directory
+
+If another process on your machine writes files to a folder (for example, log files, exported CSVs, or images from a third-party application), you can have the data management service sync that folder to the cloud automatically.
+
+Add the directory path to **Additional paths** in the data management service configuration (or `"additional_sync_paths"` in JSON mode). See [Sync data from another directory](/data/capture-sync/capture-and-sync-data/#4-sync-data-from-another-directory-optional) for step-by-step instructions.
+
+**How it works:**
+
+- The data management service monitors the directory and uploads any file that has not been modified for at least 10 seconds (configurable with `file_last_modified_millis` in the [data management service attributes](/data/reference/#data-management-service-attributes)).
+- **Uploaded files are deleted from the local directory after successful sync.** If you need to keep a local copy, copy the files to a separate folder and point `additional_sync_paths` at the copy.
+- Uploaded files are stored in Viam's cloud storage and associated with the machine's `part_id`, `location_id`, and `organization_id`. They are not associated with a specific component or capture method.
+- Synced files appear on the **DATA** tab under **Files** (not under Images or Sensors, even if the files are images).
+
+## Upload with SDKs
+
+Use the [Data Client API](/reference/apis/data-client/) to upload files programmatically.
+Unlike the data management service, the [`FileUploadFromPath`](/reference/apis/data-client/#fileuploadfrompath) method does not delete local files after upload, but it will duplicate data if you run it more than once.
+
+1. Create an [API key](/organization/access/) for your organization, location, or machine.
+2. Use [`FileUploadFromPath`](/reference/apis/data-client/#fileuploadfrompath) to upload a file.
+   You must provide a {{< glossary_tooltip term_id="part" text="machine part" >}} ID to associate the data with.
+3. Run your code once.
+   Running it again uploads the same files a second time.
+4. Check the [**DATA** tab](https://app.viam.com/data/view) to confirm your data appears.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+{{< read-code-snippet file="/static/include/examples-generated/upload-single-file.snippet.upload-single-file.py" lang="py" class="line-numbers linkable-line-numbers" data-line="31-38" >}}
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+{{< read-code-snippet file="/static/include/examples-generated/upload-single-file.snippet.upload-single-file.go" lang="go" class="line-numbers linkable-line-numbers" data-line="33-40" >}}
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Upload images with the mobile app
+
+The Viam mobile app lets you upload images directly from your phone, bypassing the normal capture and sync process.
+This is useful for quickly collecting training images for machine learning models.
+
+Install the app from the [App Store](https://apps.apple.com/vn/app/viam-robotics/id6451424162) or [Google Play](https://play.google.com/store/apps/details?id=com.viam.viammobile&hl=en&gl=US) if you haven't already.
+
+1. In the app, select an organization, then tap **Locations** and navigate to the machine you want the data associated with.
+2. Tap **...** in the upper right corner, then tap **Upload Images**.
+3. Select the images you want to upload and tap **Add**.
+
+Uploaded images are associated with the machine part you selected but not with a specific component or method.
+
+## Next steps
+
+If you uploaded data for machine learning, continue to [create a dataset](/train/create-a-dataset/).
diff --git a/docs/data/data-management-tutorial.md b/docs/data/data-management-tutorial.md
new file mode 100644
index 0000000000..e9e27547f4
--- /dev/null
+++ b/docs/data/data-management-tutorial.md
@@ -0,0 +1,217 @@
+---
+linkTitle: "Tutorial"
+title: "Capture, sync, and query data tutorial"
+weight: 2
+layout: "docs"
+type: "docs"
+description: "Capture sensor data, sync it to the cloud, view it in the Data tab, and query it from code."
+date: "2026-03-26"
+aliases:
+  - /data/capture-sync/data-capture-tutorial/
+---
+
+In this tutorial, you will set up a complete data pipeline: capture sensor data on your machine, sync it to Viam's cloud, view it in the Data tab, and query it from your own code. By the end, you will understand how data flows from your robot to the cloud and how to access it programmatically.
+
+**Time:** ~15 minutes
+
+**What you need:**
+
+- A machine connected to the Viam app (if you don't have one yet, follow [Set up a machine](/foundation/))
+- Python 3 installed on your laptop or desktop (for the final step)
+
+We will use a fake sensor so this tutorial works without any physical hardware.
+
+## 1. Add a fake sensor
+
+We need a component that produces data. The built-in `sensor/fake` component returns a fixed set of readings every time it is polled, which is enough to exercise the capture, sync, and query pipeline end to end.
+
+1. Go to your machine's page in the Viam app.
+2. Click the **+** button in the left sidebar.
+3. Select **Configuration block**.
+4. Search for **sensor/fake** and select the result.
+5. Name it `test-sensor` and click **Create**.
+6. Click **Save** in the upper right.
+
+Expand the **test** section on the sensor's component card. You should see `{"a": 1, "b": 2, "c": 3}` returned from `GetReadings`. This confirms the sensor is working.
+
+{{< alert title="Note" color="note" >}}
+`sensor/fake` always returns the same values. As you capture data in the next steps, every row will have identical `data` but a fresh `time_received` timestamp. That is enough to verify the full pipeline. With a real sensor, the values would change each reading.
+{{< /alert >}}
+
+## 2. Enable data capture
+
+Now we will tell Viam to record every reading from this sensor.
+
+1. Find the `test-sensor` component in the **CONFIGURE** tab.
+2. Click the **Data Capture** button.
+3. If you see a "Data management service missing" banner, click
+   **Create data management service**, click **Save**, navigate back to
+   `test-sensor`, and click the **Data Capture** button again.
+4. Select the **Readings** method.
+5. Set the capture frequency to **0.2** (one reading every 5 seconds).
+6. Click **Save**.
+
+After saving, `viam-server` begins capturing immediately. You do not need to restart anything.
+
+## 3. Watch data sync to the cloud
+
+The data management service captures readings to local disk, then syncs them to Viam's cloud. By default, sync runs every 6 seconds.
+
+Wait about 30 seconds, then:
+
+1. Click the **DATA** tab in the top navigation of the Viam app. The tab opens on the **Images** view by default.
+2. Click the **Sensors** tab.
+3. You should see a machine card for your machine with `test-sensor` listed and its most recent reading displayed.
+
+The Sensors tab shows the latest reading per resource per machine, not a table of historical rows. You will query the historical rows from the query editor in the next step.
+
+If you don't see your machine or sensor yet, wait another 30 seconds. The first sync can take a moment as the service initializes.
+
+{{< alert title="What just happened?" color="info" >}}
+
+Behind the scenes:
+
+1. `viam-server` called `test-sensor.GetReadings()` every 5 seconds.
+2. Each reading was appended to a `.capture` file (length-delimited binary protobuf) in `$HOME/.viam/capture` on your machine. When `viam-server` runs as root through `viam-agent`, that path is `/root/.viam/capture`.
+3. The sync process uploaded those files to Viam's cloud storage.
+4. The local files were deleted after successful sync.
+
+Your data is now stored in MongoDB (tabular data) in the cloud, queryable and exportable.
+
+{{< /alert >}}
+
+## 4. Query your data in the app
+
+Now that data is in the cloud, you can query it.
+
+1. On the **Sensors** tab, find your `test-sensor` and click the small search icon next to it to jump to the query editor. (If you don't see the icon, it is in the same row as the sensor name. Its tooltip reads "Query historical data".) You can also click **Query** in the data tab navigation to open the editor manually.
+2. The query editor opens. Paste this SQL query:
+
+   ```sql
+   SELECT time_received, data
+   FROM readings
+   WHERE component_name = 'test-sensor'
+     AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)
+   ORDER BY time_received DESC
+   LIMIT 5
+   ```
+
+   {{< alert title="Known issue" color="caution" >}}
+   The `AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)` clause is a workaround for APP-10891: SQL queries against `readings` currently return no rows unless the `WHERE` clause includes an explicit lower bound on `time_received`. Include it on every SQL query on this page.
+   {{< /alert >}}
+
+3. Click **Run query**.
+
+The results appear as a list of JSON rows by default. Click the **table view** toggle (the small table icon in the results area) to see the rows as columns. You should see 5 rows with `time_received` values a few seconds apart and identical `data` values (`{"a": 1, "b": 2, "c": 3}`, because `sensor/fake` returns constant readings).
+
+To understand the structure, try this:
+
+```sql
+SELECT data FROM readings
+WHERE component_name = 'test-sensor'
+  AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)
+LIMIT 1
+```
+
+Switch to **table view** (the table icon in the results area). You'll see nested fields flattened into column headers like `data.readings.x`. These dot-notation paths are what you use to extract specific values in queries. For the full schema, see the [readings table schema](/data/schema/#column-reference).
+
+Try one more query:
+
+```sql
+SELECT COUNT(*) as total_readings
+FROM readings
+WHERE component_name = 'test-sensor'
+  AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)
+```
+
+This tells you how many readings have been captured so far.
+
+## 5. Query your data from code
+
+The same data is accessible from your own code through the Viam SDK.
+
+{{< readfile "/static/include/how-to/get-credentials.md" >}}
+
+Install the Viam Python SDK:
+
+```bash
+pip install viam-sdk
+```
+
+Save this as `query_data.py`:
+
+```python
+import asyncio
+from viam.rpc.dial import DialOptions
+from viam.app.viam_client import ViamClient
+
+
+async def main():
+    dial_options = DialOptions.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID",
+    )
+    client = await ViamClient.create_from_dial_options(dial_options)
+    data_client = client.data_client
+
+    # Query the 5 most recent readings from test-sensor
+    results = await data_client.tabular_data_by_sql(
+        organization_id="YOUR-ORGANIZATION-ID",
+        sql_query=(
+            "SELECT time_received, data "
+            "FROM readings "
+            "WHERE component_name = 'test-sensor' "
+            "  AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP) "
+            "ORDER BY time_received DESC "
+            "LIMIT 5"
+        ),
+    )
+
+    print(f"Got {len(results)} readings:\n")
+    for row in results:
+        print(row)
+
+    client.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```bash
+python query_data.py
+```
+
+You should see your 5 most recent sensor readings printed to the console. This is the same data you saw in the app's query editor, now accessible from your own code.
+
+## 6. Clean up
+
+To stop capturing data from the test sensor:
+
+1. Go back to the **CONFIGURE** tab.
+2. Find `test-sensor`.
+3. In the **Data capture** section, click the trash icon next to the **Readings** method to remove the capture configuration.
+4. Click **Save**.
+
+Capture stops immediately. Data already synced to the cloud remains available for querying.
+
+If you want to remove the test sensor entirely, click the trash icon on the component card and save.
+
+## What you learned
+
+You set up a complete data pipeline:
+
+- **Capture**: `viam-server` recorded sensor readings to local disk at a configured frequency.
+- **Sync**: the data management service uploaded captured data to Viam's cloud automatically.
+- **View**: the Data tab in the Viam app showed your synced data with filtering and browsing.
+- **Query**: you queried your data with SQL, both in the app and from your own Python code.
+
+## What's next
+
+Now that you understand the data pipeline, you can:
+
+- [Capture data from real hardware](/data/capture-sync/capture-and-sync-data/): configure capture on cameras, motors, or any component.
+- [Filter data at the edge](/data/filter-at-the-edge/): reduce data volume by capturing only what matters.
+- [Data pipelines](/data/pipelines/create-a-pipeline/): schedule transformations on your captured data.
+- [Visualize your data](/data/visualize-data/): build monitoring dashboards.
diff --git a/docs/data-ai/data/export.md b/docs/data/export-data.md
similarity index 74%
rename from docs/data-ai/data/export.md
rename to docs/data/export-data.md
index 2889f0b78a..fc4fdc4d8c 100644
--- a/docs/data-ai/data/export.md
+++ b/docs/data/export-data.md
@@ -2,25 +2,22 @@
 linkTitle: "Export data"
 title: "Export data"
 weight: 40
-description: "Download data from Viam using the data client API or the CLI."
+layout: "docs"
 type: "docs"
+description: "Download data from Viam using the data client API or the CLI."
 tags: ["data management", "cloud", "sync"]
-icon: true
-images: ["/services/icons/data-capture.svg"]
 aliases:
+  - /data/export/export-data/
+  - /data/export-data/
+  - /data-ai/data/export/
   - /manage/data/export/
-  - /data/export/
-  - /services/data/export/
-  - /how-tos/export-data/
-viamresources: ["sensor", "data_manager"]
-platformarea: ["data", "cli"]
 date: "2024-12-03"
 updated: "2025-09-12"
 ---
 
 You can download machine data to your computer with the Viam CLI.
 
-If you prefer to manage your data with code, see the [data client API documentation](/dev/reference/apis/data-client/).
+If you prefer to manage your data with code, see the [data client API documentation](/reference/apis/data-client/).
 
 ## Prerequisites
 
@@ -69,26 +66,27 @@ Run the copied command in a terminal:
 viam data export binary filter --org-ids=<org-id> --destination=.
 ```
 
+By default, the command creates two new directories named `data` and `metadata` in the destination directory.
+It downloads binary files into the `data` folder and metadata (bounding box information, labels) in JSON format into the `metadata` folder.
+
+Since data is downloaded in parallel, the order is not guaranteed to be chronological.
+Sort your files by filename to see them in chronological order.
+
 {{% /tab %}}
 {{% tab name="Tabular data" %}}
 
 ```sh {class="command-line" data-prompt="$"}
-viam data export tabular filter --org-ids=<org-id> --destination=.
+viam data export tabular --destination=. --part-id=<part-id> --resource-name=<resource-name> --resource-subtype=<resource-subtype> --method=<method>
 ```
 
+The tabular export command writes a single `data.ndjson` file in [NDJSON](https://github.com/ndjson/ndjson-spec) (newline-delimited JSON) format to the destination directory.
+
 {{% /tab %}}
 {{< /tabs >}}
 
-This command downloads the data onto your computer based on the search criteria you select in the web UI.
-
-By default, the command creates two new directories named `data` and `metadata` in the current directory.
-It downloads the specified data into the `data` folder and metadata, like bounding box information and labels, in JSON format into the `metadata` folder.
-If you want to store the data in a different location, change the destination folder with the [`--destination` flag](/dev/tools/cli/#named-arguments).
-
-Since data is downloaded in parallel, the order is not guaranteed to be chronological.
-Sort your files by filename to see them in chronological order.
+If you want to store the data in a different location, change the destination with the [`--destination` flag](/cli/).
 
 {{% /tablestep %}}
 {{< /table >}}
 
-You can see more information about exporting data in the [Viam CLI documentation](/dev/tools/cli/#data).
+You can see more information about exporting data in the [Viam CLI documentation](/cli/).
diff --git a/docs/data/filter-at-the-edge.md b/docs/data/filter-at-the-edge.md
new file mode 100644
index 0000000000..344c1a228f
--- /dev/null
+++ b/docs/data/filter-at-the-edge.md
@@ -0,0 +1,337 @@
+---
+linkTitle: "Filter at the edge"
+title: "Filter at the edge"
+weight: 31
+layout: "docs"
+type: "docs"
+description: "Reduce data volume, bandwidth, and storage costs by filtering data on the machine before syncing to the cloud."
+date: "2025-01-30"
+aliases:
+  - /build/data/filter-at-the-edge/
+  - /data-ai/capture-data/filter-before-sync/
+  - /how-tos/image-data/
+  - /tutorials/projects/filtered-camera/
+---
+
+Reduce the volume of data your robot captures and syncs. Robots can generate gigabytes per day from cameras and sensors, but most of that data is redundant. Edge filtering means the machine decides what is worth recording or syncing, so you save bandwidth, storage costs, and noise in your datasets.
+
+This is especially important for machines on cellular connections, metered networks, or with limited local storage.
+
+This page covers three approaches, from simplest to most powerful:
+
+1. **Reduce capture frequency** -- capture less often.
+2. **Use a filtered camera** -- use an ML model to decide frame-by-frame what to capture.
+3. **Conditional sync** -- capture locally but only sync when conditions are met.
+
+## Reduce capture frequency (time-based sampling)
+
+The simplest filter is capturing less often. If you configured your camera at
+1 Hz (one frame per second), consider whether you actually need that rate.
+
+1. In the [Viam app](https://app.viam.com), navigate to your machine's
+   **CONFIGURE** tab.
+2. Find the component you are capturing from (for example, `my-camera`).
+3. In the **Data capture** section, find the capture method you configured.
+4. Change the **frequency** to a lower value:
+   - `1` Hz = 1 capture per second = ~2.5&nbsp;GB/day for camera images
+   - `0.1` Hz = 1 capture every 10 seconds = ~250 MB/day
+   - `0.0167` Hz = 1 capture per minute = ~25 MB/day
+   - `0.00028` Hz = 1 capture per hour = ~0.4 MB/day
+5. Click **Save**.
+
+The change takes effect immediately. No restart required.
+
+{{< alert title="Tip" color="tip" >}}
+
+Start with the lowest frequency that meets your needs. You can always
+increase it later once you understand your data volume and bandwidth budget.
+
+{{< /alert >}}
+
+This approach works well when you need periodic snapshots but not continuous
+monitoring. It does not help when you need to capture specific events, like
+"only save images when there is a person in the frame". For event-based
+capture, skip ahead to [Use a filtered camera with ML](#use-a-filtered-camera-with-ml).
+
+## Configure conditional sync
+
+Conditional sync lets you capture data locally at full frequency but only upload
+it to the cloud when certain conditions are met. This is useful when you want
+a local buffer of recent data but only care about syncing data that meets
+specific criteria.
+
+You configure conditional sync through the data management service in your
+machine's configuration. The sync configuration supports conditions based on
+sensor readings, component states, or other data sources on your machine.
+
+1. In the Viam app, go to your machine's **CONFIGURE** tab.
+2. Find the **data management** service in your configuration. If you do not see
+   it, add it by clicking **+**, selecting **Service**, and choosing **data
+   management**.
+3. In the data management service configuration, set the **Sync interval** to
+   control how frequently synced data is uploaded. A longer interval means data
+   accumulates locally before being sent in batches.
+4. To add sync conditions, you can use the `selective_syncer_name` attribute to
+   specify a custom module that controls when sync occurs. This module
+   programmatically decides whether accumulated data should be synced based on
+   any logic you define -- sensor thresholds, time of day, connectivity status,
+   or external triggers.
+
+For example, you might write a selective sync module that checks a temperature
+sensor and only triggers sync when the reading exceeds a threshold. The data
+management service calls into your module to determine whether to proceed with
+each sync cycle.
+
+{{< alert title="Note" color="note" >}}
+
+Conditional sync still captures data locally at your configured
+frequency. It only controls when that data gets uploaded. Make sure your
+machine has enough local storage for the capture buffer (see
+[Manage local storage](#manage-local-storage) below).
+
+{{< /alert >}}
+
+## Use a filtered camera with ML
+
+The [`filtered-camera`](https://app.viam.com/module/viam/filtered-camera) registry module captures only the images you actually care about by running an ML vision model on each frame and gating capture on the result. It wraps an existing camera and a vision service so data capture sees a pre-filtered stream.
+
+### How it works
+
+The filtered camera sits between a raw camera and the data manager:
+
+1. A raw **camera** component (for example, a USB webcam) provides the image stream.
+2. A **vision service** runs an ML classifier or detector against each image and returns classifications or detections with confidence scores.
+3. A **`filtered-camera`** component wraps the camera and the vision service. It continuously pulls frames from the camera into an in-memory ring buffer, asks the vision service to score each frame, and marks a frame as "interesting" when a classification or detection passes a confidence threshold you configure.
+4. **Data capture** is configured on the `filtered-camera` component, not on the raw camera. Because the filtered camera is itself a camera component, the data manager captures from it the same way it would from any other camera. Only frames that passed the filter are ever written to disk.
+5. The normal sync pipeline uploads the captured files to the cloud.
+
+The raw camera's image stream is unchanged: the CONTROL tab, other services, and anything else on the machine still see every frame. Only the filtered camera, and therefore only data capture, sees the filtered subset.
+
+Optionally, you can configure a pre-trigger buffer with `window_seconds_before` and a post-trigger buffer with `window_seconds_after`. When a frame triggers the filter, the module includes the buffered frames from those windows alongside the trigger frame. Use this when you need context leading up to or after an event.
+
+### Prerequisites
+
+- A configured camera component on your machine. See [Configure a camera](/hardware/common-components/add-a-camera/) if you need to set one up.
+- The data management service configured. See [Start data capture](/data/capture-sync/capture-and-sync-data/) for instructions.
+
+### Instructions
+
+{{< table >}}
+{{% tablestep start=1 %}}
+**Add an ML model service to your machine**
+
+Add an ML model service on your machine that is compatible with the ML model you want to use, for example [TFLite CPU](https://github.com/viam-modules/mlmodel-tflite).
+
+{{% /tablestep %}}
+{{% tablestep %}}
+**Select a suitable ML model**
+
+Click **Select model** on the ML model service configuration panel, then select an [existing model](https://app.viam.com/registry?type=ML+Model) you want to use, or click **Upload a new model** to upload your own.
+If you're not sure which model to use, you can use [`EfficientDet-COCO`](https://app.viam.com/ml-model/viam-labs/EfficientDet-COCO) from the **Registry**, which can detect people and animals, among other things.
+
+{{% /tablestep %}}
+{{% tablestep %}}
+**Add a vision service to use with the ML model**
+
+The vision service is the bridge between the ML model service and the camera images. It loads the ML model and exposes classifier or detector methods that the filtered camera calls on each frame.
+
+Add and configure the `vision / ML model` service on your machine.
+From the **Select model** dropdown, select the name of your ML model service (for example, `mlmodel-1`).
+
+{{% /tablestep %}}
+{{% tablestep %}}
+**Configure the filtered camera**
+
+Add a `camera / filtered-camera` component on your machine. Set `camera` to the name of the raw camera you want to filter, and add a `vision_services` entry that references the vision service you just configured, along with the classification labels or detection classes you want to capture.
+
+For example, to capture images only when a person is detected with at least 80% confidence:
+
+```json {class="line-numbers linkable-line-numbers"}
+{
+  "camera": "camera-1",
+  "vision_services": [
+    {
+      "vision": "vision-1",
+      "objects": {
+        "Person": 0.8
+      }
+    }
+  ],
+  "window_seconds_before": 0,
+  "window_seconds_after": 0
+}
+```
+
+Key attributes:
+
+| Attribute               | Required | Description                                                                                                                                                                             |
+| ----------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `camera`                | Yes      | Name of the camera to filter.                                                                                                                                                           |
+| `vision_services`       | Yes      | List of vision services with their trigger criteria. Each entry needs a `vision` (the service name) and one of `classifications` or `objects` (a map of label to confidence threshold). |
+| `window_seconds_before` | Yes      | Seconds of buffered frames to include before a trigger. Set to `0` for no pre-buffer.                                                                                                   |
+| `window_seconds_after`  | Yes      | Seconds of buffered frames to include after a trigger. Set to `0` for no post-buffer.                                                                                                   |
+| `image_frequency`       | No       | Rate in Hz at which the filtered camera pulls frames from the raw camera into its buffer. Default: `1.0`.                                                                               |
+| `cooldown_s`            | No       | Seconds to suppress new triggers after a capture window ends. Useful when events happen in bursts. Default: `0`.                                                                        |
+
+You can configure more than one `vision_services` entry to trigger on multiple conditions. Use `"*"` as a label to match any classification or detection above the confidence threshold. For the full attribute reference, see the [module README on GitHub](https://github.com/viam-modules/filtered_camera#attributes).
+
+{{% /tablestep %}}
+{{% tablestep %}}
+**Configure data capture on the filtered camera**
+
+Configure data capture on the **filtered camera**, not on the raw camera, following the same process as [Start data capture](/data/capture-sync/capture-and-sync-data/). Use the `GetImages` capture method and choose a capture frequency.
+
+If the raw camera already has data capture configured, remove it. Otherwise you will capture both the unfiltered stream and the filtered stream.
+
+{{% /tablestep %}}
+{{% tablestep %}}
+**Save and verify**
+
+Save the config. Place an object your ML model can detect in front of the camera and wait for the next sync interval.
+
+On the **DATA** tab in the Viam app, click **Images** (the default view). You should see frames appear only when the trigger condition was met. If no frames appear:
+
+- **Test the vision service directly.** On the machine's **CONTROL** tab, open the vision service panel and point the camera at a known object. The panel shows live classifications and detections with their confidence scores. If no classifications or detections reach your threshold, the filtered camera has nothing to capture.
+- **Check the logs.** The machine's **LOGS** tab shows the filtered camera's filtering decisions if you set `"debug": true` in its config.
+- **Confirm capture is on the filtered camera.** Data capture must be on the `filtered-camera` component, not the underlying camera.
+
+{{% /tablestep %}}
+{{% tablestep %}}
+**(Optional) Trigger sync with custom logic**
+
+By default, captured data syncs at the interval you set on the data management service. If you need to sync only at certain times or when other conditions are met, see [Conditional sync](/data/capture-sync/conditional-sync/).
+
+{{% /tablestep %}}
+{{< /table >}}
+
+{{< alert title="Build your own filtering module" color="tip" >}}
+
+If the `filtered-camera` module does not meet your needs, you can build a custom filtering module. See [Write a module](/build-modules/write-a-driver-module/) for the general module development guide. The next section covers the pattern.
+
+{{< /alert >}}
+
+## Build a custom filter module
+
+For filtering needs that go beyond what the `filtered-camera` module provides, you can write your own module. Common examples:
+
+- A sensor wrapper that only reports readings above a threshold (for example, temperature above 50 degrees C)
+- A camera filter with custom logic specific to your application
+- A filter that combines data from multiple sensors before deciding what to capture
+
+The pattern is: write a module that wraps an existing component, evaluates its data against your criteria, and only returns data worth capturing. Configure data capture on the wrapper component instead of the raw component.
+
+See [Write a module](/build-modules/write-a-driver-module/) for the general module development guide. The key technique is accessing the source component through the `dependencies` parameter in your module's `reconfigure` method.
+
+## Manage local storage
+
+On constrained machines (Raspberry Pi, Jetson Nano, single-board computers),
+local storage is limited. Understanding how Viam manages the capture directory
+helps you avoid filling the disk.
+
+### How local storage works
+
+- Captured data is written to the capture directory (default: `$HOME/.viam/capture`). When `viam-server` is installed through `viam-agent` it runs as root, so the path is `/root/.viam/capture`. See [Capture directories](/data/reference/#capture-directories) for the full per-platform breakdown.
+- Each capture is written as a `.capture` file: length-delimited binary protobuf. The first message is metadata describing the capture; the remaining messages hold the captured data. Images and tabular readings use the same container format.
+- The sync process uploads `.capture` files and deletes them after successful upload.
+- If sync is disabled or the network is down, files accumulate locally.
+
+### Configure storage limits
+
+You can configure the maximum storage that data capture will use on disk. In
+your data management service configuration, set the `maximum_capture_file_size_bytes`
+attribute to limit the size of individual capture files, and monitor the overall
+capture directory size.
+
+To check current disk usage of the capture directory (substitute `/root/.viam/capture` if `viam-server` runs as root through `viam-agent`):
+
+```bash
+du -sh "$HOME/.viam/capture"
+```
+
+To monitor it over time:
+
+```bash
+watch -n 60 du -sh "$HOME/.viam/capture"
+```
+
+### Best practices for constrained machines
+
+- **Use the lowest capture frequency that meets your needs.** Every reduction in
+  frequency directly reduces storage pressure.
+- **Enable sync.** Without sync, local storage fills indefinitely.
+- **Use filtered capture.** The filtered camera and threshold sensor modules
+  above reduce what gets written to disk, not just what gets synced.
+- **Monitor disk space.** Set up a simple cron job or health check that alerts
+  you when the capture directory exceeds a size threshold.
+- **Adjust sync interval.** A shorter sync interval (for example, every 30 seconds)
+  keeps the local buffer small. A longer interval (for example, every 5 minutes)
+  reduces network requests but requires more local storage.
+
+## Try it
+
+### Verify your filtering is working
+
+1. Configure one of the filtering techniques above on your machine.
+2. Open the **DATA** tab in the Viam app.
+3. Compare data volume before and after filtering:
+   - Check how many new entries appear per minute with your filter active.
+   - Compare to the rate you saw in
+     [Capture and sync data](/data/capture-sync/capture-and-sync-data/) before
+     filtering.
+4. For the filtered camera, verify that captured images show meaningful
+   variation between consecutive frames.
+
+## Troubleshooting
+
+{{< expand "Filtered camera module not loading" >}}
+
+- Check the module logs in the Viam app (**LOGS** tab) for import errors or
+  configuration issues.
+- Verify that the camera name in the filtered camera attributes matches
+  the name of your actual camera component exactly. Names are case-sensitive.
+- Ensure the `filtered_camera` module is added to your machine and that
+  the vision service and ML model service are both configured.
+
+{{< /expand >}}
+
+{{< expand "No data captured after enabling filter" >}}
+
+- Verify that your ML model can detect the objects you expect. Test the vision
+  service from the **CONTROL** tab to see its classifications and detections live.
+- Confirm the source camera is still working. Check the raw camera's test panel
+  in the Viam app.
+- Verify that data capture is configured on the filtered camera component, not
+  only on the raw camera.
+
+{{< /expand >}}
+
+{{< expand "Too much data still being captured" >}}
+
+- Increase the confidence threshold in your filtered camera configuration to
+  require higher confidence before capturing.
+- Reduce the capture frequency on the filtered camera. Even with filtering, a
+  high capture frequency means more comparisons and more opportunities for a
+  frame to be flagged as changed.
+
+{{< /expand >}}
+
+{{< expand "Local disk filling up despite sync being enabled" >}}
+
+- Check your network connection. If the machine cannot reach Viam's cloud, data
+  accumulates locally.
+- Verify that both **Capturing** and **Syncing** are enabled in the data
+  management service configuration.
+- Check the sync interval. A very long sync interval combined with high capture
+  frequency can cause the local buffer to grow between sync cycles.
+- Run `du -sh "$HOME/.viam/capture"` to check current usage (or `/root/.viam/capture` when `viam-server` runs as root).
+
+{{< /expand >}}
+
+## What's next
+
+- [Query data](/data/query-data/) -- write SQL and MQL queries against your
+  filtered, high-signal dataset.
+- [Create a dataset](/train/create-a-dataset/) -- use filtered captures to
+  build cleaner training datasets for ML models.
+- [Write a module](/build-modules/write-a-driver-module/) -- learn more about
+  building and deploying custom modules on Viam.
diff --git a/docs/data/hot-data-store.md b/docs/data/hot-data-store.md
new file mode 100644
index 0000000000..e1a6465103
--- /dev/null
+++ b/docs/data/hot-data-store.md
@@ -0,0 +1,162 @@
+---
+linkTitle: "Hot data store"
+title: "Hot data store"
+weight: 32
+layout: "docs"
+type: "docs"
+description: "Store a rolling window of recent data for fast queries while continuing to write all data to blob storage."
+date: "2025-01-30"
+aliases:
+  - /data/query/hot-data-store/
+  - /data/hot-data-store/
+  - /build/data/hot-data-store/
+  - /data-ai/data/hot-data-store/
+---
+
+Keep a rolling window of recent data in a fast-query database for significantly faster queries on the last few hours or days of captured data. All data continues to be written to blob storage regardless of hot data store settings. The hot data store is an additional copy, not a replacement.
+
+## Configure
+
+The hot data store is configured per capture method on each component. You
+choose which components send data to it and how many hours of data to retain.
+
+{{< tabs >}}
+{{% tab name="Web UI" %}}
+
+1. Go to [app.viam.com](https://app.viam.com) and navigate to your machine's
+   **CONFIGURE** tab.
+2. Find the component you want to enable hot storage for (for example, your sensor).
+3. Click the **Data Capture** button on the component.
+4. If you see a "Data management service missing" banner, click
+   **Create data management service**, then click **Save**. Navigate back
+   to your component and click the **Data Capture** button again.
+5. Select a **Method**, set the **Frequency**, and toggle it **On**.
+   Click **Save**.
+6. On the capture method, click the chevron to expand **Advanced** options.
+7. Enable **Sync to Hot Data Store**.
+8. Set the **Time frame** to the number of hours of data to retain (for example, 24
+   for the last 24 hours).
+9. Click **Save**.
+
+{{% /tab %}}
+{{% tab name="JSON" %}}
+
+Add the `recent_data_store` configuration to your component's data capture
+settings. Set `stored_hours` to the number of hours of recent data to store.
+
+```json {class="line-numbers linkable-line-numbers" data-line="17-19"}
+{
+  "components": [
+    {
+      "name": "sensor-1",
+      "api": "rdk:component:sensor",
+      "model": "rdk:builtin:fake",
+      "attributes": {},
+      "service_configs": [
+        {
+          "type": "data_manager",
+          "attributes": {
+            "capture_methods": [
+              {
+                "method": "Readings",
+                "capture_frequency_hz": 0.5,
+                "additional_params": {},
+                "recent_data_store": {
+                  "stored_hours": 24
+                }
+              }
+            ]
+          }
+        }
+      ]
+    }
+  ]
+}
+```
+
+The `stored_hours` field controls how many hours of data the hot data store
+retains. A scheduled cleanup job runs hourly and removes documents with a
+`time_received` timestamp older than the configured window.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Query
+
+Queries execute against blob storage by default. To query the hot data store,
+specify it as the data source in your query.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+Use [`DataClient.TabularDataByMQL`](/reference/apis/data-client/#tabulardatabymql) with `data_source` set to `TabularDataSourceType.TABULAR_DATA_SOURCE_TYPE_HOT_STORAGE`:
+
+```python
+from viam.gen.app.data.v1.data_pb2 import TabularDataSourceType
+
+results = await data_client.tabular_data_by_mql(
+    organization_id=ORG_ID,
+    query=[
+        {"$match": {"component_name": "temperature-sensor"}},
+        {"$sort": {"time_received": -1}},
+        {"$limit": 10},
+    ],
+    tabular_data_source_type=TabularDataSourceType.TABULAR_DATA_SOURCE_TYPE_HOT_STORAGE,
+)
+
+for entry in results:
+    print(entry)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+Use [`DataClient.TabularDataByMQL`](https://pkg.go.dev/go.viam.com/rdk/app#DataClient.TabularDataByMQL) with `TabularDataSourceType` set to hot storage:
+
+```go
+hotQueryStages := []map[string]interface{}{
+    {"$match": map[string]interface{}{
+        "component_name": "temperature-sensor",
+    }},
+    {"$sort": map[string]interface{}{"time_received": -1}},
+    {"$limit": 10},
+}
+
+hotData, err := dataClient.TabularDataByMQL(ctx, orgID, hotQueryStages,
+    &app.TabularDataByMQLOptions{
+        TabularDataSourceType: app.TabularDataSourceTypeHotStorage,
+    },
+)
+if err != nil {
+    logger.Fatal(err)
+}
+
+for _, entry := range hotData {
+    fmt.Printf("%v\n", entry)
+}
+```
+
+{{% /tab %}}
+{{% tab name="TypeScript" %}}
+
+Use [`dataClient.TabularDataByMQL`](/reference/apis/data-client/#tabulardatabymql) with `dataSourceType` set to `TabularDataSourceType.TABULAR_DATA_SOURCE_TYPE_HOT_STORAGE`:
+
+{{< read-code-snippet file="/static/include/examples-generated/query.snippet.pipeline-query.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="" >}}
+
+{{% /tab %}}
+{{< /tabs >}}
+
+The hot data store returns the same document schema as the standard data store.
+The only difference is the data is limited to the configured time window and
+queries execute faster because the dataset is smaller.
+
+{{< alert title="Caution" color="caution" >}}
+
+Queries to the hot data store _only_ return data within the configured time
+window. For example, if your hot data store retains 24 hours of data and you
+query for temperature readings above 25°C, but no readings above 25°C were
+recorded in the last 24 hours, the query returns zero results, even if older
+data in blob storage contains matching readings. To query your full data
+history, use the default blob storage data source.
+
+{{< /alert >}}
diff --git a/docs/data/overview.md b/docs/data/overview.md
new file mode 100644
index 0000000000..ec48bd5acc
--- /dev/null
+++ b/docs/data/overview.md
@@ -0,0 +1,181 @@
+---
+linkTitle: "Overview"
+title: "Manage data"
+weight: 1
+layout: "docs"
+type: "docs"
+description: "Record sensor data on your robot, sync it to the cloud, and query, export, or use it for ML training."
+---
+
+Your robot's sensors, cameras, and other components produce data you need to record, analyze, and act on. Viam's data management service lets you configure which components to capture from, sync captured data to the cloud, and query, export, or use it for ML training without building a custom data pipeline.
+
+## How data flows
+
+Data moves through four stages, from your robot to actionable insights:
+
+<img src="/data/data-flow-overview.svg" alt="Data flow: capture on the machine writes .capture files to local disk, sync uploads to cloud, cloud stores tabular data in MongoDB and binary data in blob storage, and from there you can query, export, train ML models, build dashboards, and trigger alerts." style="width:100%;max-width:720px;height:auto;display:block" >
+
+1. **Capture on the machine.** You configure which components to record from and at what frequency. Captured data is written to local disk. Nothing is captured until you configure it.
+2. **Sync to the cloud.** A separate process uploads captured data to Viam's cloud at a configurable interval, then deletes local files. If the machine goes offline, data buffers locally and syncs when connectivity returns.
+3. **Store.** In the cloud, tabular data (sensor readings, motor positions, encoder ticks) is stored in MongoDB. Binary data (images, point clouds, audio) is stored in blob storage. Both are indexed and queryable.
+4. **Use.** From the cloud, you can query data with SQL or MQL, export it to your own database, build datasets for ML training, create monitoring dashboards, or trigger alerts when data meets a condition.
+
+Capture and sync run independently: you can capture without syncing, or sync files from other sources without using Viam's capture.
+
+To get started recording data, see [Capture and sync data](/data/capture-sync/capture-and-sync-data/).
+
+## Query and explore
+
+All captured tabular data is queryable through SQL and MQL, either in the Viam app's query editor or programmatically through the SDK. You can run ad-hoc queries for data exploration, create custom indexes to speed up frequent queries, and save queries for reuse. An AI-assisted query builder helps you write MQL aggregation pipelines.
+
+Binary data (images, point clouds) is browsable and filterable in the Viam app's Data tab, with viewers for images, video, and 3D point clouds.
+
+See [Query data](/data/query-data/) and [Query reference](/data/reference/).
+
+## Transform and pipeline
+
+Data pipelines run scheduled MQL aggregations on your captured data. Use them to compute hourly averages, detect trends, or reshape data for downstream tools. Pipelines run on a cron schedule with optional backfill for historical data.
+
+A hot data store keeps a rolling window of recent data in a fast-query database, so you can build real-time dashboards without scanning the full archive.
+
+See [Create a data pipeline](/data/pipelines/create-a-pipeline/) and [Hot data store](/data/hot-data-store/).
+
+## Export and integrate
+
+Viam is not a data silo. You can export data to your own tools and databases:
+
+- **CLI export**: download binary or tabular data in bulk.
+- **SDK access**: query and download data programmatically from Python or Go.
+- **Direct MongoDB connection**: connect Grafana, Tableau, or custom scripts directly to your data through a MongoDB connection URI.
+
+See [Export data](/data/export-data/) and [Sync to your database](/data/sync-data-to-your-database/).
+
+## Delete data
+
+You can delete captured data through the Viam app, the CLI, or the SDK. The SQL and MQL query editor is read-only: you cannot run `DELETE`, `DROP TABLE`, or any write operation through it.
+
+**In the Viam app:**
+
+- **Images and binary data**: on the **DATA** tab, select one or more items and click **Delete selected**, or use **Delete all** with the current filters applied. Point clouds, video, and file uploads can also be deleted this way.
+- **Tabular data (sensor readings)**: the Sensors tab does not have a delete button. Use the CLI or SDK instead.
+
+**From the CLI:**
+
+Delete tabular data older than a number of days:
+
+```bash
+viam data delete tabular --org-id=<org-id> --delete-older-than-days=30
+```
+
+If the organization has a [hot data store](/data/hot-data-store/), matching data is deleted from that store as well.
+
+{{< alert title="Caution" color="caution" >}}
+`--delete-older-than-days=0` deletes **all** tabular data in the organization. The CLI tabular delete has no component or location filter: it applies to the entire org.
+{{< /alert >}}
+
+Delete binary data within a time range:
+
+```bash
+viam data delete binary \
+  --org-ids=<org-id> \
+  --start=2026-01-01T00:00:00Z \
+  --end=2026-02-01T00:00:00Z
+```
+
+The binary delete command requires `--org-ids`, `--start`, and `--end`. You can narrow deletion with optional filters for location, component, MIME type, and more. For the full, up-to-date list of filters, see the [`viam data delete binary` CLI reference](/cli/manage-data/#delete-data).
+
+**From the SDK:**
+
+The [data client API](/reference/apis/data-client/) supports these delete operations; see the API reference for your SDK's method names and signatures:
+
+- Delete tabular data older than a specified number of days. Also deletes matching data from the [hot data store](/data/hot-data-store/) when one is configured.
+- Delete binary data matching a filter, such as organization, location, or time range.
+- Delete specific binary items by ID.
+
+**Retention policies** can also auto-delete data in the cloud after a configured number of days. See [Platform-managed capture settings](/data/reference/#platform-managed-capture-settings) for the `retention_policy` field.
+
+## Annotate and train
+
+Captured images can be tagged, annotated with bounding boxes, and organized into datasets for ML training. Viam provides a complete path from captured data to a deployed model:
+
+1. Capture images from your robot's cameras.
+2. Label them with tags and bounding boxes in the Viam app.
+3. Organize labeled images into a dataset.
+4. Submit a training job (Vertex AI AutoML or your own training container).
+5. Deploy the trained model back to your robot.
+
+See [Create a dataset](/train/create-a-dataset/) and the training section for details.
+
+## Monitor and debug
+
+Triggers send webhooks or email alerts when synced data meets a condition, so you can respond to events like temperature spikes or detection results without polling.
+
+Monitoring dashboards can be built with Viam's Teleop workspace or with Grafana connected to your data through MongoDB.
+
+### OpenTelemetry distributed tracing
+
+Viam includes OpenTelemetry (OTel) tracing that propagates trace context across your SDK code, `viam-server`, and modules. Traces cover gRPC request lifecycle, data capture operations, and module calls. When tracing is enabled on `viam-server`, module tracing is activated automatically.
+
+To enable tracing, add a `tracing` block at the top level of your machine's JSON config (alongside `"components"` and `"services"`). You must set `enabled` to `true` **and** enable at least one export destination (`disk`, `console`, or `otlpendpoint`). Setting only `"enabled": true` without an export destination has no effect.
+
+**Save traces to disk** for later retrieval with the CLI:
+
+```json
+{
+  "tracing": {
+    "enabled": true,
+    "disk": true
+  }
+}
+```
+
+This writes traces to `$HOME/.viam/trace/<part-id>/traces/` as compressed OTLP protobuf files. Download and import saved traces with the CLI. See [Traces](/monitor/troubleshoot/#traces) for instructions and troubleshooting tips.
+
+**Export directly to an OTLP-compatible backend** (Jaeger, Grafana Tempo, Datadog, or any OTLP collector):
+
+```json
+{
+  "tracing": {
+    "enabled": true,
+    "otlpendpoint": "<collector-host>:4317"
+  }
+}
+```
+
+For local development, see the [Jaeger getting started guide](https://www.jaegertracing.io/docs/latest/getting-started/) to set up a local instance that accepts OTLP traces.
+
+**Print traces to the console** for quick debugging without any external tools:
+
+```json
+{
+  "tracing": {
+    "enabled": true,
+    "console": true
+  }
+}
+```
+
+You can combine multiple destinations (for example, `"disk": true` and `"otlpendpoint": "<collector-host>:4317"` together).
+
+See [Trigger on data events](/data/trigger-on-data/) and [Visualize data](/data/visualize-data/).
+
+## Manage data volume
+
+Robots can generate more data than your network can transfer or your budget can store. Viam provides several tools to control data volume:
+
+- **Capture frequency**: set per-component, from sub-second to infrequent intervals.
+- **Conditional sync**: a sensor on the machine decides whether to sync or hold data.
+- **Edge filtering**: write a custom sensor module that evaluates data before capture and only records what matters.
+- **Retention policies**: configure how long data is retained in the cloud.
+
+See [Filter at the edge](/data/filter-at-the-edge/) and [Conditional sync](/data/capture-sync/conditional-sync/).
+
+## Security and data integrity
+
+Data is encrypted in transit using {{< glossary_tooltip term_id="grpc" text="gRPC" >}} and encrypted at rest by the cloud storage provider.
+
+The sync process is designed to prevent data loss and duplication:
+
+- If the connection drops, the service retries at exponentially increasing intervals until restored.
+- Sync resumes where it left off without duplicating data.
+- Files still being written are not synced until they stabilize (configurable, default 10 seconds).
diff --git a/docs/data/pipelines/_index.md b/docs/data/pipelines/_index.md
new file mode 100644
index 0000000000..879c1f170b
--- /dev/null
+++ b/docs/data/pipelines/_index.md
@@ -0,0 +1,10 @@
+---
+linkTitle: "Data pipelines"
+title: "Data pipelines"
+weight: 30
+layout: "docs"
+type: "docs"
+no_list: true
+description: "Scheduled data transformations that automatically aggregate and summarize captured data."
+manualLink: "/data/pipelines/overview/"
+---
diff --git a/docs/data/pipelines/create-a-pipeline.md b/docs/data/pipelines/create-a-pipeline.md
new file mode 100644
index 0000000000..b1b7b3872b
--- /dev/null
+++ b/docs/data/pipelines/create-a-pipeline.md
@@ -0,0 +1,233 @@
+---
+linkTitle: "Create a pipeline"
+title: "Create a data pipeline"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Create a scheduled MQL pipeline that automatically aggregates captured data."
+date: "2026-03-27"
+aliases:
+  - /data/configure-data-pipelines/
+  - /build/data/configure-data-pipelines/
+  - /data-ai/data/data-pipelines/
+  - /data/query/configure-data-pipelines/
+---
+
+Create a pipeline that runs a scheduled MQL aggregation against your captured data and stores the results as precomputed summaries. For an overview of how pipelines work, see [Data pipelines overview](/data/pipelines/overview/).
+
+## Prerequisites
+
+- Captured tabular data in the cloud (see [Start data capture](/data/capture-sync/capture-and-sync-data/))
+- Your organization ID (find it in the Viam app under **Settings**)
+- Viam CLI installed, or the Python/Go SDK
+
+## Create with the CLI
+
+This example creates a pipeline that computes hourly temperature averages grouped by location:
+
+```bash
+viam datapipelines create \
+  --org-id=<org-id> \
+  --name=hourly-temp-avg \
+  --schedule="0 * * * *" \
+  --data-source-type=standard \
+  --mql='[{"$match": {"component_name": "temperature-sensor"}}, {"$group": {"_id": "$location_id", "avg_temp": {"$avg": "$data.readings.temperature"}, "count": {"$sum": 1}}}, {"$project": {"location": "$_id", "avg_temp": 1, "count": 1, "_id": 0}}]' \
+  --enable-backfill=true
+```
+
+The CLI prints the pipeline ID on success. Save this ID to query results and manage the pipeline.
+
+### CLI flags
+
+| Flag                 | Required                       | Description                                                                                                                     |
+| -------------------- | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------- |
+| `--org-id`           | Yes                            | Your organization ID.                                                                                                           |
+| `--name`             | Yes                            | A descriptive name. Must be unique within the organization.                                                                     |
+| `--schedule`         | Yes                            | A cron expression in UTC. Also determines the query time window. See [Cron schedule](/data/pipelines/reference/#cron-schedule). |
+| `--mql`              | One of `--mql` or `--mql-path` | The MQL aggregation pipeline as a JSON string.                                                                                  |
+| `--mql-path`         | One of `--mql` or `--mql-path` | Path to a file containing the MQL aggregation pipeline as JSON.                                                                 |
+| `--enable-backfill`  | Yes                            | Whether to process historical time windows. `true` or `false`.                                                                  |
+| `--data-source-type` | Yes                            | `standard` or `hotstorage`.                                                                                                     |
+
+For complex queries, use `--mql-path` to read from a file:
+
+```bash
+viam datapipelines create \
+  --org-id=<org-id> \
+  --name=hourly-temp-avg \
+  --schedule="0 * * * *" \
+  --data-source-type=standard \
+  --mql-path=./my-pipeline.json \
+  --enable-backfill=true
+```
+
+Where `my-pipeline.json` contains:
+
+```json
+[
+  { "$match": { "component_name": "temperature-sensor" } },
+  {
+    "$group": {
+      "_id": "$location_id",
+      "avg_temp": { "$avg": "$data.readings.temperature" },
+      "count": { "$sum": 1 }
+    }
+  },
+  {
+    "$project": {
+      "location": "$_id",
+      "avg_temp": 1,
+      "count": 1,
+      "_id": 0
+    }
+  }
+]
+```
+
+## Create with the SDK
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+import asyncio
+from viam.rpc.dial import DialOptions
+from viam.app.viam_client import ViamClient
+from viam.gen.app.data.v1.data_pb2 import TabularDataSourceType
+
+API_KEY = "YOUR-API-KEY"
+API_KEY_ID = "YOUR-API-KEY-ID"
+ORG_ID = "YOUR-ORGANIZATION-ID"
+
+
+async def main():
+    dial_options = DialOptions.with_api_key(
+        api_key=API_KEY,
+        api_key_id=API_KEY_ID,
+    )
+    client = await ViamClient.create_from_dial_options(dial_options)
+    data_client = client.data_client
+
+    # Returns the pipeline ID
+    pipeline_id = await data_client.create_data_pipeline(
+        organization_id=ORG_ID,
+        name="hourly-temp-avg",
+        mql_binary=[
+            {"$match": {"component_name": "temperature-sensor"}},
+            {"$group": {
+                "_id": "$location_id",
+                "avg_temp": {"$avg": "$data.readings.temperature"},
+                "count": {"$sum": 1},
+            }},
+            {"$project": {
+                "location": "$_id",
+                "avg_temp": 1,
+                "count": 1,
+                "_id": 0,
+            }},
+        ],
+        schedule="0 * * * *",
+        data_source_type=TabularDataSourceType.TABULAR_DATA_SOURCE_TYPE_STANDARD,
+        enable_backfill=False,
+    )
+
+    print(f"Created pipeline: {pipeline_id}")
+    client.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/app"
+    "go.viam.com/rdk/logging"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewDebugLogger("pipeline")
+
+    viamClient, err := app.CreateViamClientWithAPIKey(
+        ctx, app.Options{}, "YOUR-API-KEY", "YOUR-API-KEY-ID", logger)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer viamClient.Close()
+
+    dataClient := viamClient.DataClient()
+
+    mqlStages := []map[string]interface{}{
+        {"$match": map[string]interface{}{
+            "component_name": "temperature-sensor",
+        }},
+        {"$group": map[string]interface{}{
+            "_id":      "$location_id",
+            "avg_temp": map[string]interface{}{"$avg": "$data.readings.temperature"},
+            "count":    map[string]interface{}{"$sum": 1},
+        }},
+        {"$project": map[string]interface{}{
+            "location": "$_id",
+            "avg_temp": 1,
+            "count":    1,
+            "_id":      0,
+        }},
+    }
+
+    pipelineID, err := dataClient.CreateDataPipeline(
+        ctx, "YOUR-ORGANIZATION-ID", "hourly-temp-avg",
+        mqlStages, "0 * * * *", false,
+        &app.CreateDataPipelineOptions{
+            TabularDataSourceType: app.TabularDataSourceTypeStandard,
+        },
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    fmt.Printf("Created pipeline: %s\n", pipelineID)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+{{< readfile "/static/include/how-to/get-credentials.md" >}}
+
+After creating a pipeline, see [Query pipeline results](/data/pipelines/query-results/) to access the output, and [Examples and tips](/data/pipelines/examples/) for MQL patterns for common robotics use cases.
+
+## Troubleshooting
+
+{{< expand "Pipeline creation fails with permission error" >}}
+
+Only organization owners can create data pipelines. Verify your API key has owner-level permissions. In the Viam app, go to **Settings** and check the role associated with your key.
+
+{{< /expand >}}
+
+{{< expand "Pipeline runs but produces no results" >}}
+
+- **Check the `$match` stage.** Field names and values must match your actual data. Run the same MQL query in the query editor to verify it returns results.
+- **Check the time window.** If no data was captured during the pipeline's time window, the run produces no output.
+- **Check the data source type.** If you set `hotstorage` but the hot data store is not configured for your components, the pipeline has no data to query.
+
+{{< /expand >}}
+
+{{< expand "Duplicate key error in pipeline results" >}}
+
+Follow `$group` with `$project` to rename `_id` to a descriptive field name and set `_id` to 0. See [MQL tips](/data/pipelines/examples/#always-rename-_id-in-project).
+
+{{< /expand >}}
+
+{{< expand "Pipeline results are stale or delayed" >}}
+
+Pipelines run on a cron schedule with a 2-minute execution delay. Results for the 02:00-03:00 PM window are not available until shortly after 03:00 PM. For faster updates, use a more frequent schedule (for example, `*/15 * * * *`).
+
+{{< /expand >}}
diff --git a/docs/data/pipelines/examples.md b/docs/data/pipelines/examples.md
new file mode 100644
index 0000000000..e383df5a50
--- /dev/null
+++ b/docs/data/pipelines/examples.md
@@ -0,0 +1,171 @@
+---
+linkTitle: "Examples and tips"
+title: "Pipeline examples and MQL tips"
+weight: 25
+layout: "docs"
+type: "docs"
+description: "MQL patterns for common robotics use cases and tips for writing effective pipeline queries."
+date: "2026-03-27"
+---
+
+MQL patterns for common robotics data pipeline use cases. Each example can be passed to `--mql` or `--mql-path` when [creating a pipeline](/data/pipelines/create-a-pipeline/).
+
+## MQL tips
+
+### Always rename `_id` in `$project`
+
+The `$group` stage produces documents with an `_id` field. If your pipeline runs multiple times and produces documents with the same `_id`, you get a duplicate key error. Always follow `$group` with `$project` to rename `_id` and set it to 0:
+
+```json
+{ "$project": { "location": "$_id", "avg_temp": 1, "count": 1, "_id": 0 } }
+```
+
+### Test your query first
+
+Before creating a pipeline, run the MQL query manually in the [query editor](/data/query-data/) using MQL mode. This lets you verify the query returns the results you expect. The pipeline runs the same query with an automatic time constraint prepended.
+
+### Use `$match` early
+
+Place `$match` stages at the beginning of your pipeline to reduce the amount of data processed by later stages. Filter by `component_name`, `component_type`, or other indexed fields for best performance. See [indexed fields](/data/reference/#indexed-fields-and-query-optimization).
+
+## Downsample high-frequency sensor data
+
+A sensor capturing at 10 Hz produces 36,000 readings per hour. This pipeline computes 1-minute averages, reducing the data to 60 summary documents per hour:
+
+```json
+[
+  { "$match": { "component_name": "accel-sensor" } },
+  {
+    "$group": {
+      "_id": {
+        "$dateTrunc": {
+          "date": "$time_received",
+          "unit": "minute"
+        }
+      },
+      "avg_x": { "$avg": "$data.readings.x" },
+      "avg_y": { "$avg": "$data.readings.y" },
+      "avg_z": { "$avg": "$data.readings.z" },
+      "sample_count": { "$sum": 1 }
+    }
+  },
+  {
+    "$project": {
+      "minute": "$_id",
+      "avg_x": 1,
+      "avg_y": 1,
+      "avg_z": 1,
+      "sample_count": 1,
+      "_id": 0
+    }
+  },
+  { "$sort": { "minute": 1 } }
+]
+```
+
+## Count detection events per hour per machine
+
+A vision service captures detection results. This pipeline counts how many detections of each class occurred per machine per hour:
+
+```json
+[
+  { "$match": { "component_type": "rdk:service:vision" } },
+  { "$unwind": "$data.detections" },
+  {
+    "$group": {
+      "_id": {
+        "machine": "$robot_id",
+        "hour": {
+          "$dateTrunc": {
+            "date": "$time_received",
+            "unit": "hour"
+          }
+        },
+        "class": "$data.detections.class_name"
+      },
+      "count": { "$sum": 1 },
+      "avg_confidence": { "$avg": "$data.detections.confidence" }
+    }
+  },
+  {
+    "$project": {
+      "machine": "$_id.machine",
+      "hour": "$_id.hour",
+      "class": "$_id.class",
+      "count": 1,
+      "avg_confidence": { "$round": ["$avg_confidence", 2] },
+      "_id": 0
+    }
+  }
+]
+```
+
+## Compute derived metrics
+
+A sensor reports voltage and current. This pipeline computes power (voltage \* current) and summarizes per hour:
+
+```json
+[
+  { "$match": { "component_name": "power-monitor" } },
+  {
+    "$addFields": {
+      "power_watts": {
+        "$multiply": ["$data.readings.voltage", "$data.readings.current"]
+      }
+    }
+  },
+  {
+    "$group": {
+      "_id": {
+        "$dateTrunc": {
+          "date": "$time_received",
+          "unit": "hour"
+        }
+      },
+      "avg_power": { "$avg": "$power_watts" },
+      "max_power": { "$max": "$power_watts" },
+      "readings": { "$sum": 1 }
+    }
+  },
+  {
+    "$project": {
+      "hour": "$_id",
+      "avg_power_watts": { "$round": ["$avg_power", 2] },
+      "max_power_watts": { "$round": ["$max_power", 2] },
+      "readings": 1,
+      "_id": 0
+    }
+  }
+]
+```
+
+## Fleet-wide aggregation by location
+
+Aggregate sensor readings across all machines at each location to compare performance across sites:
+
+```json
+[
+  { "$match": { "component_name": "temperature-sensor" } },
+  {
+    "$group": {
+      "_id": "$location_id",
+      "avg_temp": { "$avg": "$data.readings.temperature" },
+      "min_temp": { "$min": "$data.readings.temperature" },
+      "max_temp": { "$max": "$data.readings.temperature" },
+      "machine_count": { "$addToSet": "$robot_id" },
+      "reading_count": { "$sum": 1 }
+    }
+  },
+  {
+    "$project": {
+      "location": "$_id",
+      "avg_temp": { "$round": ["$avg_temp", 1] },
+      "min_temp": 1,
+      "max_temp": 1,
+      "machines_reporting": { "$size": "$machine_count" },
+      "reading_count": 1,
+      "_id": 0
+    }
+  }
+]
+```
diff --git a/docs/data/pipelines/manage-pipelines.md b/docs/data/pipelines/manage-pipelines.md
new file mode 100644
index 0000000000..2961542168
--- /dev/null
+++ b/docs/data/pipelines/manage-pipelines.md
@@ -0,0 +1,299 @@
+---
+linkTitle: "Manage pipelines"
+title: "Manage data pipelines"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "List, monitor, enable, disable, rename, and delete data pipelines."
+date: "2026-03-27"
+---
+
+Monitor and manage your data pipelines after creation. For creating pipelines, see [Create a pipeline](/data/pipelines/create-a-pipeline/).
+
+## List pipelines
+
+{{< tabs >}}
+{{% tab name="CLI" %}}
+
+```bash
+viam datapipelines list --org-id=<org-id>
+```
+
+Example output (one line per pipeline):
+
+```text
+hourly-temp-avg (ID: 64f3a1b2c4d5e6f7a8b9c0d1) [Enabled] [Data Source Type: Standard]
+daily-summary (ID: 64f3a1b2c4d5e6f7a8b9c0d2) [Disabled] [Data Source Type: Hot Storage]
+```
+
+If the command prints nothing, the organization has no pipelines. This is not an error.
+
+{{% /tab %}}
+{{% tab name="Python" %}}
+
+```python
+pipelines = await data_client.list_data_pipelines(organization_id=ORG_ID)
+for p in pipelines:
+    print(f"{p.id}: {p.name} (enabled={p.enabled}, schedule={p.schedule})")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+pipelines, err := dataClient.ListDataPipelines(ctx, orgID)
+if err != nil {
+    logger.Fatal(err)
+}
+for _, p := range pipelines {
+    fmt.Printf("%s: %s (enabled=%v, schedule=%s)\n", p.ID, p.Name, p.Enabled, p.Schedule)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Get pipeline details
+
+{{< tabs >}}
+{{% tab name="CLI" %}}
+
+```bash
+viam datapipelines describe --id=<pipeline-id>
+```
+
+Example output:
+
+```text
+ID: 64f3a1b2c4d5e6f7a8b9c0d1
+Name: hourly-temp-avg
+Enabled: true
+Schedule: 0 * * * *
+MQL query: [
+  {
+    "$match": {
+      "component_name": "temperature-sensor"
+    }
+  },
+  ...
+]
+DataSourceType: TABULAR_DATA_SOURCE_TYPE_STANDARD
+Last run:
+  Status: Success
+  Started: 2026-03-15T15:02:13Z
+  Data range: [2026-03-15T14:00:00Z, 2026-03-15T15:00:00Z]
+  Ended: 2026-03-15T15:02:18Z
+```
+
+If the pipeline has never run, the last section reads `Has not run yet.` instead.
+
+{{% /tab %}}
+{{% tab name="Python" %}}
+
+```python
+pipeline = await data_client.get_data_pipeline(id="YOUR-PIPELINE-ID")
+print(f"Name: {pipeline.name}")
+print(f"Schedule: {pipeline.schedule}")
+print(f"Enabled: {pipeline.enabled}")
+print(f"Data source: {pipeline.data_source_type}")
+print(f"Created: {pipeline.created_on}")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+pipeline, err := dataClient.GetDataPipeline(ctx, "YOUR-PIPELINE-ID")
+if err != nil {
+    logger.Fatal(err)
+}
+fmt.Printf("Name: %s\nSchedule: %s\nEnabled: %v\n", pipeline.Name, pipeline.Schedule, pipeline.Enabled)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Monitor pipeline runs
+
+Each pipeline run has a status and an associated time window showing which data it processed.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+# Returns a page of runs (default page size: 10)
+page = await data_client.list_data_pipeline_runs(id="YOUR-PIPELINE-ID")
+for run in page.runs:
+    print(f"Run {run.id}: {run.status}")
+    print(f"  Data window: {run.data_start_time} to {run.data_end_time}")
+    if run.error_message:
+        print(f"  Error: {run.error_message}")
+
+# Get the next page if there are more runs
+if page.next_page_token:
+    next_page = await page.next_page()
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+// Returns a page of runs (default page size: 10)
+page, err := dataClient.ListDataPipelineRuns(ctx, "YOUR-PIPELINE-ID", 10)
+if err != nil {
+    logger.Fatal(err)
+}
+for _, run := range page.Runs {
+    fmt.Printf("Run %s: %d\n", run.ID, run.Status)
+    fmt.Printf("  Data window: %s to %s\n", run.DataStartTime, run.DataEndTime)
+    if run.ErrorMessage != "" {
+        fmt.Printf("  Error: %s\n", run.ErrorMessage)
+    }
+}
+
+// Get the next page
+nextPage, err := page.NextPage(ctx)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Run statuses:
+
+| SDK status  | CLI label   | Meaning                                                                            |
+| ----------- | ----------- | ---------------------------------------------------------------------------------- |
+| `SCHEDULED` | `Scheduled` | The run is queued and waiting to execute (2-minute delay before execution starts). |
+| `STARTED`   | `Running`   | The run is executing the MQL aggregation against the data source.                  |
+| `COMPLETED` | `Success`   | The run finished and results are in the pipeline sink.                             |
+| `FAILED`    | `Failed`    | The run encountered an error. Check the `error_message` field.                     |
+
+SDK methods return the enum `Status` value on the left. The `viam datapipelines describe` CLI output uses the label on the right.
+
+If a run stays in `STARTED` for more than 10 minutes, it is automatically marked as failed and a new run is created for that time window.
+
+## Enable a pipeline
+
+{{< tabs >}}
+{{% tab name="CLI" %}}
+
+```bash
+viam datapipelines enable --id=<pipeline-id>
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+err = dataClient.EnableDataPipeline(ctx, "YOUR-PIPELINE-ID")
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+{{< alert title="Note" color="note" >}}
+The Python SDK does not currently have `enable_data_pipeline` or `disable_data_pipeline` methods. Use the CLI or Go SDK.
+{{< /alert >}}
+
+## Disable a pipeline
+
+{{< tabs >}}
+{{% tab name="CLI" %}}
+
+```bash
+viam datapipelines disable --id=<pipeline-id>
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+err = dataClient.DisableDataPipeline(ctx, "YOUR-PIPELINE-ID")
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Disabling a pipeline stops future scheduled runs but does not delete existing results. When you re-enable a pipeline, it resumes from the next scheduled time window. It does not backfill windows it missed while disabled.
+
+## Rename a pipeline
+
+{{< tabs >}}
+{{% tab name="CLI" %}}
+
+```bash
+viam datapipelines rename --id=<pipeline-id> --name=new-name
+```
+
+{{% /tab %}}
+{{% tab name="Python" %}}
+
+```python
+await data_client.rename_data_pipeline(id="YOUR-PIPELINE-ID", name="new-name")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+err = dataClient.RenameDataPipeline(ctx, "YOUR-PIPELINE-ID", "new-name")
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Delete a pipeline
+
+{{< tabs >}}
+{{% tab name="CLI" %}}
+
+```bash
+viam datapipelines delete --id=<pipeline-id>
+```
+
+{{% /tab %}}
+{{% tab name="Python" %}}
+
+```python
+await data_client.delete_data_pipeline(id="YOUR-PIPELINE-ID")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+err = dataClient.DeleteDataPipeline(ctx, "YOUR-PIPELINE-ID")
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+{{< alert title="Deleting a pipeline is irreversible" color="caution" >}}
+Deleting a pipeline removes the pipeline configuration, its execution history, and all output data in the pipeline sink. If you need to preserve pipeline results, export them first.
+{{< /alert >}}
+
+## Troubleshooting
+
+{{< expand "Pipeline consistently fails" >}}
+
+1. Check the error message in the run details (`list_data_pipeline_runs` or `describe`).
+2. Run the same MQL query manually in the [query editor](/data/query-data/) using MQL mode against the same data source. This isolates whether the issue is in the query or the pipeline configuration.
+3. Common failure causes:
+   - Invalid MQL stage or syntax error
+   - Query timeout (5-minute limit) on large datasets. Add a `$match` filter to reduce data.
+   - Output exceeds 10,000 documents. Add `$limit` or make the `$group` less granular.
+
+{{< /expand >}}
+
+{{< expand "Re-enabled pipeline has gaps in results" >}}
+
+This is expected. When you disable a pipeline, scheduled runs do not execute. When you re-enable it, it resumes from the next scheduled window. Missed windows are not retroactively processed, even if backfill is enabled. Backfill only applies to late-arriving data within windows the pipeline was active for.
+
+{{< /expand >}}
+
+{{< expand "Hot data store query returns no data" >}}
+
+- Verify the hot data store is enabled on the component. See [Hot data store](/data/hot-data-store/).
+- Check that data falls within the configured `stored_hours` window. Older data is removed hourly.
+- Verify data has been captured and synced within the retention window.
+
+{{< /expand >}}
diff --git a/docs/data/pipelines/overview.md b/docs/data/pipelines/overview.md
new file mode 100644
index 0000000000..ce9421710b
--- /dev/null
+++ b/docs/data/pipelines/overview.md
@@ -0,0 +1,84 @@
+---
+linkTitle: "Overview"
+title: "Data pipelines"
+weight: 1
+layout: "docs"
+type: "docs"
+description: "How data pipelines work: scheduled MQL aggregations that transform raw captured data into precomputed summaries."
+date: "2026-03-27"
+---
+
+A data pipeline runs a scheduled MQL aggregation query against your captured data and stores the results as precomputed summary documents. Instead of querying 86,000 raw sensor readings to compute an hourly average, you query a single summary document that the pipeline already computed.
+
+## When to use pipelines
+
+Pipelines are useful when:
+
+- **Your aggregation queries take too long.** If computing averages, counts, or rollups over raw data takes more than a few seconds, a pipeline pre-computes the result so you query a summary instead of scanning raw readings.
+- **You need the same computation on a schedule.** Hourly averages, daily counts, per-location rollups. A pipeline runs the query automatically and stores the result. No scripts, no cron jobs on your machine.
+- **You're feeding results into other tools.** Dashboards, alerts, or downstream pipelines can query the pipeline sink directly. The output is a small, stable collection that doesn't grow with your raw data volume.
+
+Pipelines are not necessary when:
+
+- Your queries already return in under a second. Pipelines add complexity; use them when you need the performance gain.
+- You need ad-hoc, one-time queries. Use the [query editor](/data/query-data/) instead.
+- You need real-time results with sub-minute latency. Pipelines run on a cron schedule with at least a 2-minute execution delay.
+
+{{< alert title="Pipelines don't reduce data transfer" color="note" >}}
+Pipelines run in the cloud against data that has already been synced. They reduce query time, not bandwidth or storage volume. To reduce what gets sent from the machine, see [Filter at the edge](/data/filter-at-the-edge/).
+{{< /alert >}}
+
+## How pipelines work
+
+A pipeline has four parts:
+
+1. **An MQL aggregation query.** A sequence of MongoDB aggregation stages (`$match`, `$group`, `$project`, and others) that transforms raw documents into summary documents. You write the query; the pipeline runs it automatically. See [Examples and tips](/data/pipelines/examples/) for common patterns.
+
+2. **A [cron schedule](/data/pipelines/reference/#cron-schedule).** Determines how often the pipeline runs. The schedule also determines the query time window: an hourly schedule (`0 * * * *`) scopes each run to the previous hour of data. A 15-minute schedule (`*/15 * * * *`) scopes each run to the previous 15 minutes. Schedules are in UTC.
+
+3. **A data source.** Either `standard` (the raw readings collection containing all historical data) or `hotstorage` (the [hot data store](/data/hot-data-store/) containing a rolling window of recent data). See [Data source types](/data/pipelines/reference/#data-source-types) for the full list.
+
+4. **A pipeline sink.** The destination collection where results are stored. Each pipeline has its own sink. You query pipeline results by specifying the `pipeline_sink` data source type and the pipeline's ID.
+
+### Execution flow
+
+When a pipeline's cron schedule triggers:
+
+1. The pipeline determines the time window from the schedule (for example, 02:00 to 03:00 PM for an hourly pipeline running at 03:00 PM).
+2. It prepends a time constraint to your MQL query that limits it to documents within that window.
+3. It executes the query against the configured data source with a 5-minute timeout.
+4. If the query produces 10,000 or fewer documents, results are written to the pipeline sink.
+5. The run is marked as completed or failed.
+
+Each run processes exactly one time window with no gaps and no overlaps between consecutive runs.
+
+### Backfill
+
+When you enable backfill on a pipeline, Viam processes historical time windows that the pipeline missed. This is useful in two scenarios:
+
+- **Late-arriving data.** If a machine syncs data with a delay (for example, it was offline and synced a backlog), the pipeline automatically reruns the affected time windows to include the late data.
+- **New pipeline on existing data.** When you create a pipeline with backfill enabled, it processes historical data backward from the creation time to the earliest available data.
+
+When backfill is disabled, each time window is processed exactly once. Late-arriving data is not incorporated into past summaries.
+
+### Limits
+
+- **Output size:** Each pipeline run can produce a maximum of 10,000 documents. Runs that exceed this limit fail.
+- **Execution timeout:** MQL queries time out after 5 minutes. Complex aggregations on large datasets may need to be simplified or scoped with tighter `$match` filters.
+- **Minimum schedule interval:** The cron schedule must have at least 1-minute granularity.
+
+## Data source types
+
+| Source type     | What it queries                                                                        | When to use                                                                                                                                  |
+| --------------- | -------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| `standard`      | The raw `readings` collection containing all historical tabular data                   | Default. Use for aggregations over any time range.                                                                                           |
+| `hotstorage`    | The [hot data store](/data/hot-data-store/) containing a rolling window of recent data | Use when your pipeline only needs recent data and you want lower query latency.                                                              |
+| `pipeline_sink` | The output of another pipeline                                                         | Use when chaining pipelines: one pipeline produces summaries, another aggregates those summaries further. Requires the source pipeline's ID. |
+
+## What's next
+
+- [Create a pipeline](/data/pipelines/create-a-pipeline/): step-by-step guide to creating your first pipeline
+- [Query pipeline results](/data/pipelines/query-results/): access precomputed summaries from your code
+- [Manage pipelines](/data/pipelines/manage-pipelines/): list, enable, disable, monitor, and delete pipelines
+- [Examples and tips](/data/pipelines/examples/): MQL patterns for common robotics use cases
+- [Reference](/data/pipelines/reference/): configuration fields, run statuses, cron schedule syntax
diff --git a/docs/data/pipelines/query-results.md b/docs/data/pipelines/query-results.md
new file mode 100644
index 0000000000..e43191a1cb
--- /dev/null
+++ b/docs/data/pipelines/query-results.md
@@ -0,0 +1,108 @@
+---
+linkTitle: "Query results"
+title: "Query pipeline results"
+weight: 15
+layout: "docs"
+type: "docs"
+description: "Query the output of a data pipeline from Python, Go, or TypeScript."
+date: "2026-03-27"
+---
+
+Once you have [created a pipeline](/data/pipelines/create-a-pipeline/), its results land in a dedicated sink collection that is separate from your raw data. This page covers how to query that sink.
+
+You query pipeline results the same way you query raw readings, except you specify the `pipeline_sink` data source type and the **pipeline ID** of the pipeline whose results you want. The pipeline ID is returned on creation. If you did not save it, retrieve it with:
+
+```bash
+viam datapipelines list --org-id=<org-id>
+```
+
+To see a specific pipeline and its last run:
+
+```bash
+viam datapipelines describe --id=<pipeline-id>
+```
+
+Both commands are also documented in [Manage pipelines](/data/pipelines/manage-pipelines/).
+
+## Query with the SDK
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.gen.app.data.v1.data_pb2 import TabularDataSourceType
+
+PIPELINE_ID = "YOUR-PIPELINE-ID"
+
+# Returns a list of result documents
+results = await data_client.tabular_data_by_mql(
+    organization_id=ORG_ID,
+    query=[
+        {"$limit": 10},
+    ],
+    tabular_data_source_type=TabularDataSourceType.TABULAR_DATA_SOURCE_TYPE_PIPELINE_SINK,
+    pipeline_id=PIPELINE_ID,
+)
+
+for entry in results:
+    print(entry)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+results, err := dataClient.TabularDataByMQL(ctx, orgID,
+    []map[string]interface{}{
+        {"$limit": 10},
+    },
+    &app.TabularDataByMQLOptions{
+        TabularDataSourceType: app.TabularDataSourceTypePipelineSink,
+        PipelineID:            "YOUR-PIPELINE-ID",
+    },
+)
+if err != nil {
+    logger.Fatal(err)
+}
+
+for _, entry := range results {
+    fmt.Printf("%v\n", entry)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+The query runs against the pipeline's output documents, not the raw readings. The fields available depend on what your pipeline's `$project` stage produces.
+
+## What results look like
+
+Each result document contains the fields your pipeline's `$project` stage outputs, plus metadata added automatically:
+
+```json
+{
+  "_viam_pipeline_run": {
+    "id": "run-id",
+    "interval": {
+      "start": "2025-03-15T14:00:00.000Z",
+      "end": "2025-03-15T15:00:00.000Z"
+    },
+    "organization_id": "org-id"
+  },
+  "location": "warehouse-a",
+  "avg_temp": 23.5,
+  "count": 3600
+}
+```
+
+You can use `$match` on the `_viam_pipeline_run.interval` fields to filter results by time window.
+
+## Troubleshooting
+
+{{< expand "Query returns empty results" >}}
+
+- **Pipeline hasn't run yet.** Check pipeline run status with `viam datapipelines describe --id=<pipeline-id>` or see [Monitor pipeline runs](/data/pipelines/manage-pipelines/#monitor-pipeline-runs). Wait for at least one run to complete.
+- **Wrong pipeline ID.** The ID is returned on creation and visible in `viam datapipelines list`.
+- **Wrong data source type.** You must specify `TABULAR_DATA_SOURCE_TYPE_PIPELINE_SINK`, not `STANDARD` or `HOT_STORAGE`.
+
+{{< /expand >}}
diff --git a/docs/data/pipelines/reference.md b/docs/data/pipelines/reference.md
new file mode 100644
index 0000000000..4210c02c33
--- /dev/null
+++ b/docs/data/pipelines/reference.md
@@ -0,0 +1,149 @@
+---
+linkTitle: "Pipeline reference"
+title: "Data pipelines reference"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "Configuration fields, run statuses, cron schedule syntax, data source types, and execution limits."
+date: "2026-03-27"
+---
+
+Configuration fields, execution behavior, and limits for data pipelines. For an overview of how pipelines work, see [Data pipelines overview](/data/pipelines/overview/).
+
+## Pipeline configuration fields
+
+These are the underlying fields on the pipeline resource. The CLI flags and SDK parameters you use to create a pipeline each set one of these fields.
+
+| Field              | Type   | Required | CLI flag                | Description                                                                                                                     |
+| ------------------ | ------ | -------- | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
+| `name`             | string | Yes      | `--name`                | Pipeline name. Must be unique within the organization.                                                                          |
+| `organization_id`  | string | Yes      | `--org-id`              | Organization UUID.                                                                                                              |
+| `schedule`         | string | Yes      | `--schedule`            | Cron expression in UTC. Determines both when the pipeline runs and the query time window. See [Cron schedule](#cron-schedule).  |
+| `mql_binary`       | array  | Yes      | `--mql` or `--mql-path` | MQL aggregation pipeline as an array of stage objects. See [Supported MQL operators](/data/reference/#supported-mql-operators). |
+| `enable_backfill`  | bool   | Yes      | `--enable-backfill`     | Whether to process historical time windows. See [Backfill behavior](#backfill-behavior).                                        |
+| `data_source_type` | enum   | Yes      | `--data-source-type`    | Data source to query. Accepts `standard` or `hotstorage`. See [Data source types](#data-source-types).                          |
+
+## Cron schedule
+
+The `schedule` field uses standard five-field cron syntax: `minute hour day-of-month month day-of-week`. All times are UTC.
+
+The schedule determines both when the pipeline runs and the time range it queries. Each run processes the time window between the previous two schedule ticks.
+
+| Schedule       | Frequency        | Query time range per run |
+| -------------- | ---------------- | ------------------------ |
+| `0 * * * *`    | Hourly           | Previous hour            |
+| `0 0 * * *`    | Daily            | Previous day             |
+| `*/15 * * * *` | Every 15 minutes | Previous 15 minutes      |
+| `*/5 * * * *`  | Every 5 minutes  | Previous 5 minutes       |
+
+For example, a pipeline with schedule `0 * * * *` that triggers at 03:00 PM UTC processes data from 02:00 PM to 03:00 PM UTC. The time window is `[start, end)` (start inclusive, end exclusive).
+
+Choose a schedule that matches how frequently you need updated summaries. Shorter intervals produce more granular summaries but create more pipeline sink documents.
+
+## Data source types
+
+Pipelines support three data source types. You use them in two contexts: when creating a pipeline (the pipeline reads from this source) and when querying pipeline results (the query targets this source). Not every type is valid in both contexts.
+
+| Type          | Value string    | Description                                                                                                                                                                                      |
+| ------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Standard      | `standard`      | The raw `readings` collection containing all historical tabular data.                                                                                                                            |
+| Hot storage   | `hotstorage`    | The [hot data store](/data/hot-data-store/). A rolling window of recent data, with lower latency.                                                                                                |
+| Pipeline sink | `pipeline_sink` | The output of another pipeline. **Query-time only**: you cannot pass `pipeline_sink` to `--data-source-type` when creating a pipeline; use it in query calls alongside the source pipeline's ID. |
+
+The SDK constants for each type:
+
+| Type          | Python SDK                                                     | Go SDK                                  |
+| ------------- | -------------------------------------------------------------- | --------------------------------------- |
+| Standard      | `TabularDataSourceType.TABULAR_DATA_SOURCE_TYPE_STANDARD`      | `app.TabularDataSourceTypeStandard`     |
+| Hot storage   | `TabularDataSourceType.TABULAR_DATA_SOURCE_TYPE_HOT_STORAGE`   | `app.TabularDataSourceTypeHotStorage`   |
+| Pipeline sink | `TabularDataSourceType.TABULAR_DATA_SOURCE_TYPE_PIPELINE_SINK` | `app.TabularDataSourceTypePipelineSink` |
+
+To query the output of another pipeline, use `pipeline_sink` in your query call alongside the source pipeline's ID. See [Query pipeline results](/data/pipelines/query-results/).
+
+## Run statuses
+
+| Status        | Value | CLI label   | Description                                                           |
+| ------------- | ----- | ----------- | --------------------------------------------------------------------- |
+| `UNSPECIFIED` | 0     | `Unknown`   | Unknown or not set.                                                   |
+| `SCHEDULED`   | 1     | `Scheduled` | Run is queued. Execution begins after a 2-minute delay.               |
+| `STARTED`     | 2     | `Running`   | MQL query is executing against the data source.                       |
+| `COMPLETED`   | 3     | `Success`   | Run finished successfully. Results are in the pipeline sink.          |
+| `FAILED`      | 4     | `Failed`    | Run encountered an error. Check the `error_message` field on the run. |
+
+SDK methods return the enum `Status` values. The `viam datapipelines describe` CLI command prints the friendly "CLI label" form.
+
+If a run stays in `STARTED` for more than 10 minutes, it is automatically marked as `FAILED` and a new run is created for that time window.
+
+## Run fields
+
+Each pipeline run record contains:
+
+| Field             | Type      | Description                                                   |
+| ----------------- | --------- | ------------------------------------------------------------- |
+| `id`              | string    | Run identifier.                                               |
+| `status`          | enum      | Current status. See [Run statuses](#run-statuses).            |
+| `start_time`      | timestamp | When the run started executing.                               |
+| `end_time`        | timestamp | When the run completed or failed.                             |
+| `data_start_time` | timestamp | Start of the data time window this run processed (inclusive). |
+| `data_end_time`   | timestamp | End of the data time window this run processed (exclusive).   |
+| `error_message`   | string    | Error details if the run failed. Empty on success.            |
+
+## Backfill behavior
+
+When `enable_backfill` is `true`:
+
+- On pipeline creation, Viam processes historical time windows backward from the creation time to the earliest available data.
+- When data syncs with a delay (machine was offline), the pipeline automatically reruns affected time windows to include the late-arriving data.
+- Backfill processes in batches of up to 10 concurrent time windows with a 2-minute delay between batches.
+- For `standard` data source, backfill may provision an Atlas Data Federation instance for faster historical queries.
+- Backfill results replace any existing results for the same time window.
+
+When `enable_backfill` is `false`:
+
+- Each time window is processed exactly once.
+- Late-arriving data is not incorporated into past summaries.
+
+Backfill does not apply to windows missed while a pipeline was disabled. If you disable a pipeline for 3 hours and re-enable it, those 3 hours are not backfilled.
+
+## Pipeline sink
+
+Each pipeline stores its output in a dedicated sink collection named `sink-<pipeline-id>`. Each result document includes metadata:
+
+```json
+{
+  "_viam_pipeline_run": {
+    "id": "run-id",
+    "interval": {
+      "start": "2025-03-15T14:00:00.000Z",
+      "end": "2025-03-15T15:00:00.000Z"
+    },
+    "organization_id": "org-id"
+  },
+  "location": "warehouse-a",
+  "avg_temp": 23.5,
+  "count": 3600
+}
+```
+
+The `_viam_pipeline_run` field is added automatically. Your pipeline's `$project` output fields appear alongside it.
+
+To query the sink, use data source type `pipeline_sink` with the pipeline's ID. See [Query pipeline results](/data/pipelines/query-results/).
+
+{{< alert title="Deleting a pipeline is irreversible" color="caution" >}}
+Deleting a pipeline removes its sink collection and every result stored in it. Export the results first if you need to preserve them. See [Delete a pipeline](/data/pipelines/manage-pipelines/#delete-a-pipeline).
+{{< /alert >}}
+
+## Execution limits
+
+| Limit                            | Value                                                          |
+| -------------------------------- | -------------------------------------------------------------- |
+| Maximum output documents per run | 10,000                                                         |
+| MQL execution timeout            | 5 minutes                                                      |
+| Execution start delay            | 2 minutes after scheduled time                                 |
+| Hung run detection               | 2x execution timeout (currently 10 minutes) in `STARTED` state |
+| Backfill batch size              | 10 concurrent time windows                                     |
+| Backfill throttle                | 2-minute delay between batches                                 |
+
+## Permissions
+
+Only organization owners can create, modify, and delete data pipelines. Query access to pipeline results follows the same permissions as other data queries. See [Permissions](/data/reference/#permissions).
diff --git a/docs/data/query-data-from-code.md b/docs/data/query-data-from-code.md
new file mode 100644
index 0000000000..82be30bb63
--- /dev/null
+++ b/docs/data/query-data-from-code.md
@@ -0,0 +1,217 @@
+---
+linkTitle: "Query from code"
+title: "Query data from code"
+weight: 22
+layout: "docs"
+type: "docs"
+description: "Query captured data programmatically using the Viam Python or Go SDK."
+date: "2026-03-26"
+aliases:
+  - /data/query-data-from-code/
+---
+
+Pull captured data into your own programs using the Viam data client API. You can run the same SQL and MQL queries available in the app's query editor from Python or Go code.
+
+{{< alert title="Tip: discover your data structure" color="tip" >}}
+Not sure what fields to query? Run this in the [query editor](/data/query-data/) first:
+
+```sql
+SELECT data FROM readings
+WHERE component_name = 'YOUR-COMPONENT'
+  AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)
+LIMIT 1
+```
+
+Switch to **table view** to see nested fields as dot-notation column headers. Use those paths in your code. See the [readings table schema](/data/schema/#column-reference) for the full reference.
+{{< /alert >}}
+
+{{< alert title="Known issue: SQL queries need an explicit lower time bound" color="caution" >}}
+SQL queries against `readings` currently return no rows unless the `WHERE` clause includes an explicit lower bound on `time_received`. Include `AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)` in any SQL example on this page if you copy it. MQL queries are not affected. Tracked as APP-10891.
+{{< /alert >}}
+
+## Set up a connection
+
+{{< readfile "/static/include/how-to/get-credentials.md" >}}
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```bash
+pip install viam-sdk
+```
+
+```python
+import asyncio
+from viam.rpc.dial import DialOptions
+from viam.app.viam_client import ViamClient
+
+API_KEY = "YOUR-API-KEY"
+API_KEY_ID = "YOUR-API-KEY-ID"
+ORG_ID = "YOUR-ORGANIZATION-ID"
+
+
+async def main():
+    dial_options = DialOptions.with_api_key(
+        api_key=API_KEY,
+        api_key_id=API_KEY_ID,
+    )
+    client = await ViamClient.create_from_dial_options(dial_options)
+    data_client = client.data_client
+
+    # ... your queries here ...
+
+    client.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```bash
+mkdir query-data && cd query-data
+go mod init query-data
+go get go.viam.com/rdk
+```
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/app"
+    "go.viam.com/rdk/logging"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewDebugLogger("query-data")
+
+    viamClient, err := app.CreateViamClientWithAPIKey(
+        ctx, app.Options{}, "YOUR-API-KEY", "YOUR-API-KEY-ID", logger)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer viamClient.Close()
+
+    dataClient := viamClient.DataClient()
+
+    // ... your queries here ...
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Query with SQL
+
+Use `tabular_data_by_sql` to run SQL queries. Results come back as a list of rows.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+# Returns a list of dictionaries, one per row
+results = await data_client.tabular_data_by_sql(
+    organization_id=ORG_ID,
+    sql_query=(
+        "SELECT time_received, "
+        "  data.readings.temperature AS temperature "
+        "FROM readings "
+        "WHERE component_name = 'my-sensor' "
+        "  AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP) "
+        "ORDER BY time_received DESC "
+        "LIMIT 5"
+    ),
+)
+
+for row in results:
+    print(row)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+// Returns a slice of maps, one per row
+results, err := dataClient.TabularDataBySQL(ctx, orgID,
+    "SELECT time_received, "+
+        "data.readings.temperature AS temperature "+
+        "FROM readings "+
+        "WHERE component_name = 'my-sensor' "+
+        "  AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP) "+
+        "ORDER BY time_received DESC LIMIT 5")
+if err != nil {
+    logger.Fatal(err)
+}
+
+for _, row := range results {
+    fmt.Printf("%v\n", row)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Query with MQL
+
+Use `tabular_data_by_mql` for MongoDB aggregation pipelines. MQL is more powerful than SQL for grouping, computing averages, and reshaping nested data.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+# Returns a list of dictionaries from the aggregation result
+results = await data_client.tabular_data_by_mql(
+    organization_id=ORG_ID,
+    query=[
+        {"$match": {"component_name": "my-sensor"}},
+        {"$group": {
+            "_id": "$component_name",
+            "avg_temp": {"$avg": "$data.readings.temperature"},
+            "count": {"$sum": 1},
+        }},
+    ],
+)
+
+for entry in results:
+    print(entry)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+// Returns a slice of maps from the aggregation result
+results, err := dataClient.TabularDataByMQL(ctx, orgID,
+    []map[string]interface{}{
+        {"$match": map[string]interface{}{
+            "component_name": "my-sensor",
+        }},
+        {"$group": map[string]interface{}{
+            "_id":      "$component_name",
+            "avg_temp": map[string]interface{}{"$avg": "$data.readings.temperature"},
+            "count":    map[string]interface{}{"$sum": 1},
+        }},
+    }, nil)
+if err != nil {
+    logger.Fatal(err)
+}
+
+for _, entry := range results {
+    fmt.Printf("%v\n", entry)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## What's next
+
+- [Query reference](/data/reference/): schema, supported operators, and optimization tips
+- [Create a data pipeline](/data/pipelines/create-a-pipeline/): schedule recurring queries
+- [Sync to your database](/data/sync-data-to-your-database/): export data to your own MongoDB instance
+- [Data client API reference](/reference/apis/data-client/): full method documentation
diff --git a/docs/data/query-data.md b/docs/data/query-data.md
new file mode 100644
index 0000000000..45f42895cc
--- /dev/null
+++ b/docs/data/query-data.md
@@ -0,0 +1,340 @@
+---
+linkTitle: "Query in the app"
+title: "Query data in the Viam app"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "Write SQL and MQL queries against captured data in the Viam app or programmatically."
+date: "2025-01-30"
+aliases:
+  - /data/query/query-data/
+  - /data/query-data/
+  - /build/data/query-data/
+---
+
+Explore and analyze your captured data using SQL or MQL queries. You can run queries interactively in the Viam app's query editor or programmatically through the SDK for ad-hoc analysis, building dashboards, or integrating with your own tools.
+
+Tabular data (sensor readings, motor positions, encoder ticks, and other structured key-value data) is queryable through SQL and MQL. Binary data (images, point clouds) is stored separately and accessible through the [data client API](/reference/apis/data-client/).
+
+{{< alert title="Known issue: SQL queries need an explicit lower time bound" color="caution" >}}
+SQL queries against `readings` currently return no rows unless the `WHERE` clause includes an explicit lower bound on `time_received`. Every SQL example and troubleshooting step on this page (including short inline examples) includes an explicit lower bound on `time_received` for this reason. When troubleshooting, do not remove the lower-bound filter entirely: widen it by using a broad lower bound such as `AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)`. MQL queries are not affected. Tracked as APP-10891.
+{{< /alert >}}
+
+## Open the query editor
+
+1. Go to [app.viam.com](https://app.viam.com).
+2. Click the **DATA** tab in the top navigation.
+3. Click **Query** to open the query editor.
+4. Select **SQL** or **MQL** mode depending on which language you want to use.
+
+**SQL** is good for straightforward filtering, sorting, and limiting.
+**MQL** (MongoDB Query Language) uses aggregation pipelines and is more powerful for grouping, computing averages, and restructuring nested data.
+
+By default, queries run against the `readings` collection in the `sensorData` database.
+See [Query reference](/data/schema/#column-reference) for the full schema.
+
+## Explore your data with basic SQL
+
+Start with a broad query to see what data you have:
+
+```sql
+SELECT time_received, component_name, component_type, data
+FROM readings
+WHERE time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)
+ORDER BY time_received DESC
+LIMIT 10
+```
+
+This shows the 10 most recent readings across all components.
+Most of the interesting values are in the `data` column, which contains your actual readings as nested JSON.
+
+To see the structure of your data, run this query for a specific component:
+
+```sql
+SELECT data FROM readings
+WHERE component_name = 'my-sensor'
+  AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)
+LIMIT 1
+```
+
+Switch to **table view** (the table icon in the results area) to see nested fields automatically flattened into dot-notation column headers like `data.readings.temperature`. These dot-notation paths are exactly what you use in your queries to extract specific values.
+
+For the full schema and per-component examples, see the [readings table schema](/data/schema/#column-reference).
+
+To narrow to a specific component:
+
+```sql
+SELECT time_received, data
+FROM readings
+WHERE component_name = 'my-sensor'
+  AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)
+ORDER BY time_received DESC
+LIMIT 10
+```
+
+To filter by time range:
+
+```sql
+SELECT time_received, component_name, data
+FROM readings
+WHERE time_received > '2025-01-15T00:00:00Z'
+  AND time_received < '2025-01-16T00:00:00Z'
+ORDER BY time_received ASC
+```
+
+## Extract fields from nested JSON
+
+The `data` column contains JSON, so you need JSON functions to extract specific
+values. Use dot notation to reach into the nested structure:
+
+```sql
+SELECT
+  time_received,
+  data.readings.temperature AS temperature,
+  data.readings.humidity AS humidity
+FROM readings
+WHERE component_name = 'my-sensor'
+  AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)
+ORDER BY time_received DESC
+LIMIT 20
+```
+
+For detection results from a vision service:
+
+```sql
+SELECT
+  time_received,
+  data.detections
+FROM readings
+WHERE component_name = 'my-detector'
+  AND component_type = 'rdk:service:vision'
+  AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)
+ORDER BY time_received DESC
+LIMIT 10
+```
+
+To filter by a specific machine:
+
+```sql
+SELECT time_received, component_name, data
+FROM readings
+WHERE robot_id = 'YOUR-MACHINE-ID'
+  AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)
+ORDER BY time_received DESC
+LIMIT 10
+```
+
+## Write MQL aggregation pipelines
+
+Switch to **MQL** mode in the query editor. MQL queries are JSON arrays where
+each element is a pipeline stage.
+
+Get the last 10 readings from a component:
+
+```json
+[
+  { "$match": { "component_name": "my-sensor" } },
+  { "$sort": { "time_received": -1 } },
+  { "$limit": 10 },
+  {
+    "$project": {
+      "time_received": 1,
+      "data": 1,
+      "_id": 0
+    }
+  }
+]
+```
+
+Count readings per component:
+
+```json
+[
+  {
+    "$group": {
+      "_id": "$component_name",
+      "count": { "$sum": 1 }
+    }
+  },
+  { "$sort": { "count": -1 } }
+]
+```
+
+Count readings per component over a specific time window:
+
+```json
+[
+  {
+    "$match": {
+      "time_received": {
+        "$gte": { "$date": "2025-01-15T00:00:00Z" },
+        "$lt": { "$date": "2025-01-16T00:00:00Z" }
+      }
+    }
+  },
+  {
+    "$group": {
+      "_id": "$component_name",
+      "count": { "$sum": 1 }
+    }
+  },
+  { "$sort": { "count": -1 } }
+]
+```
+
+Compute average, min, and max of a sensor value:
+
+```json
+[
+  { "$match": { "component_name": "my-sensor" } },
+  {
+    "$group": {
+      "_id": null,
+      "avg_temperature": { "$avg": "$data.readings.temperature" },
+      "min_temperature": { "$min": "$data.readings.temperature" },
+      "max_temperature": { "$max": "$data.readings.temperature" },
+      "total_readings": { "$sum": 1 }
+    }
+  }
+]
+```
+
+Group readings by hour to see trends over time:
+
+```json
+[
+  { "$match": { "component_name": "my-sensor" } },
+  {
+    "$group": {
+      "_id": {
+        "$dateToString": {
+          "format": "%Y-%m-%d %H:00",
+          "date": "$time_received"
+        }
+      },
+      "avg_temperature": { "$avg": "$data.readings.temperature" },
+      "count": { "$sum": 1 }
+    }
+  },
+  { "$sort": { "_id": 1 } }
+]
+```
+
+Find all detections above a confidence threshold:
+
+```json
+[
+  { "$match": { "component_name": "my-detector" } },
+  { "$unwind": "$data.detections" },
+  { "$match": { "data.detections.confidence": { "$gte": 0.9 } } },
+  {
+    "$project": {
+      "time_received": 1,
+      "class_name": "$data.detections.class_name",
+      "confidence": "$data.detections.confidence",
+      "_id": 0
+    }
+  },
+  { "$sort": { "time_received": -1 } },
+  { "$limit": 20 }
+]
+```
+
+The `$unwind` stage is important when your data contains arrays. It flattens
+the array so each element becomes its own document, which you can then filter
+and project individually.
+
+## Query from code
+
+You can run the same SQL and MQL queries from Python or Go using the data client API. See [Query data from code](/data/query-data-from-code/) for setup instructions and examples.
+
+## Try it
+
+To get oriented with your own data:
+
+1. Open the query editor and run the following to see what components have captured data:
+
+   ```sql
+   SELECT DISTINCT component_name FROM readings
+   WHERE time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)
+   ```
+
+2. Pick a component and run the following to see the JSON structure of its readings:
+
+   ```sql
+   SELECT data FROM readings
+   WHERE component_name = 'YOUR-COMPONENT'
+     AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)
+   LIMIT 1
+   ```
+
+3. Use the field names from step 2 to write a query that extracts a specific value with dot notation (for example, `data.readings.temperature`).
+
+For the full schema of the readings table, see [Query reference](/data/schema/#column-reference).
+
+## Troubleshooting
+
+{{< expand "Query returns empty results" >}}
+
+- **Check the component name.** Component names are case-sensitive and must match
+  exactly. Run the following to see all available component names:
+
+  ```sql
+  SELECT DISTINCT component_name FROM readings
+  WHERE time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)
+  ```
+
+- **Check the time range.** If you narrowed the time range, widen it back to the
+  broad lower bound `time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)`
+  to confirm data exists, then tighten the range back down. Do not remove the
+  `time_received` filter entirely: under APP-10891, SQL queries without an
+  explicit lower bound on `time_received` return no rows.
+- **Verify data has synced.** Data must sync from the machine to the cloud before
+  it is queryable. Check the **DATA** tab to confirm entries are visible.
+
+{{< /expand >}}
+
+{{< expand "Query returns data but fields are null" >}}
+
+- **Check the JSON path.** The nested path must match the actual structure of
+  your data. Run the following to see the raw JSON, then build your dot-notation
+  path to match. A common mistake is using `data.temperature` when the actual
+  path is `data.readings.temperature`.
+
+  ```sql
+  SELECT data FROM readings
+  WHERE time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)
+  LIMIT 1
+  ```
+
+{{< /expand >}}
+
+{{< expand "MQL pipeline returns unexpected results" >}}
+
+- **Build incrementally.** Start with just the `$match` stage and verify it
+  returns the documents you expect. Then add one stage at a time. This makes it
+  easy to identify which stage is producing unexpected output.
+- **Check field references.** In MQL, field references use `$` prefix
+  (for example, `$component_name`, `$data.readings.temperature`). Missing the `$` is
+  a common source of errors.
+
+{{< /expand >}}
+
+{{< expand "Query is slow" >}}
+
+- **Add filters early.** Always include a `$match` stage (MQL) or `WHERE`
+  clause (SQL) to narrow the data before doing expensive operations like
+  grouping or sorting. Filtering by `component_name` and `time_received` is
+  particularly effective.
+- **Use LIMIT.** While developing queries, always include a `LIMIT` clause (SQL)
+  or `$limit` stage (MQL) to avoid scanning your entire dataset.
+
+{{< /expand >}}
+
+## What's next
+
+- [Create a data pipeline](/data/pipelines/create-a-pipeline/): create precomputed summaries for faster queries.
+- [Hot data store](/data/hot-data-store/): query a rolling window of recent data with lower latency.
+- [Sync data to your database](/data/sync-data-to-your-database/): export data to your own MongoDB instance.
+- [Visualize data](/data/visualize-data/): build dashboards from your captured data.
+- [Query captured data from an app](/build-apps/tasks/query-data/): run SQL and MQL queries from a custom client app using the SDK.
diff --git a/docs/data/reference.md b/docs/data/reference.md
new file mode 100644
index 0000000000..8b185327a0
--- /dev/null
+++ b/docs/data/reference.md
@@ -0,0 +1,340 @@
+---
+linkTitle: "Data reference"
+title: "Data management reference"
+weight: 999
+layout: "docs"
+type: "docs"
+description: "Data schema, query operators, configuration fields, supported resources, and storage behavior."
+aliases:
+  - /data/query-reference/
+  - /manage/data/query/
+  - /use-cases/sensor-data-query/
+  - /use-cases/sensor-data-query-with-third-party-tools/
+  - /how-tos/sensor-data-query-with-third-party-tools/
+  - /data-ai/data/query/
+  - /data/advanced-data-capture-sync/
+  - /data-ai/capture-data/advanced/advanced-data-capture-sync/
+  - /data-ai/capture-data/advanced/
+  - /data/query/query-reference/
+  - /data/capture-sync/advanced-data-capture-sync/
+date: "2025-02-10"
+---
+
+## Data schema
+
+For the full schema of the `readings` table (document format, column reference, the `data` column, and per-component data structures), see [Captured data schema](/data/schema/).
+
+## Query reference
+
+### Indexed fields and query optimization
+
+You can improve query performance by filtering on indexed fields early in your query. Viam stores data in blob storage using the path pattern:
+
+`/organization_id/location_id/robot_id/part_id/component_type/component_name/method_name/capture_day/*`
+
+The more specific you can be, starting with the beginning of the path, the faster your query. These fields are indexed:
+
+- `organization_id`
+- `location_id`
+- `robot_id`
+- `part_id`
+- `component_type`
+- `component_name`
+- `method_name`
+- `capture_day`
+
+Additional optimization techniques:
+
+- Filter and reduce data early. Use `$match` (MQL) or `WHERE` (SQL) before expensive operations like grouping or sorting.
+- Use `$project` early to drop unneeded fields from the processing pipeline.
+- Use `$limit` or `LIMIT` while developing queries to avoid scanning your entire dataset.
+- For frequent queries on recent data, use the [hot data store](/data/hot-data-store/).
+- For recurring queries (dashboards), use [data pipelines](/data/pipelines/create-a-pipeline/) to pre-compute materialized views.
+
+### Supported MQL operators
+
+Viam supports a subset of MongoDB aggregation pipeline stages. Operators not on this list will return an error.
+
+- `$addFields`
+- `$bucket`
+- `$bucketAuto`
+- `$count`
+- `$densify`
+- `$fill`
+- `$geoNear`
+- `$group`
+- `$limit`
+- `$match`
+- `$project`
+- `$redact`
+- `$replaceRoot`
+- `$replaceWith`
+- `$sample`
+- `$set`
+- `$setWindowFields`
+- `$skip`
+- `$sort`
+- `$sortByCount`
+- `$unset`
+- `$unwind`
+
+See the [MQL documentation](https://www.mongodb.com/docs/manual/tutorial/query-documents/) for syntax details.
+
+### SQL limitations
+
+Viam supports the [MongoDB Atlas SQL dialect](https://www.mongodb.com/docs/atlas/data-federation/query/sql/language-reference/#compatibility-and-limitations):
+
+- If a database, table, or column identifier begins with a digit, a reserved character, or conflicts with a reserved SQL keyword, surround it with backticks (`` ` ``) or double quotes (`"`).
+- To include a single quote in a string literal, use two single quotes (use `o''clock` to represent `o'clock`).
+- The `date` data type is not supported. Use `timestamp` instead.
+
+For a full list of limitations, see the [MongoDB Atlas SQL Interface Language Reference](https://www.mongodb.com/docs/atlas/data-federation/query/sql/language-reference/#compatibility-and-limitations).
+
+### Date queries
+
+MQL time-range queries perform better with the BSON `date` type than with `$toDate`. Use JavaScript `Date()` constructors in `mongosh`:
+
+```mongodb
+use sensorData
+
+const startTime = new Date('2024-02-10T19:45:07.000Z')
+const endTime = new Date()
+
+db.readings.aggregate([
+    { $match: {
+        time_received: {
+            $gte: startTime,
+            $lte: endTime
+        }
+    }}
+])
+```
+
+### Permissions
+
+Users with owner or operator roles at the organization, location, or machine level can query data. See [Role-Based Access Control](/organization/rbac/) for details.
+
+## Supported resources
+
+The following components and services support data capture and cloud sync. The table shows which capture methods are available for each resource type. Not all models support all methods listed for their type.
+
+{{< readfile "/static/include/data/capture-supported.md" >}}
+
+If the resource type you need is not listed, you can still capture data from it using the `DoCommand` method with a custom `docommand_input` parameter.
+
+## Capture and sync configuration
+
+This section describes the configuration fields for data capture and cloud sync.
+
+### Data management service attributes
+
+The data management service controls sync behavior, storage paths, and deletion policies. Most of these settings are configured through the Viam app UI. Edit JSON directly for settings not exposed in the UI, such as deletion thresholds, sync thread limits, and MongoDB capture.
+
+{{< tabs >}}
+{{% tab name="viam-server" %}}
+
+```json {class="line-numbers linkable-line-numbers"}
+{
+  "services": [
+    {
+      "name": "my-data-manager",
+      "api": "rdk:service:data_manager",
+      "model": "rdk:builtin:builtin",
+      "attributes": {
+        "sync_interval_mins": 1,
+        "capture_dir": "",
+        "tags": [],
+        "capture_disabled": false,
+        "sync_disabled": true,
+        "delete_every_nth_when_disk_full": 5,
+        "maximum_num_sync_threads": 250
+      }
+    }
+  ]
+}
+```
+
+{{% /tab %}}
+{{% tab name="viam-micro-server" %}}
+
+```json {class="line-numbers linkable-line-numbers"}
+{
+  "services": [
+    {
+      "name": "my-data-manager",
+      "api": "rdk:service:data_manager",
+      "model": "rdk:builtin:builtin",
+      "attributes": {
+        "capture_dir": "",
+        "tags": [],
+        "additional_sync_paths": [],
+        "sync_interval_mins": 3
+      }
+    }
+  ]
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+<!-- prettier-ignore -->
+<!-- markdownlint-disable MD060 -->
+
+| Name                              | Type             | Required? | Description                                                                                                                                                                                                                                                     | `viam-micro-server` Support                                         |
+| --------------------------------- | ---------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------- |
+| `capture_disabled`                | bool             | Optional  | Toggle data capture on or off for the entire machine {{< glossary_tooltip term_id="part" text="part" >}}. Even if capture is enabled for the whole part, data is only captured from components that have capture individually configured. <br> Default: `false` | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| `capture_dir`                     | string           | Optional  | Path to the directory where captured data is stored. If you change this, only new data goes to the new directory; existing data stays where it was. <br> Default: `~/.viam/capture`                                                                             | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| `tags`                            | array of strings | Optional  | Tags applied to all data captured by this machine part. May include alphanumeric characters, underscores, and dashes.                                                                                                                                           |                                                                     |
+| `sync_disabled`                   | bool             | Optional  | Toggle cloud sync on or off for the entire machine {{< glossary_tooltip term_id="part" text="part" >}}. <br> Default: `false`                                                                                                                                   |                                                                     |
+| `additional_sync_paths`           | string array     | Optional  | Additional directories to sync to the cloud. Data is deleted from the directory after syncing. Use absolute paths.                                                                                                                                              |                                                                     |
+| `sync_interval_mins`              | float            | Optional  | Minutes between sync attempts. Your hardware or network speed may impose practical limits. <br> Default: `0.1` (every 6 seconds).                                                                                                                               | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| `selective_syncer_name`           | string           | Optional  | Name of the sensor that controls selective sync. Also add this sensor to the `depends_on` field. See [Conditional sync](/data/capture-sync/conditional-sync/).                                                                                                  |                                                                     |
+| `delete_every_nth_when_disk_full` | int              | Optional  | When local storage meets the fullness criteria, the service deletes every Nth captured file. <br> Default: `5`                                                                                                                                                  |                                                                     |
+| `maximum_num_sync_threads`        | int              | Optional  | Max CPU threads for syncing to the cloud. Higher values may improve throughput but can cause instability on constrained devices. <br> Default: [runtime.NumCPU](https://pkg.go.dev/runtime#NumCPU)/2                                                            |                                                                     |
+| `mongo_capture_config.uri`        | string           | Optional  | [MongoDB URI](https://www.mongodb.com/docs/v6.2/reference/connection-string/) for writing tabular data alongside disk capture.                                                                                                                                  |                                                                     |
+| `mongo_capture_config.database`   | string           | Optional  | Database name for MongoDB capture. <br> Default: `"sensorData"`                                                                                                                                                                                                 |                                                                     |
+| `mongo_capture_config.collection` | string           | Optional  | Collection name for MongoDB capture. <br> Default: `"readings"`                                                                                                                                                                                                 |                                                                     |
+| `maximum_capture_file_size_bytes` | int              | Optional  | Maximum size in bytes of each capture file on disk. When a capture file reaches this size, a new file is created. <br> Default: `262144` (256 KB)                                                                                                               |                                                                     |
+| `file_last_modified_millis`       | int              | Optional  | How long (in ms) an arbitrary file must be unmodified before it is eligible for sync. Normal `.capture` files sync immediately. <br> Default: `10000`                                                                                                           |                                                                     |
+| `disk_usage_deletion_threshold`   | float            | Optional  | Disk usage ratio (0-1) at or above which captured files are deleted, provided the capture directory also meets `capture_dir_deletion_threshold`. <br> Default: `0.9`                                                                                            |                                                                     |
+| `capture_dir_deletion_threshold`  | float            | Optional  | Ratio (0-1) of disk usage attributable to the capture directory, at or above which deletion occurs (if `disk_usage_deletion_threshold` is also met). <br> Default: `0.5`                                                                                        |                                                                     |
+
+#### Platform-managed service settings
+
+The following settings appear in your machine's configuration but are not processed by `viam-server` on your machine. They are read and enforced by the Viam cloud platform:
+
+| Name                           | Type | Description                                                                                               |
+| ------------------------------ | ---- | --------------------------------------------------------------------------------------------------------- |
+| `delete_data_on_part_deletion` | bool | Whether deleting this machine or machine part also deletes all its captured cloud data. Default: `false`. |
+
+### Data capture method attributes
+
+Data capture is configured per-resource in the `service_configs` array of a component or service. When you configure capture through the Viam app UI, these fields are set automatically. The table below is the JSON-level reference for manual configuration.
+
+Here is where capture attributes live in a component's JSON config:
+
+```json
+{
+  "name": "my-sensor",
+  "api": "rdk:component:sensor",
+  "model": "rdk:builtin:fake",
+  "service_configs": [
+    {
+      "type": "data_manager",
+      "attributes": {
+        "capture_methods": [
+          {
+            "method": "Readings",
+            "capture_frequency_hz": 0.2,
+            "additional_params": {},
+            "disabled": false
+          }
+        ]
+      }
+    }
+  ]
+}
+```
+
+{{< alert title="Caution" color="caution" >}}
+Avoid configuring capture rates higher than your hardware can handle. This leads to performance degradation.
+{{< /alert >}}
+
+<!-- prettier-ignore -->
+| Name               | Type   | Required? | Description |
+| ------------------ | ------ | --------- | ----------- |
+| `name` | string | **Required** | Fully qualified resource name (for example, `rdk:component:sensor/my-sensor`). |
+| `method` | string | **Required** | Depends on the component or service type. See [Supported resources](#supported-resources). Individual tabular readings larger than 4&nbsp;MB are rejected at upload time and will not sync to the cloud. |
+| `capture_frequency_hz` | float   | **Required** | Frequency in hertz. For example, `0.5` = one reading every 2 seconds. |
+| `additional_params` | object | Optional | Method-specific parameters. For example, `DoCommand` requires a `docommand_input` object; `GetImages` accepts a `filter_source_names` list. |
+| `disabled` | boolean | Optional | Whether capture is disabled for this method. |
+| `tags` | array of strings | Optional | Tags applied to data captured by this specific method. Added alongside any tags set at the service level. |
+| `capture_directory` | string | Optional | Override the capture directory for this specific resource. If not set, uses the service-level `capture_dir`. |
+| `capture_queue_size` | int | Optional | Size of the buffer between the capture goroutine and the file writer. <br> Default: `250` |
+| `capture_buffer_size` | int | Optional | Size in bytes of the buffer used when writing captured data to disk. <br> Default: `4096` |
+| `cache_size_kb` | float | Optional | `viam-micro-server` only. Max storage (KB) per data collector. <br> Default: `1` |
+
+#### Platform-managed capture settings
+
+The following settings are processed by the Viam cloud platform, not by `viam-server`. `retention_policy` is set at the `attributes` level (sibling to `capture_methods`), while `recent_data_store` is set inside an individual `capture_methods[]` entry:
+
+```json
+{
+  "type": "data_manager",
+  "attributes": {
+    "capture_methods": [
+      {
+        "method": "Readings",
+        "capture_frequency_hz": 0.2,
+        "recent_data_store": {
+          "stored_hours": 24
+        }
+      }
+    ],
+    "retention_policy": {
+      "days": 30
+    }
+  }
+}
+```
+
+<!-- prettier-ignore -->
+| Name | Type | Level | Description |
+| --- | --- | --- | --- |
+| `retention_policy` | object | `attributes` (sibling to `capture_methods`) | How long captured data is retained in the cloud. Options: `"days": <int>`, `"binary_limit_gb": <int>`, `"tabular_limit_gb": <int>`. Days are in UTC. |
+| `recent_data_store` | object | Inside a `capture_methods[]` entry | Store a rolling window of recent data in a [hot data store](/data/hot-data-store/) for faster queries. Example: `{ "stored_hours": 24 }` |
+
+For remote parts capture, see [Capture from multi-part machines](/data/capture-sync/remote-parts-capture/).
+
+## Local storage
+
+This section describes how captured data is stored on the machine before syncing.
+
+### Capture directories
+
+By default, captured data is stored in `~/.viam/capture`.
+The actual path depends on your platform:
+
+<!-- prettier-ignore -->
+| Platform | Default directory |
+| -------- | ----------------- |
+| Windows | With `viam-agent`: <FILE>C:\Windows\system32\config\systemprofile\.viam\capture</FILE>. Manual installation: <FILE>C:\Users\admin\.viam\capture</FILE>. |
+| Linux | With root or sudo: <FILE>/root/.viam/capture</FILE>. |
+| macOS | <FILE>/Users/\<username\>/.viam/capture</FILE>. |
+
+{{% expand "Can't find the capture directory?" %}}
+
+The path depends on where `viam-server` runs and the operating system.
+Check your machine's startup logs for the `$HOME` value:
+
+```sh
+2025-01-15T14:27:26.073Z    INFO    rdk    server/entrypoint.go:77    Starting viam-server with following environment variables    {"HOME":"/home/johnsmith"}
+```
+
+{{% /expand%}}
+
+You can change the capture directory with the `capture_dir` attribute in the [data management service attributes](#data-management-service-attributes).
+
+### Automatic deletion
+
+After data syncs successfully, it is automatically deleted from local storage.
+While a machine is offline, captured data accumulates locally.
+
+{{< alert title="Warning" color="warning" >}}
+If your machine is offline and its disk fills up, the data management service will delete captured data to free space and keep the machine running.
+{{< /alert >}}
+
+Automatic deletion triggers when _all_ of these conditions are met:
+
+- Data capture is enabled
+- Local disk usage is at or above the `disk_usage_deletion_threshold` (default: 90%)
+- The capture directory accounts for at least the `capture_dir_deletion_threshold` proportion of disk usage (default: 50%)
+
+Control deletion behavior with the `delete_every_nth_when_disk_full` attribute.
+
+### Micro-RDK
+
+The [micro-RDK](/foundation/setup-micro/) (for ESP32 and similar microcontrollers) supports data capture with a smaller set of resources than `viam-server`. See the **Micro-RDK** tab in the [supported resources table](#supported-resources) for the specific methods available.
+
+On micro-RDK devices, captured data is stored in the ESP32's flash memory until it is uploaded to the cloud. If the machine restarts before all data is synced, unsynced data since the last sync point is lost.
diff --git a/docs/data/schema.md b/docs/data/schema.md
new file mode 100644
index 0000000000..69eb8ffe92
--- /dev/null
+++ b/docs/data/schema.md
@@ -0,0 +1,206 @@
+---
+linkTitle: "Captured data schema"
+title: "Captured data schema"
+weight: 12
+layout: "docs"
+type: "docs"
+description: "Structure of captured tabular data: document format, column reference, the data column, and common per-component data structures."
+date: "2025-02-10"
+---
+
+When you enable data capture on a component, `viam-server` records its readings to local disk and the data management service syncs those recordings to the cloud. Once synced, the captured tabular data (sensor readings, motor positions, encoder ticks, and other structured key-value data) lands in a single table called `readings` in the `sensorData` database. Each row represents one capture event from one resource.
+
+You can access this data in three ways:
+
+- **Viam app**: the **DATA** tab shows latest readings on the **Sensors** tab. The **Query** editor lets you run SQL or MQL against the `readings` table directly.
+- **Viam SDK**: the data client's `tabular_data_by_sql` and `tabular_data_by_mql` methods query the same table from Python or Go code.
+- **External tools**: connect Grafana, Tableau, or any MongoDB client using the database credentials from `viam data database configure`. See [Visualize data](/data/visualize-data/).
+
+This page describes the structure of the `readings` table and the nested `data` column so you know what to query.
+
+For query syntax, optimization tips, and supported operators, see [Data reference](/data/reference/).
+
+## What a document looks like
+
+Every row in the `readings` table has two layers: metadata that Viam adds automatically (organization, location, machine, part, component, method, timestamps, tags) and your actual captured values inside the `data` column.
+
+Here is a complete row for a sensor called `my-sensor`:
+
+```json
+{
+  "organization_id": "ab1c2d3e-1234-5678-abcd-ef1234567890",
+  "location_id": "loc-1234-5678-abcd-ef1234567890",
+  "robot_id": "robot-1234-5678-abcd-ef1234567890",
+  "part_id": "part-1234-5678-abcd-ef1234567890",
+  "component_type": "rdk:component:sensor",
+  "component_name": "my-sensor",
+  "method_name": "Readings",
+  "time_requested": "2025-03-15T14:30:00.000Z",
+  "time_received": "2025-03-15T14:30:01.234Z",
+  "tags": ["production", "floor-2"],
+  "additional_parameters": {},
+  "data": {
+    "readings": {
+      "temperature": 23.5,
+      "humidity": 61.2
+    }
+  }
+}
+```
+
+The metadata fields (`organization_id` through `additional_parameters`) are the same structure for every component type. The `data` column is different for each component and capture method. To query your specific values, you use dot notation into `data` (for example, `data.readings.temperature`).
+
+## Column reference
+
+| Column                  | Type      | Description                                                                                                        |
+| ----------------------- | --------- | ------------------------------------------------------------------------------------------------------------------ |
+| `organization_id`       | String    | Organization UUID. Set automatically from your machine's config.                                                   |
+| `location_id`           | String    | Location UUID. The location this machine belongs to.                                                               |
+| `robot_id`              | String    | Machine UUID. Identifies which machine captured this data.                                                         |
+| `part_id`               | String    | Machine part UUID. Identifies which part of the machine.                                                           |
+| `component_type`        | String    | Resource type as a triplet (for example, `rdk:component:sensor`).                                                  |
+| `component_name`        | String    | The name you gave this component in your config (for example, `my-sensor`). This is what you filter on most often. |
+| `method_name`           | String    | The capture method (for example, `Readings`, `GetImages`, `EndPosition`).                                          |
+| `time_requested`        | Timestamp | When the capture was requested on the machine (machine's clock).                                                   |
+| `time_received`         | Timestamp | When the cloud received and stored the data. Use this for time-range queries since it's indexed.                   |
+| `tags`                  | Array     | User-applied tags from your data management config.                                                                |
+| `additional_parameters` | JSON      | Method-specific parameters you configured (for example, `pin_name`, `reader_name`).                                |
+| `data`                  | JSON      | Your actual captured values. Structure varies by component type and method.                                        |
+
+{{< alert title="Note" color="note" >}}
+The `readings` table does not include `robot_name` or `part_name` columns. These fields appear in data export responses but are not part of the queryable schema. To filter by machine, use `robot_id` or `part_id`.
+{{< /alert >}}
+
+## The data column
+
+The `data` column contains your actual captured values as nested JSON. Its structure depends on what component and method captured the data. To find out what's inside `data` for your specific components, run:
+
+```sql
+SELECT data FROM readings
+WHERE component_name = 'my-sensor'
+  AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)
+LIMIT 1
+```
+
+Then use the field names you see to build more specific queries.
+
+{{< alert title="Known issue: SQL queries need an explicit lower time bound" color="caution" >}}
+SQL queries against `readings` currently return no rows unless the `WHERE` clause includes an explicit lower bound on `time_received`. Include `AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)` in any SQL example on this page if you copy it. MQL queries are not affected. Tracked as APP-10891.
+{{< /alert >}}
+
+**Common data structures:**
+
+{{< tabs >}}
+{{% tab name="Sensor (Readings)" %}}
+
+Keys inside `data.readings` are whatever your sensor returns. Each sensor is different.
+
+```json
+{
+  "readings": {
+    "temperature": 23.5,
+    "humidity": 61.2
+  }
+}
+```
+
+To query: `data.readings.temperature`
+
+Example:
+
+```sql
+SELECT time_received,
+  data.readings.temperature AS temp,
+  data.readings.humidity AS humidity
+FROM readings
+WHERE component_name = 'my-sensor'
+  AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)
+ORDER BY time_received DESC
+LIMIT 10
+```
+
+{{% /tab %}}
+{{% tab name="Vision service (CaptureAllFromCamera)" %}}
+
+Detections include bounding box coordinates and confidence scores.
+
+```json
+{
+  "detections": [
+    {
+      "class_name": "person",
+      "confidence": 0.94,
+      "x_min": 120,
+      "y_min": 50,
+      "x_max": 340,
+      "y_max": 480
+    }
+  ]
+}
+```
+
+To query detections, use MQL since SQL cannot easily traverse arrays:
+
+```json
+[
+  { "$match": { "component_name": "my-vision" } },
+  { "$unwind": "$data.detections" },
+  { "$match": { "data.detections.confidence": { "$gt": 0.8 } } },
+  {
+    "$project": {
+      "class": "$data.detections.class_name",
+      "confidence": "$data.detections.confidence",
+      "time": "$time_received"
+    }
+  }
+]
+```
+
+{{% /tab %}}
+{{% tab name="Motor (Position)" %}}
+
+```json
+{
+  "position": 145.7
+}
+```
+
+To query: `data.position`
+
+{{% /tab %}}
+{{% tab name="Encoder (Position)" %}}
+
+```json
+{
+  "position": 12450,
+  "position_type": 1
+}
+```
+
+To query: `data.position`
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Finding the structure of your data
+
+If you're unsure what fields your component produces:
+
+1. Run the following to see what components have captured data:
+
+   ```sql
+   SELECT DISTINCT component_name FROM readings
+   WHERE time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)
+   ```
+
+2. Pick one and run the following:
+
+   ```sql
+   SELECT data FROM readings
+   WHERE component_name = 'YOUR-COMPONENT'
+     AND time_received >= CAST('2000-01-01T00:00:00.000Z' AS TIMESTAMP)
+   LIMIT 1
+   ```
+
+3. Look at the JSON structure in the result. The keys you see are the fields you can query with dot notation.
+4. Build your query using `data.` followed by the path to the field you want (for example, `data.readings.temperature`).
diff --git a/docs/data/sync-data-to-your-database.md b/docs/data/sync-data-to-your-database.md
new file mode 100644
index 0000000000..5a20a3bd23
--- /dev/null
+++ b/docs/data/sync-data-to-your-database.md
@@ -0,0 +1,741 @@
+---
+linkTitle: "Sync to your database"
+title: "Sync data to your database"
+weight: 42
+layout: "docs"
+type: "docs"
+description: "Use Viam as an ingestion layer and sync captured data to your own MongoDB database."
+date: "2025-01-30"
+aliases:
+  - /data/export/sync-data-to-your-database/
+  - /data/sync-data-to-your-database/
+  - /build/data/sync-data-to-your-database/
+  - /data/capture-sync/direct-mongodb-capture/
+---
+
+Integrate Viam's captured data with your own database or data infrastructure. This is useful when compliance requires you to control where data resides, when you already have a MongoDB cluster with dashboards and pipelines built on it, or when you want to reduce dependency on any single vendor at the storage layer.
+
+Viam handles reliable machine-to-cloud transport. Your database handles long-term storage, retention, access control, and downstream analytics.
+
+## Choose an approach
+
+| Pattern                   | Mechanism                       | Latency   | Best For                                 |
+| ------------------------- | ------------------------------- | --------- | ---------------------------------------- |
+| API/SDK queries           | Pull from Viam programmatically | On-demand | Dashboards, bulk export, ad-hoc analysis |
+| CLI export                | Batch download to local files   | Manual    | One-time migration, backups              |
+| Direct MongoDB connection | Query through connection URI    | On-demand | External tools, custom sync scripts      |
+
+### Viam as ingestion layer
+
+In this architecture, Viam handles everything from the machine to the cloud:
+data capture on the machine, local buffering when connectivity drops, and
+reliable sync to Viam's cloud storage. Your infrastructure takes over from
+there. A sync script or direct connection pulls data from Viam and writes it to
+your database. Your team manages retention, access control, roll-ups, and
+downstream consumers against your own cluster.
+
+## Steps
+
+### 1. Configure database access credentials
+
+Viam provides a MongoDB Atlas Data Federation interface to your captured data.
+Before you can connect, you need to set up credentials.
+
+1. Log in to the Viam CLI:
+
+   ```sh
+   viam login
+   ```
+
+2. Find your organization ID:
+
+   ```sh
+   viam organizations list
+   ```
+
+   Copy the ID for the organization whose data you want to access.
+
+3. Configure a database password for your organization. This creates a
+   database user tied to your organization:
+
+   ```sh
+   viam data database configure --org-id=<YOUR-ORG-ID> --password=<NEW-PASSWORD>
+   ```
+
+   Choose a strong password. You will use it in connection URIs and scripts.
+
+4. Retrieve the connection hostname:
+
+   ```sh
+   viam data database hostname --org-id=<YOUR-ORG-ID>
+   ```
+
+   The output includes the hostname and a connection URI. Save both values.
+
+### 2. Connect to your data with mongosh
+
+With credentials configured, you can connect to your Viam data using any
+MongoDB client. This step uses `mongosh` (the MongoDB shell) to verify the
+connection and explore your data interactively.
+
+1. Install `mongosh` if you do not have it:
+
+   ```sh
+   brew install mongosh
+   ```
+
+   On Linux, follow the [mongosh installation guide](https://www.mongodb.com/docs/mongodb-shell/install/).
+
+2. Connect using the connection URI from step 1:
+
+   ```sh
+   mongosh "mongodb://db-user-<YOUR-ORG-ID>:<PASSWORD>@<HOSTNAME>/?ssl=true&authSource=admin"
+   ```
+
+   Replace `<YOUR-ORG-ID>`, `<PASSWORD>`, and `<HOSTNAME>` with your values.
+
+3. Switch to the sensor data database:
+
+   ```text
+   use sensorData
+   ```
+
+4. List available collections:
+
+   ```text
+   show collections
+   ```
+
+   You should see a `readings` collection containing your captured tabular data.
+
+5. Query a few documents to verify:
+
+   ```text
+   db.readings.find().sort({time_received: -1}).limit(5)
+   ```
+
+This connection URI works with any MongoDB-compatible tool: Compass, Studio 3T,
+database drivers in any language, or your own applications.
+
+### 3. Export data with the CLI
+
+For one-time exports, backups, or migration, the Viam CLI provides bulk export
+commands.
+
+**Export tabular data (sensor readings):**
+
+Tabular export requires you to specify the exact part, resource, and method:
+
+```sh
+viam data export tabular \
+  --part-id=<YOUR-PART-ID> \
+  --resource-name=my-sensor \
+  --resource-subtype=sensor \
+  --method=Readings \
+  --destination=./export
+```
+
+You can add time filters to narrow the export:
+
+```sh
+viam data export tabular \
+  --part-id=<YOUR-PART-ID> \
+  --resource-name=my-sensor \
+  --resource-subtype=sensor \
+  --method=Readings \
+  --start=2025-01-01T00:00:00Z \
+  --end=2025-02-01T00:00:00Z \
+  --destination=./january-export
+```
+
+**Export binary data (images, point clouds):**
+
+Binary export supports broad filtering by organization, location, or machine:
+
+```sh
+viam data export binary filter --org-ids=<YOUR-ORG-ID> --destination=./export
+```
+
+Once exported, you can load these files into your own database, convert them to
+CSV for analysis tools, or archive them for compliance.
+
+### 4. Pull data programmatically
+
+For automated workflows, use the Viam SDK to query data from Viam and write it
+directly to your own MongoDB cluster.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+Install dependencies:
+
+```sh
+pip install viam-sdk pymongo
+```
+
+Save this as `sync_to_db.py`:
+
+```python
+import asyncio
+from viam.rpc.dial import DialOptions, Credentials
+from viam.app.viam_client import ViamClient
+from pymongo import MongoClient
+
+
+API_KEY = "<your-api-key>"
+API_KEY_ID = "<your-api-key-id>"
+ORG_ID = "<your-org-id>"
+
+# Your own MongoDB cluster.
+MY_MONGO_URI = "mongodb+srv://user:pass@your-cluster.mongodb.net/"
+MY_DB_NAME = "my_robot_data"
+MY_COLLECTION_NAME = "sensor_readings"
+
+
+async def connect() -> ViamClient:
+    dial_options = DialOptions(
+        credentials=Credentials(
+            type="api-key",
+            payload=API_KEY,
+        ),
+        auth_entity=API_KEY_ID,
+    )
+    return await ViamClient.create_from_dial_options(dial_options)
+
+
+async def main():
+    # Connect to Viam.
+    viam_client = await connect()
+    data_client = viam_client.data_client
+
+    # Query recent data from Viam.
+    data = await data_client.tabular_data_by_mql(
+        organization_id=ORG_ID,
+        mql_binary=[
+            {"$match": {
+                "component_name": "my-sensor",
+                "time_received": {
+                    "$gte": {"$date": "2025-01-01T00:00:00Z"},
+                },
+            }},
+            {"$sort": {"time_received": 1}},
+            {"$limit": 1000},
+        ],
+    )
+
+    print(f"Pulled {len(data)} records from Viam.")
+
+    # Connect to your own database and insert.
+    my_client = MongoClient(MY_MONGO_URI)
+    my_db = my_client[MY_DB_NAME]
+    my_collection = my_db[MY_COLLECTION_NAME]
+
+    inserted = 0
+    for record in data:
+        my_collection.insert_one(record)
+        inserted += 1
+
+    print(f"Inserted {inserted} records into {MY_DB_NAME}.{MY_COLLECTION_NAME}.")
+
+    my_client.close()
+    viam_client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```sh
+python sync_to_db.py
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+Install dependencies:
+
+```sh
+mkdir sync-data && cd sync-data
+go mod init sync-data
+go get go.viam.com/rdk
+go get go.mongodb.org/mongo-driver/mongo
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.mongodb.org/mongo-driver/mongo"
+    "go.mongodb.org/mongo-driver/mongo/options"
+    "go.viam.com/rdk/app"
+    "go.viam.com/rdk/logging"
+)
+
+func main() {
+    apiKey := "YOUR-API-KEY"
+    apiKeyID := "YOUR-API-KEY-ID"
+    orgID := "YOUR-ORGANIZATION-ID"
+    myMongoURI := "mongodb+srv://user:pass@your-cluster.mongodb.net/"
+
+    ctx := context.Background()
+    logger := logging.NewDebugLogger("sync-data")
+
+    // Connect to Viam.
+    viamClient, err := app.CreateViamClientWithAPIKey(
+        ctx, app.Options{}, apiKey, apiKeyID, logger)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer viamClient.Close()
+
+    dataClient := viamClient.DataClient()
+
+    // Query recent data from Viam.
+    mqlStages := []map[string]interface{}{
+        {"$match": map[string]interface{}{
+            "component_name": "my-sensor",
+            "time_received": map[string]interface{}{
+                "$gte": map[string]interface{}{
+                    "$date": "2025-01-01T00:00:00Z",
+                },
+            },
+        }},
+        {"$sort": map[string]interface{}{"time_received": 1}},
+        {"$limit": 1000},
+    }
+    tabularData, err := dataClient.TabularDataByMQL(ctx, orgID, mqlStages, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    fmt.Printf("Pulled %d records from Viam.\n", len(tabularData))
+
+    // Connect to your own MongoDB cluster.
+    mongoClient, err := mongo.Connect(ctx,
+        options.Client().ApplyURI(myMongoURI))
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer mongoClient.Disconnect(ctx)
+
+    collection := mongoClient.Database("my_robot_data").Collection("sensor_readings")
+
+    inserted := 0
+    for _, record := range tabularData {
+        _, err := collection.InsertOne(ctx, record)
+        if err != nil {
+            logger.Errorf("failed to insert record: %v", err)
+            continue
+        }
+        inserted++
+    }
+
+    fmt.Printf("Inserted %d records into my_robot_data.sensor_readings.\n", inserted)
+}
+```
+
+Run it:
+
+```sh
+go run main.go
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+{{< readfile "/static/include/how-to/get-credentials.md" >}}
+
+### 5. Build an ongoing sync script
+
+A one-time pull is useful, but most teams need ongoing sync. The key is tracking
+the last sync timestamp so each run only pulls new data.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+Save this as `ongoing_sync.py`:
+
+```python
+import asyncio
+import json
+import os
+from datetime import datetime, timezone
+
+from viam.rpc.dial import DialOptions, Credentials
+from viam.app.viam_client import ViamClient
+from pymongo import MongoClient
+
+
+API_KEY = "<your-api-key>"
+API_KEY_ID = "<your-api-key-id>"
+ORG_ID = "<your-org-id>"
+MY_MONGO_URI = "mongodb+srv://user:pass@your-cluster.mongodb.net/"
+MY_DB_NAME = "my_robot_data"
+MY_COLLECTION_NAME = "sensor_readings"
+
+# File to persist the last sync timestamp between runs.
+STATE_FILE = "sync_state.json"
+
+
+def load_last_sync_time() -> str:
+    """Load the last sync timestamp from the state file."""
+    if os.path.exists(STATE_FILE):
+        with open(STATE_FILE, "r") as f:
+            state = json.load(f)
+            return state.get("last_sync_time", "2000-01-01T00:00:00Z")
+    return "2000-01-01T00:00:00Z"
+
+
+def save_last_sync_time(timestamp: str) -> None:
+    """Save the last sync timestamp to the state file."""
+    with open(STATE_FILE, "w") as f:
+        json.dump({"last_sync_time": timestamp}, f)
+
+
+async def connect() -> ViamClient:
+    dial_options = DialOptions(
+        credentials=Credentials(
+            type="api-key",
+            payload=API_KEY,
+        ),
+        auth_entity=API_KEY_ID,
+    )
+    return await ViamClient.create_from_dial_options(dial_options)
+
+
+async def sync_once():
+    last_sync = load_last_sync_time()
+    print(f"Syncing data received after {last_sync}")
+
+    viam_client = await connect()
+    data_client = viam_client.data_client
+
+    # Pull only data received since the last sync.
+    data = await data_client.tabular_data_by_mql(
+        organization_id=ORG_ID,
+        mql_binary=[
+            {"$match": {
+                "time_received": {
+                    "$gt": {"$date": last_sync},
+                },
+            }},
+            {"$sort": {"time_received": 1}},
+            {"$limit": 5000},
+        ],
+    )
+
+    if not data:
+        print("No new data to sync.")
+        viam_client.close()
+        return
+
+    print(f"Pulled {len(data)} new records.")
+
+    # Insert into your database.
+    my_client = MongoClient(MY_MONGO_URI)
+    my_db = my_client[MY_DB_NAME]
+    my_collection = my_db[MY_COLLECTION_NAME]
+
+    latest_time = last_sync
+    inserted = 0
+    for record in data:
+        my_collection.insert_one(record)
+        inserted += 1
+        # Track the most recent timestamp.
+        record_time = record.get("time_received", "")
+        if hasattr(record_time, "isoformat"):
+            record_time = record_time.isoformat()
+        if str(record_time) > latest_time:
+            latest_time = str(record_time)
+
+    # Persist the latest timestamp for the next run.
+    save_last_sync_time(latest_time)
+    print(f"Inserted {inserted} records. Last sync time: {latest_time}")
+
+    my_client.close()
+    viam_client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(sync_once())
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "encoding/json"
+    "fmt"
+    "os"
+    "time"
+
+    "go.mongodb.org/mongo-driver/mongo"
+    "go.mongodb.org/mongo-driver/mongo/options"
+    "go.viam.com/rdk/app"
+    "go.viam.com/rdk/logging"
+)
+
+const stateFile = "sync_state.json"
+
+type syncState struct {
+    LastSyncTime string `json:"last_sync_time"`
+}
+
+func loadLastSyncTime() string {
+    data, err := os.ReadFile(stateFile)
+    if err != nil {
+        return "2000-01-01T00:00:00Z"
+    }
+    var state syncState
+    if err := json.Unmarshal(data, &state); err != nil {
+        return "2000-01-01T00:00:00Z"
+    }
+    return state.LastSyncTime
+}
+
+func saveLastSyncTime(t string) error {
+    data, err := json.Marshal(syncState{LastSyncTime: t})
+    if err != nil {
+        return err
+    }
+    return os.WriteFile(stateFile, data, 0644)
+}
+
+func main() {
+    apiKey := "YOUR-API-KEY"
+    apiKeyID := "YOUR-API-KEY-ID"
+    orgID := "YOUR-ORGANIZATION-ID"
+    myMongoURI := "mongodb+srv://user:pass@your-cluster.mongodb.net/"
+
+    ctx := context.Background()
+    logger := logging.NewDebugLogger("sync-data")
+
+    lastSync := loadLastSyncTime()
+    fmt.Printf("Syncing data received after %s\n", lastSync)
+
+    // Connect to Viam.
+    viamClient, err := app.CreateViamClientWithAPIKey(
+        ctx, app.Options{}, apiKey, apiKeyID, logger)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer viamClient.Close()
+
+    dataClient := viamClient.DataClient()
+
+    // Pull only data received since the last sync.
+    mqlStages := []map[string]interface{}{
+        {"$match": map[string]interface{}{
+            "time_received": map[string]interface{}{
+                "$gt": map[string]interface{}{
+                    "$date": lastSync,
+                },
+            },
+        }},
+        {"$sort": map[string]interface{}{"time_received": 1}},
+        {"$limit": 5000},
+    }
+    tabularData, err := dataClient.TabularDataByMQL(ctx, orgID, mqlStages, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    if len(tabularData) == 0 {
+        fmt.Println("No new data to sync.")
+        return
+    }
+
+    fmt.Printf("Pulled %d new records.\n", len(tabularData))
+
+    // Connect to your own MongoDB cluster.
+    mongoClient, err := mongo.Connect(ctx,
+        options.Client().ApplyURI(myMongoURI))
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer mongoClient.Disconnect(ctx)
+
+    collection := mongoClient.Database("my_robot_data").Collection("sensor_readings")
+
+    latestTime := lastSync
+    inserted := 0
+    for _, record := range tabularData {
+        _, err := collection.InsertOne(ctx, record)
+        if err != nil {
+            logger.Errorf("failed to insert record: %v", err)
+            continue
+        }
+        inserted++
+
+        // Track the most recent timestamp.
+        if tr, ok := record["time_received"]; ok {
+            var ts string
+            switch v := tr.(type) {
+            case time.Time:
+                ts = v.Format(time.RFC3339)
+            case string:
+                ts = v
+            }
+            if ts > latestTime {
+                latestTime = ts
+            }
+        }
+    }
+
+    // Persist the latest timestamp for the next run.
+    if err := saveLastSyncTime(latestTime); err != nil {
+        logger.Errorf("failed to save sync state: %v", err)
+    }
+
+    fmt.Printf("Inserted %d records. Last sync time: %s\n", inserted, latestTime)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+#### Run on a schedule
+
+Run the sync script on a schedule using cron (Linux/macOS) or Task Scheduler
+(Windows). For example, to sync every 15 minutes:
+
+```sh
+crontab -e
+```
+
+Add this line (adjust the path to your script):
+
+```text
+*/15 * * * * cd /path/to/sync-data && python ongoing_sync.py >> sync.log 2>&1
+```
+
+For the Go version, compile first and run the binary:
+
+```sh
+go build -o sync-data .
+```
+
+```text
+*/15 * * * * cd /path/to/sync-data && ./sync-data >> sync.log 2>&1
+```
+
+## Try It
+
+1. **Configure credentials.** Run the CLI commands from step 1 to set up
+   database access. Verify you get a hostname and connection URI back.
+
+2. **Connect with mongosh.** Use the connection URI to connect and run
+   `db.readings.find().limit(3)` in the `sensorData` database. Verify you see
+   your captured data.
+
+3. **Export with the CLI.** Run `viam data export tabular filter
+--org-ids=<YOUR-ORG-ID> --destination=./test-export` and confirm files
+   appear in the `./test-export/data/` directory.
+
+4. **Run the one-time sync script.** Copy the Python or Go script from step 4,
+   fill in your credentials and MongoDB URI, and run it. Verify records appear
+   in your destination database.
+
+5. **Run the ongoing sync script twice.** Run the sync script from step 5. Note
+   the count of inserted records. Wait for new data to be captured by your
+   machine, then run it again. The second run should only pull data received
+   after the first run's latest timestamp.
+
+## Troubleshooting
+
+{{< expand "viam data database configure fails" >}}
+
+- Verify you are logged in: run `viam login` first.
+- Verify the organization ID is correct: run `viam organizations list` and
+  copy the exact ID.
+- The password must meet minimum complexity requirements. Use at least 8
+  characters with a mix of letters, numbers, and symbols.
+
+{{< /expand >}}
+
+{{< expand "mongosh connection times out" >}}
+
+- Verify the hostname is correct. Copy it exactly from the output of
+  `viam data database hostname`.
+- Ensure your network allows outbound connections on port 27017.
+- Check that `ssl=true` and `authSource=admin` are both present in the
+  connection URI. Without SSL, the connection will be rejected.
+- If you are behind a corporate firewall or VPN, you may need to allowlist the
+  Data Federation hostname.
+
+{{< /expand >}}
+
+{{< expand "Query returns empty results" >}}
+
+- Verify data has been captured and synced. Check the **DATA** tab in the Viam
+  app to confirm entries are visible.
+- If filtering by `component_name`, confirm the name matches exactly
+  (case-sensitive). Run a query without the component filter first to see what
+  data exists.
+- If filtering by time, make sure the time range covers a period when data was
+  actually captured.
+
+{{< /expand >}}
+
+{{< expand "Authentication error in Python or Go script" >}}
+
+- Verify your API key and API key ID are both correct. These are two separate
+  values. The API key is the secret; the API key ID identifies which key is
+  being used.
+- Verify your organization ID. Find it in the Viam app under **Settings** in
+  the left navigation. It is a UUID, not your organization name.
+- Check that the API key has data access permissions.
+
+{{< /expand >}}
+
+{{< expand "Duplicate records in destination database" >}}
+
+- The sync scripts do not deduplicate by default. If a run is
+  interrupted and restarted, some records may be inserted twice.
+- To prevent duplicates, create a unique index on your destination collection
+  using a combination of `time_received`, `component_name`, and `robot_id`:
+
+  ```text
+  db.sensor_readings.createIndex(
+    {time_received: 1, component_name: 1, robot_id: 1},
+    {unique: true}
+  )
+  ```
+
+- Then change `insert_one` to use `update_one` with `upsert=True` (Python) or
+  `ReplaceOne` with `Upsert` (Go) to skip duplicates gracefully.
+
+{{< /expand >}}
+
+{{< expand "CLI export is slow or incomplete" >}}
+
+- Large exports download files in parallel, but total time depends on data
+  volume and network speed.
+- If the export is interrupted, re-run the same command. The CLI resumes where
+  it left off.
+- Use time range filters (`--start`, `--end`) to break large exports into
+  smaller chunks.
+
+{{< /expand >}}
+
+## What's next
+
+- [Data pipelines](/data/pipelines/create-a-pipeline/) -- set up
+  windowed roll-ups and derived metrics to reduce data volume before syncing.
+- [Visualize Data](/data/visualize-data/) -- connect Grafana or other
+  dashboard tools to your Viam data using the MongoDB connection URI.
+- [Query Data](/data/query-data/) -- write advanced SQL and MQL queries
+  against your data in Viam's cloud before pulling it to your own systems.
diff --git a/docs/data-ai/data/alert-data.md b/docs/data/trigger-on-data.md
similarity index 53%
rename from docs/data-ai/data/alert-data.md
rename to docs/data/trigger-on-data.md
index aba03ff0be..6ac3d16dca 100644
--- a/docs/data-ai/data/alert-data.md
+++ b/docs/data/trigger-on-data.md
@@ -1,22 +1,31 @@
 ---
-linkTitle: "Trigger on data events"
+linkTitle: "Trigger on events"
 title: "Trigger on data events"
-weight: 200
+weight: 55
 layout: "docs"
 type: "docs"
 description: "Use triggers to send email notifications or webhook requests when data from the machine is synced."
 date: "2025-09-12"
 aliases:
-  - /data-ai/data/advanced/alert-data/
 ---
 
-You can use triggers to send webhooks or email alerts when data syncs from a machine.
-For example, a trigger could alert you when a sensor detects a temperature greater than 100 degrees Celsius.
+Get alerted when your robot's data meets a condition. Triggers send webhooks or email notifications when events occur on a machine, so you can respond to temperature spikes, low battery, detection results, or connectivity changes without polling.
 
-You can configure triggers to fire in the following scenarios:
+Triggers are configured in the machine's config and are scoped to that machine. Each trigger fires when its event occurs on the specific machine it is configured on.
 
-- **Data has been synced to the cloud**: fire when any data syncs from the machine
-- **Conditional data ingestion**: fire any time synced data meets a specified condition
+## Trigger types
+
+Viam supports five trigger types:
+
+| Type                       | Event JSON value            | Fires when                                                                |
+| -------------------------- | --------------------------- | ------------------------------------------------------------------------- |
+| Data synced                | `part_data_ingested`        | Any data syncs from the machine to the cloud.                             |
+| Conditional data ingestion | `conditional_data_ingested` | Synced data meets a specified condition (key, operator, value).           |
+| Part online                | `part_online`               | The machine part comes online.                                            |
+| Part offline               | `part_offline`              | The machine part goes offline.                                            |
+| Conditional logs ingestion | `conditional_logs_ingested` | Machine logs contain errors, warnings, or info messages (checked hourly). |
+
+For the full attribute reference for all trigger types, see [Trigger configuration](/reference/triggers/).
 
 ## Configure a trigger
 
@@ -47,7 +56,7 @@ You can configure triggers to fire in the following scenarios:
 
         To see the data your components are returning, use each component's **TEST** panel.
 
-        For more information about conditional attributes, see [Conditional attributes](/data-ai/reference/triggers-configuration/#conditional-attributes).
+        For a full reference of trigger configuration attributes, see [Trigger configuration](/reference/triggers/).
 
 1. Next, configure what should happen when an event occurs.
    You can add **Webhooks** and **Email** notifications:
@@ -57,9 +66,8 @@ You can configure triggers to fire in the following scenarios:
    1. Click **Add Webhook**.
    1. Add the URL of your cloud function.
    1. Configure the time between notifications.
-   1. Write your cloud function to process the [webhook](/data-ai/reference/triggers-configuration/#webhook-attributes).
+   1. Write your cloud function to process the webhook payload.
       Use your cloud function to process data or interact with external APIs, such as Twilio, PagerDuty, or Zapier.
-      For an example function, see [Example cloud function](/data-ai/reference/triggers-configuration/#example-cloud-function).
 
    To add an email notification for specific email addresses:
 
@@ -114,7 +122,7 @@ The following JSON configuration shows how to set up a trigger that fires when a
       "event": {
         "type": "part_data_ingested",
         "data_ingested": {
-          "data_types": ["binary", "tabular", "file"]
+          "data_types": ["binary", "tabular", "file", "unspecified"]
         }
       },
       "notifications": [
@@ -134,7 +142,23 @@ The following JSON configuration shows how to set up a trigger that fires when a
 }
 ```
 
-For more information about triggers, see [Trigger Configuration](/data-ai/reference/triggers-configuration/).
+For more information about triggers, see [Trigger Configuration](/reference/triggers/).
 
 {{% /tab %}}
 {{< /tabs >}}
+
+## Webhook payload
+
+When a trigger fires and sends a webhook, the HTTP request includes identifying headers (`Org-Id`, `Location-Id`, `Part-Id`, `Robot-Id`) and a JSON body with details about the event. For data triggers (`part_data_ingested`, `conditional_data_ingested`), the body includes the component name, method, timestamps, and the ingested data. For status triggers (`part_online`, `part_offline`), the request is a GET with metadata in headers only.
+
+For the full header and body reference, see [Webhook attributes](/reference/triggers/#webhook-attributes). For example cloud functions that process the payload, see [Example cloud function](/reference/triggers/#example-cloud-function).
+
+## Notification frequency
+
+The `seconds_between_notifications` field sets the minimum time between notifications for the same trigger. If a trigger fires more frequently than this interval, additional notifications are suppressed until the interval has elapsed. To avoid floods of notifications, set the interval to a value appropriate for your use case (for example, 3600 to allow at most one alert per hour). For `conditional_logs_ingested` triggers, the check interval is always one hour regardless of this setting.
+
+## Machine telemetry triggers
+
+The **Part online**, **Part offline**, and **Conditional logs ingestion** triggers are primarily used for machine health monitoring rather than data analysis. For step-by-step setup of these trigger types, see [Alert on machine telemetry](/monitor/alert/).
+
+For the full attribute reference for all trigger types, see [Trigger configuration](/reference/triggers/).
diff --git a/docs/data/visualize-data.md b/docs/data/visualize-data.md
new file mode 100644
index 0000000000..4de08951e2
--- /dev/null
+++ b/docs/data/visualize-data.md
@@ -0,0 +1,613 @@
+---
+linkTitle: "Visualize data"
+title: "Visualize data"
+weight: 50
+layout: "docs"
+type: "docs"
+description: "Build dashboards with Teleop, Grafana, or programmatic charts to visualize captured data."
+date: "2025-01-30"
+aliases:
+  - /build/data/visualize-data/
+  - /data-ai/data/visualize/
+  - /use-cases/sensor-data-visualize/
+  - /how-tos/sensor-data-visualize/
+  - /how-tos/configure-teleop-workspace/
+  - /tutorials/services/visualize-data-grafana/
+  - /data/debug-and-trace/
+---
+
+Build dashboards and monitoring views for your captured data. Visualization helps you spot trends, detect anomalies, and monitor machine health.
+
+Viam stores captured data in a MongoDB Atlas Data Federation instance. This
+means that you can use any tool that can connect to MongoDB to access your data. This page covers four approaches to visualization, from simplest to most
+flexible.
+
+| Approach                                                  | Best for                                         | Setup time    |
+| --------------------------------------------------------- | ------------------------------------------------ | ------------- |
+| Viam Teleop dashboard                                     | Quick monitoring, camera feeds, live sensor data | 2 minutes     |
+| Grafana                                                   | Rich dashboards, alerting, team-shared views     | 10 minutes    |
+| Other third-party tools (Tableau, Looker Studio)          | BI reporting, executive dashboards               | 10-15 minutes |
+| Custom with Viam SDKs (Python/Go + matplotlib or similar) | Custom reports, embedded charts, notebooks       | 5 minutes     |
+
+Viam Teleop dashboards live inside the Viam app. They are scoped to a single machine
+and location, and they update in real time. You do not need to configure any
+database credentials or install any software. This makes them the right choice
+when you want a quick operational view of one machine.
+
+External tools like Grafana connect to the underlying MongoDB data store. They
+can query data across machines and organizations, apply complex transformations,
+set up alerts, and share dashboards with team members who do not have Viam app
+access.
+
+Custom visualization with Viam SDKs gives you complete control. You write code that
+queries data through the Viam SDK and renders it however you want -- matplotlib
+charts, Plotly dashboards, HTML reports, or any other format.
+
+## Build a Viam Teleop dashboard
+
+The Viam Teleop dashboard is the fastest way to visualize data from a single machine.
+
+### Create a workspace
+
+1. Go to [app.viam.com](https://app.viam.com).
+2. Click **FLEET** in the top navigation, then click the **TELEOP** tab. You
+   can also navigate directly to [app.viam.com/teleop](https://app.viam.com/teleop).
+3. Click **+ Create workspace**.
+4. In the top left of the page, replace the placeholder `untitled-workspace`
+   text with a descriptive name for your workspace (for example, "Sensor Monitor" or
+   "Factory Floor Cameras").
+5. Use the **Select location** dropdown to choose the location that contains
+   your machine.
+6. Use the **Select machine** dropdown to choose the machine you want to
+   visualize data from.
+
+### Add widgets
+
+1. Click **Add widget** and select a widget type. Available widget types include:
+
+   - **Time-series chart** -- plots sensor values over time.
+   - **Camera feed** -- shows a live camera stream.
+   - **Value display** -- shows the current reading from a sensor.
+   - **Button** -- triggers an action on the machine.
+
+   Additional widget types may be available depending on your machine's components.
+
+2. To configure a widget, click the **pencil icon** in the top right corner of
+   the widget. This opens the widget settings where you select which component
+   and data source the widget displays.
+
+   {{<imgproc src="/services/data/visualize-widget-configure.png" alt="Click the pencil icon to configure your widget." style="width:500px" resize="1200x" class="imgzoom fill shadow" >}}
+
+3. Repeat for each widget you want on the dashboard. You can mix camera feeds,
+   time-series charts, and value displays on the same workspace.
+
+   {{<imgproc src="/services/data/visualize-workspace.png" resize="1200x" style="width: 700px" class="fill imgzoom shadow" declaredimensions=true alt="Workspace containing multiple widgets displaying sensor data visualizations.">}}
+
+### Arrange the layout
+
+- Click and drag the **grid icon** in the top left corner of any widget to reposition it.
+- Resize widgets by dragging their edges.
+- The layout saves automatically.
+
+You now have a live dashboard showing real-time data from your machine. The
+dashboard updates as new data arrives -- no refresh needed.
+
+## Configure database access for third-party tools
+
+To connect external visualization tools (Grafana, Tableau, Looker Studio, or
+any MongoDB-compatible client), you first need to set up database credentials
+using the Viam CLI.
+
+Install the Viam CLI if you have not already:
+
+{{< readfile "/static/include/how-to/install-cli.md" >}}
+
+{{< readfile "/static/include/how-to/query-data.md" >}}
+
+You now have three pieces of information needed by any external tool:
+
+- **Hostname** (from the `hostname` command)
+- **Username**: `db-user-<YOUR-ORG-ID>`
+- **Password** (from the `configure` command)
+
+## Connect Grafana to your data
+
+Grafana is a popular open-source visualization tool that works well with Viam's
+MongoDB-backed data store.
+
+### Install Grafana
+
+If you do not already have a Grafana instance:
+
+- **Grafana Cloud**: Sign up at [grafana.com](https://grafana.com). The free
+  tier is sufficient for testing.
+- **Local Grafana Enterprise**: Install following the [official Grafana
+  installation guide](https://grafana.com/docs/grafana/latest/setup-grafana/installation/).
+
+### Install the MongoDB data source plugin
+
+1. Open your Grafana web UI.
+2. Navigate to **Connections > Add new connection**.
+3. Search for **MongoDB**.
+
+   {{<imgproc src="/tutorials/visualize-data-grafana/search-grafana-plugins.png" resize="800x" style="width: 500px" declaredimensions=true alt="The Grafana plugin search interface showing the results for a search for mongodb" class="shadow imgzoom" >}}
+
+4. Install the **Grafana MongoDB data source** plugin.
+
+{{< alert title="Important" color="caution" >}}
+
+Install the MongoDB **data source**, not the MongoDB **integration**. They are
+different plugins. The data source is what allows you to query MongoDB from
+Grafana dashboards.
+
+If the MongoDB data source does not appear in the plugin catalog, install it from the [Grafana MongoDB data source plugin page](https://grafana.com/grafana/plugins/grafana-mongodb-datasource/) using the installation instructions for your Grafana deployment type.
+
+{{< /alert >}}
+
+### Configure the data connection
+
+1. After installing the plugin, go to its configuration page and click
+   **Add new data source**.
+2. Fill in the following fields:
+
+   - **Connection string**:
+
+     ```text
+     mongodb://<HOSTNAME>/sensorData?directConnection=true&authSource=admin&tls=true
+     ```
+
+     Replace `<HOSTNAME>` with the hostname from [Configure database access](#configure-database-access-for-third-party-tools).
+
+   - **User**: `db-user-<YOUR-ORG-ID>`
+
+   - **Password**: The password you set with the
+     `viam data database configure` command.
+
+   {{<imgproc src="/tutorials/visualize-data-grafana/configure-grafana-mongodb-datasource.png" resize="800x" style="width: 500px" declaredimensions=true alt="The Grafana data source plugin configuration page, showing the connection string and username filled in" class="shadow imgzoom" >}}
+
+   For more information on the Grafana MongoDB plugin, see [Configure the MongoDB data source](https://grafana.com/docs/plugins/grafana-mongodb-datasource/latest/configure/).
+
+3. Click **Save & test**. Grafana should confirm the connection is working.
+
+### Build a Grafana dashboard
+
+1. Click **Dashboards** in the left sidebar, then **New > New dashboard**.
+2. Click **Add visualization**.
+3. Select the MongoDB data source you just configured.
+4. In the query editor, enter an MQL query. For example, to plot sensor readings
+   over time:
+
+   ```mql
+   sensorData.readings.aggregate([
+     {
+       $match: {
+         component_name: "sensor-1",
+         time_received: { $gte: ISODate(${__from}) }
+       }
+     },
+     { $sort: { time_received: 1 } },
+     { $limit: 1000 }
+   ])
+   ```
+
+   Replace `sensor-1` with the name of your component.
+
+   The `${__from}` and `${__to}` variables are [Grafana global variables](https://grafana.com/docs/grafana/latest/dashboards/variables/add-template-variables/#global-variables) populated by the time range selector at the top of your dashboard.
+   When you change the time range, the query updates automatically.
+
+5. Click **Run query** to see results.
+6. Choose a visualization type (Time series, Gauge, Stat, Table, etc.) from the
+   panel options on the right.
+7. Click **Apply** to add the panel to your dashboard.
+
+### Useful query patterns for Grafana
+
+Average sensor value per hour:
+
+```mql
+sensorData.readings.aggregate([
+  {
+    $match: {
+      component_name: "my-sensor",
+      time_received: { $gte: ISODate(${__from}), $lte: ISODate(${__to}) }
+    }
+  },
+  {
+    $group: {
+      _id: {
+        $dateToString: { format: "%Y-%m-%d %H:00", date: "$time_received" }
+      },
+      avg_value: { $avg: "$data.readings.temperature" },
+      count: { $sum: 1 }
+    }
+  },
+  { $sort: { _id: 1 } }
+])
+```
+
+Count of readings per component:
+
+```mql
+sensorData.readings.aggregate([
+  {
+    $match: {
+      time_received: { $gte: ISODate(${__from}) }
+    }
+  },
+  {
+    $group: {
+      _id: "$component_name",
+      count: { $sum: 1 }
+    }
+  },
+  { $sort: { count: -1 } }
+])
+```
+
+## Connect other third-party tools
+
+The database credentials from [Configure database access](#configure-database-access-for-third-party-tools) work with any tool that supports MongoDB
+Atlas Data Federation as a data store. The general pattern is the same:
+
+1. Install the tool's MongoDB connector or driver. For example:
+
+   - **Tableau** requires the [Atlas SQL JDBC Driver](https://www.mongodb.com/try/download/jdbc-driver) and the [Tableau Connector](https://www.mongodb.com/try/download/tableau-connector).
+   - **Google Looker Studio** supports MongoDB connections natively through community connectors.
+
+2. Configure the connection using one of these formats:
+
+   **Connection URI format** (most tools):
+
+   ```text
+   mongodb://db-user-<YOUR-ORG-ID>:<YOUR-PASSWORD>@<HOSTNAME>/sensorData?tls=true&authSource=admin
+   ```
+
+   **Hostname + credentials format** (tools that ask for fields separately):
+
+   - Hostname: the value from `viam data database hostname`
+   - Database name: `sensorData`
+   - Username: `db-user-<YOUR-ORG-ID>`
+   - Password: from the `configure` command
+
+3. Build dashboards using the tool's native interface.
+
+{{< alert title="Tip" color="tip" >}}
+
+Before building dashboards, use [MongoDB Compass](https://www.mongodb.com/products/tools/compass)
+to browse your data and explore its structure. Compass's [Schema Analyzer](https://www.mongodb.com/docs/compass/current/schema/) shows
+you the fields, types, and value distributions in your data, which helps you
+write accurate queries in your visualization tool.
+
+{{< /alert >}}
+
+## Custom visualizations with Viam SDKs
+
+When you need full control over visualization -- embedding charts in your own
+application, generating reports, or running in a Jupyter notebook -- use the
+Viam SDK to query data and a plotting library to render it.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+Install the dependencies:
+
+```bash
+pip install viam-sdk matplotlib
+```
+
+Save this as `visualize_data.py`:
+
+```python
+import asyncio
+from datetime import datetime, timedelta, timezone
+
+import matplotlib.pyplot as plt
+import matplotlib.dates as mdates
+from viam.rpc.dial import DialOptions, Credentials
+from viam.app.viam_client import ViamClient
+
+
+API_KEY = "YOUR-API-KEY"
+API_KEY_ID = "YOUR-API-KEY-ID"
+ORG_ID = "YOUR-ORGANIZATION-ID"
+
+
+async def connect() -> ViamClient:
+    dial_options = DialOptions(
+        credentials=Credentials(
+            type="api-key",
+            payload=API_KEY,
+        ),
+        auth_entity=API_KEY_ID,
+    )
+    return await ViamClient.create_from_dial_options(dial_options)
+
+
+async def main():
+    viam_client = await connect()
+    data_client = viam_client.data_client
+
+    # Query the last 24 hours of sensor data.
+    data = await data_client.tabular_data_by_mql(
+        organization_id=ORG_ID,
+        query=[
+            {"$match": {
+                "component_name": "my-sensor",
+                "time_received": {
+                    "$gte": {"$date": (
+                        datetime.now(timezone.utc) - timedelta(hours=24)
+                    ).isoformat()}
+                },
+            }},
+            {"$sort": {"time_received": 1}},
+            {"$limit": 1000},
+            {"$project": {
+                "time_received": 1,
+                "temperature": "$data.readings.temperature",
+                "_id": 0,
+            }},
+        ],
+    )
+
+    if not data:
+        print("No data returned. Check your component name and time range.")
+        viam_client.close()
+        return
+
+    # Extract timestamps and values.
+    timestamps = [entry["time_received"] for entry in data]
+    temperatures = [entry["temperature"] for entry in data]
+
+    # Plot the data.
+    fig, ax = plt.subplots(figsize=(12, 5))
+    ax.plot(timestamps, temperatures, linewidth=1.5, color="#3b82f6")
+    ax.set_xlabel("Time")
+    ax.set_ylabel("Temperature")
+    ax.set_title("Sensor Temperature - Last 24 Hours")
+    ax.xaxis.set_major_formatter(mdates.DateFormatter("%H:%M"))
+    ax.grid(True, alpha=0.3)
+    fig.autofmt_xdate()
+    plt.tight_layout()
+
+    # Save to file and show.
+    plt.savefig("temperature_chart.png", dpi=150)
+    print("Chart saved to temperature_chart.png")
+    plt.show()
+
+    viam_client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+{{< readfile "/static/include/how-to/get-credentials.md" >}}
+
+Replace `my-sensor` with your component name. Then run:
+
+```bash
+python visualize_data.py
+```
+
+This produces a time-series chart of temperature readings and saves it as a PNG
+file.
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+Initialize a Go module and install dependencies:
+
+```bash
+mkdir visualize-data && cd visualize-data
+go mod init visualize-data
+go get go.viam.com/rdk
+go get gonum.org/v1/plot
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "time"
+
+    "go.viam.com/rdk/app"
+    "go.viam.com/rdk/logging"
+    "gonum.org/v1/plot"
+    "gonum.org/v1/plot/plotter"
+    "gonum.org/v1/plot/vg"
+)
+
+func main() {
+    apiKey := "YOUR-API-KEY"
+    apiKeyID := "YOUR-API-KEY-ID"
+    orgID := "YOUR-ORGANIZATION-ID"
+
+    ctx := context.Background()
+    logger := logging.NewDebugLogger("visualize-data")
+
+    viamClient, err := app.CreateViamClientWithAPIKey(
+        ctx, app.Options{}, apiKey, apiKeyID, logger)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer viamClient.Close()
+
+    dataClient := viamClient.DataClient()
+
+    // Query the last 24 hours of sensor data.
+    cutoff := time.Now().UTC().Add(-24 * time.Hour)
+    mqlStages := []map[string]interface{}{
+        {"$match": map[string]interface{}{
+            "component_name": "my-sensor",
+            "time_received": map[string]interface{}{
+                "$gte": map[string]interface{}{
+                    "$date": cutoff.Format(time.RFC3339),
+                },
+            },
+        }},
+        {"$sort": map[string]interface{}{"time_received": 1}},
+        {"$limit": 1000},
+        {"$project": map[string]interface{}{
+            "time_received": 1,
+            "temperature":   "$data.readings.temperature",
+            "_id":           0,
+        }},
+    }
+
+    results, err := dataClient.TabularDataByMQL(ctx, orgID, mqlStages, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    if len(results) == 0 {
+        fmt.Println("No data returned. Check your component name and time range.")
+        return
+    }
+
+    // Build plot data points.
+    pts := make(plotter.XYs, len(results))
+    for i, entry := range results {
+        // Extract timestamp as float (seconds since epoch).
+        if t, ok := entry["time_received"].(time.Time); ok {
+            pts[i].X = float64(t.Unix())
+        }
+        // Extract temperature value.
+        if temp, ok := entry["temperature"].(float64); ok {
+            pts[i].Y = temp
+        }
+    }
+
+    // Create the plot.
+    p := plot.New()
+    p.Title.Text = "Sensor Temperature - Last 24 Hours"
+    p.X.Label.Text = "Time"
+    p.Y.Label.Text = "Temperature"
+
+    line, err := plotter.NewLine(pts)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    p.Add(line)
+
+    // Save to file.
+    if err := p.Save(10*vg.Inch, 4*vg.Inch, "temperature_chart.png"); err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Println("Chart saved to temperature_chart.png")
+}
+```
+
+Replace the placeholder values and component name, then run:
+
+```bash
+go run main.go
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Try It
+
+1. **Build a Viam Teleop dashboard.** Create a workspace, add a time-series widget
+   for a sensor and a camera feed widget, and verify that data appears in real
+   time.
+
+2. **Connect Grafana.** Run the CLI commands to configure database access, set
+   up the Grafana MongoDB data source, and run the example MQL query. Create a
+   time-series panel and verify the chart updates when you change the time range
+   selector.
+
+3. **Run the Python or Go script.** Copy one of the programmatic examples, fill
+   in your credentials, and run it. You should see a `temperature_chart.png`
+   file in your working directory.
+
+## Troubleshooting
+
+{{< expand "Viam Teleop dashboard shows no data" >}}
+
+- **Check that the machine is online.** The Viam Teleop dashboard shows live data
+  from the machine. If the machine is offline, widgets will be empty.
+- **Verify the component is configured.** Make sure the component you selected
+  in the widget configuration exists on the machine and is producing data.
+- **Check the widget configuration.** Click the pencil icon on the widget and
+  verify that the correct component and data source are selected.
+
+{{< /expand >}}
+
+{{< expand "CLI commands fail with authentication error" >}}
+
+- **Run `viam login` first.** The `database configure` and `database hostname`
+  commands require an active login session.
+- **Verify your organization ID.** Copy it directly from `viam organizations list`
+  output. It is a UUID, not your organization name.
+
+{{< /expand >}}
+
+{{< expand "Grafana connection test fails" >}}
+
+- **Check the connection string format.** The string must include
+  `directConnection=true&authSource=admin&tls=true`. Missing any of these
+  parameters can cause connection failures.
+- **Verify the hostname.** Use the exact hostname returned by
+  `viam data database hostname`, not the connection URI.
+- **Verify the username format.** The username must be `db-user-<YOUR-ORG-ID>`,
+  including the `db-user-` prefix.
+- **Verify the password.** This is the password you set with
+  `viam data database configure`, not your Viam app password. If
+  authentication fails with a password that contains special characters,
+  make sure the password is properly quoted or escaped in the CLI command,
+  the Grafana connection settings, and any connection string where you use it.
+- **Check that you installed the data source, not the integration.** The Grafana
+  MongoDB integration and the Grafana MongoDB data source are different plugins.
+  You need the data source.
+
+{{< /expand >}}
+
+{{< expand "Grafana query returns empty results" >}}
+
+- **Check the component name.** Component names in MQL queries are
+  case-sensitive and must match exactly.
+- **Check the time range.** The `${__from}` variable is controlled by the time
+  range selector at the top of the Grafana dashboard. Make sure the range covers
+  a period when data was captured.
+- **Verify the database name.** Sensor data is stored in the `sensorData`
+  database. If you used a different database name in the connection string, the
+  query will find no data.
+
+{{< /expand >}}
+
+{{< expand "Programmatic script fails with authentication error" >}}
+
+- **Verify your API key and API key ID.** Both are required. The API key is the
+  secret; the API key ID identifies which key is being used.
+- **Verify your organization ID.** Find it in the Viam app under **Settings**
+  in the left navigation.
+- **Check that the API key has data access.** API keys can be scoped to specific
+  resources. Ensure yours has access to the data service.
+
+{{< /expand >}}
+
+{{< expand "Chart is empty or shows no data points" >}}
+
+- **Check the component name in the query.** Replace `my-sensor` with the actual
+  name of your component.
+- **Check the time range.** The example queries the last 24 hours. If your data
+  is older than that, adjust the `timedelta` (Python) or `time.Duration` (Go).
+- **Check the field path.** The example uses `data.readings.temperature`. Your
+  sensor may use a different field name. Run a query in the Viam app query
+  editor first to see the actual structure of your data.
+
+{{< /expand >}}
+
+## What's next
+
+- [Query Data](/data/query-data/) -- learn the full range of SQL and MQL
+  queries you can use to extract insights from your data.
+- [Data pipelines](/data/pipelines/create-a-pipeline/) -- set up
+  aggregated views and derived metrics to power your dashboards more efficiently.
+- [Filter at the Edge](/data/filter-at-the-edge/) -- reduce noise in your
+  visualizations by filtering data before it leaves the machine.
diff --git a/docs/dev/_index.md b/docs/dev/_index.md
deleted file mode 100644
index cd199fa58e..0000000000
--- a/docs/dev/_index.md
+++ /dev/null
@@ -1,804 +0,0 @@
----
-linkTitle: "Dev tools"
-title: "Dev tools"
-weight: 600
-layout: "docs"
-type: "docs"
-no_list: true
-open_on_desktop: true
-overview: true
-noTitle: true
-notoc: true
-aliases:
-  - /docs/appendix/
-  - /appendix/
-  - /deeper-dive/
-  - /internals/
----
-
-<div class="max-page">
-  <div class="hero-container-small">
-    <div class="hero-text">
-      <h1>Dev tools</h1>
-      <p>
-        Viam integrates with hardware and software on <b>any device</b>. Once you've <a href="/operate/install/setup/">set up your machines</a> you can use the CLI and APIs to control and manage them.
-      </p>
-      <div class="cards max-page">
-        <div class="front-card-container">
-          <div class="hover-card primary">
-            <a href="tools/tutorials/" class="noanchor">
-            <div>
-              <p>Project Tutorials</p>
-            </div>
-          </a>
-          </div>
-          <div class="cta secondary">
-            <a href="tools/cli/" class="noanchor"><div>
-            <p>CLI →</p></div>
-            </a>
-          </div>
-          <div class="cta secondary">
-            <a href="reference/apis/" class="noanchor"><div>
-            <p>APIs →</p></div>
-            </a>
-          </div>
-        </div>
-      </div>
-    </div>
-    <img src=../viam.svg alt="Robot illustration" class="hero">
-  </div>
-</div>
-<br>
-
-<div class="max-page frontpage">
-
-Once you've set up your machine you can control your device and any attached physical hardware with [Viam APIs](/dev/reference/apis/), for example:
-
-{{< tabs class="horizontalheaders program" navheader="Examples">}}
-{{% tab name="Drive a base" %}}
-
-<div class="innertabcontentcontainer">
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python
-async def moveInSquare(base):
-    for _ in range(4):
-        # Move forward 500mm at 500mm/s
-        await base.move_straight(velocity=500, distance=500)
-        # Spin 90 degrees at 100 degrees/s
-        await base.spin(velocity=100, angle=90)
-```
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-```go
-func moveInSquare(ctx context.Context, base base.Base, logger logging.Logger) {
-    for i := 0; i < 4; i++ {
-        // Move forward 500mm at 500mm/s
-        base.MoveStraight(ctx, 600, 500.0, nil)
-        // Spin 90 degrees at 100 degrees/s
-        base.Spin(ctx, 90, 100.0, nil)
-    }
-}
-```
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-```ts
-async function moveInSquare(baseClient: VIAM.BaseClient) {
-  for (let i = 0; i < 4; i++) {
-    // Move forward 500mm at 500mm/s
-    await baseClient.moveStraight(500, 500);
-    // Spin 90 degrees at 100 degrees/s
-    await baseClient.spin(90, 100);
-  }
-}
-```
-
-{{% /tab %}}
-{{% tab name="Flutter" %}}
-
-```dart
-Future<void> moveSquare() async {
-  for (var i=0; i<4; i++) {
-    // Move forward 500mm at 500mm/s
-    await base.moveStraight(500, 500);
-    // Spins the rover 90 degrees at 100 degrees/s
-    await base.spin(90, 100);
-  }
-}
-```
-
-{{% /tab %}}
-{{% tab name="C++" %}}
-
-```cpp
-void move_in_square(std::shared_ptr<viam::sdk::Base> base) {
-  for (int i = 0; i < 4; ++i) {
-    // Move forward 500mm at 500mm/s
-    base->move_straight(500, 500);
-    // Spins the rover 90 degrees at 100 degrees/s
-    base->spin(90, 100);
-  }
-}
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-<div class="explanation">
-  <div class="explanationtext">
-
-Once you have configured a robotic base, you can drive it using the base API.
-
-[Drive a base →](/tutorials/control/drive-rover/)
-
-  </div>
-  <div class="explanationvisual">
-
-{{<gif webm_src="/tutorials/try-viam-sdk/image1.webm" mp4_src="/tutorials/try-viam-sdk/image1.mp4" alt="Overhead view of the Viam Rover showing it as it drives in a square.">}}
-
-  </div>
-</div>
-</div>
-
-{{% /tab %}}
-{{% tab name="Control motor" %}}
-
-<div class="innertabcontentcontainer">
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python
-async def spin_motor(motor):
-    # Turn the motor at 35% power forwards
-    await motor.set_power(power=0.35)
-    # Let the motor spin for 3 seconds
-    time.sleep(3)
-    # Stop the motor
-    await motor.stop()
-```
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-```go
-func spinMotor(ctx context.Context, motor motor.Motor, logger logging.Logger) {
-  // Turn the motor at 35% power forwards
-  err = motor.SetPower(context.Background(), 0.35, nil)
-  // Let the motor spin for 3 seconds
-  time.Sleep(3 * time.Second)
-  // Stop the motor
-  err = motor.Stop(context.Background(), nil)
-}
-```
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-```ts
-async function spinMotor(motorClient: VIAM.MotorClient) {
-  // Turn the motor at 35% power forwards
-  await motorClient.setPower(0.35);
-  // Let the motor spin for 3 seconds
-  const sleep = (ms: number) =>
-    new Promise((resolve) => setTimeout(resolve, ms));
-  await sleep(3000);
-  // Stop the motor
-  await motorClient.stop();
-}
-```
-
-{{% /tab %}}
-{{% tab name="Flutter" %}}
-
-```dart
-Future<void> spinMotor() async {
-  // Turn the motor at 35% power forwards
-  await motorClient.setPower(0.35);
-  // Let the motor spin for 3 seconds
-  await Future.delayed(Duration(seconds: 3));
-  // Stop the motor
-  await motorClient.stop();
-}
-```
-
-{{% /tab %}}
-{{% tab name="C++" %}}
-
-```cpp
-void spin_motor(std::shared_ptr<viam::sdk::Motor> motor) {
-  // Turn the motor at 35% power forwards
-  motor->set_power(0.35);
-  // Let the motor spin for 3 seconds
-  sleep(3);
-  // Stop the motor
-  motor->stop();
-}
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-<div class="explanation">
-  <div class="explanationtext">
-
-Once you have configured a motor, you can operate it using the motor API.
-
-[Control a motor →](/dev/reference/apis/components/motor/)
-
-  </div>
-  <div class="explanationvisual">
-
-{{<gif webm_src="/motor.webm" mp4_src="/motor.mp4" alt="A moving motor">}}
-
-  </div>
-</div>
-</div>
-{{% /tab %}}
-{{% tab name="Get sensor reading" %}}
-<div class="innertabcontentcontainer">
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python
-# Get the readings provided by the sensor.
-co_2_monitor = Sensor.from_robot(machine, "co2-monitor")
-co_2_monitor_return_value = await co_2_monitor.get_readings()
-print(f"co2-monitor get_readings return value: {co_2_monitor_return_value}")
-```
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-```go
-// Get the readings provided by the sensor.
-co2Monitor, err := sensor.FromProvider(machine, "co2-monitor")
-co2MonitorReturnValue, err := co2Monitor.Readings(
-  context.Background(), map[string]interface{}{})
-logger.Infof("co2-monitor return value: %+v", co2MonitorReturnValue)
-```
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-```ts
-// Get the readings provided by the sensor.
-const co2MonitorClient = new VIAM.SensorClient(machine, "co2-monitor");
-const co2MonitorReturnValue = await co2MonitorClient.getReadings();
-console.log("co2-monitor return value:", co2MonitorReturnValue);
-```
-
-{{% /tab %}}
-{{% tab name="Flutter" %}}
-
-```dart
-// Get the readings provided by the sensor.
-final co2Monitor = Sensor.fromRobot(client, "co2-monitor");
-var readings = await co2Monitor.readings();
-print(readings);
-```
-
-{{% /tab %}}
-{{% tab name="C++" %}}
-
-```cpp
-// Get the readings provided by the sensor.
-auto co2monitor = machine->resource_by_name<Sensor>("co2-monitor");
-auto co2monitor_get_readings_return_value = co2monitor->get_readings();
-std::cout << "co2-monitor get_readings return value " << co2monitor_get_readings_return_value << "\n";
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-<div class="explanation">
-  <div class="explanationtext">
-
-Once you have configured a physical sensor or anything else that provides measurements, you can get sensor readings using the sensor API.
-
-[Collect sensor data →](/data-ai/capture-data/capture-sync/)
-
-  </div>
-</div>
-</div>
-{{% /tab %}}
-{{% tab name="Move an arm" %}}
-<div class="innertabcontentcontainer">
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python
-# Command a joint position move: move the forearm of the arm slightly up
-cmd_joint_positions = JointPositions(values=[0, 0, -30.0, 0, 0, 0])
-await my_arm_component.move_to_joint_positions(
-    positions=cmd_joint_positions)
-
-# Generate a simple pose move +100mm in the +Z direction of the arm
-cmd_arm_pose = await my_arm_component.get_end_position()
-cmd_arm_pose.z += 100.0
-await my_arm_component.move_to_position(pose=cmd_arm_pose)
-```
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-```go
-// Command a joint position move: move the forearm of the arm slightly up
-cmdJointPositions := &armapi.JointPositions{Values: []float64{0.0, 0.0, -30.0, 0.0, 0.0, 0.0}}
-err = myArmComponent.MoveToJointPositions(context.Background(), cmdJointPositions, nil)
-
-// Generate a simple pose move +100mm in the +Z direction of the arm
-currentArmPose, err := myArmComponent.EndPosition(context.Background(), nil)
-adjustedArmPoint := currentArmPose.Point()
-adjustedArmPoint.Z += 100.0
-cmdArmPose := spatialmath.NewPose(adjustedArmPoint, currentArmPose.Orientation())
-
-err = myArmComponent.MoveToPosition(context.Background(), cmdArmPose, nil)
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-<div class="explanation">
-  <div class="explanationtext">
-
-Once you have configured a robotic arm, you can move it using the arm API.
-
-[Move a robotic arm →](/operate/mobility/move-arm/)
-
-  </div>
-  <div class="explanationvisual">
-
-{{<gif webm_src="/how-tos/move_to_position.webm" mp4_src="/how-tos/move_to_position.mp4" alt="A robot arm moving to a commanded position.">}}
-
-  </div>
-</div>
-</div>
-{{% /tab %}}
-{{% tab name="Operate custom hardware" %}}
-<div class="innertabcontentcontainer">
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python
-my_button = Generic.from_robot(robot=machine, name="my_button")
-
-# Use a custom command to push the button 5
-command = {"cmd": "push_button", "button": 5}
-result = await my_button.do_command(command)
-```
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-```go
-myButton, err := generic.FromProvider(machine, "my_button")
-
-// Use a custom command to push the button 5
-command := map[string]interface{}{"cmd": "push_button", "button": 5}
-result, err := myButton.DoCommand(context.Background(), command)
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-<div class="explanation">
-  <div class="explanationtext">
-
-Using the Viam Registry you can create _{{< glossary_tooltip term_id="resource" text="resources" >}}_ for additional hardware types or models and then deploy them to your machines.
-You can use an existing component or service type or create generic resources.
-
-[Create a module →](/operate/modules/write-a-driver-module/)
-
-  </div>
-</div>
-</div>
-{{% /tab %}}
-{{% tab name="Virtual hardware & Custom logic" %}}
-<div class="innertabcontentcontainer">
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python
-my_twilio_svc = Generic.from_robot(robot=machine, name="my_twilio_svc")
-
-# Use a custom command to send a text message with Twilio
-command = {"to": "+1 234 567 8901", "body": "Hello world!"}
-result = await my_twilio_svc.do_command(command)
-```
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-```go
-myTwilioSvc, err := generic.FromProvider(machine, "my_twilio_svc")
-
-// Use a custom command to send a text message with Twilio
-command := map[string]interface{}{"to": "+1 234 567 8901", "body": "Hello world!"}
-result, err := myTwilioSvc.DoCommand(context.Background(), command)
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-<div class="explanation">
-  <div class="explanationtext">
-
-Using the Viam Registry you can turn services and your own custom business logic into _{{< glossary_tooltip term_id="module" text="modules" >}}_. You can then deploy your modules to your machines.
-
-[Create a module →](/operate/modules/write-a-driver-module/)
-
-  </div>
-</div>
-</div>
-{{% /tab %}}
-{{< /tabs >}}
-
-<div class="max-page frontpage">
-<br>
-<br>
-
-You can also manage data, use higher level services, and manage your machines:
-
-{{< tabs class="horizontalheaders services" navheader="Examples">}}
-{{% tab name="Use computer vision" %}}
-
-<div class="innertabcontentcontainer">
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python
-# Get image from camera stream on construction site
-cam = Camera.from_robot(machine, "construction-site-cam")
-images, _ = await cam.get_images()
-img = images[0]
-
-# Use machine learning model to gather information from the image
-hardhat_detector = VisionClient.from_robot(machine, "hardhat_detector")
-detections = await hardhat_detector.get_detections(img)
-
-# Check whether a person is detected not wearing a hardhat
-for d in detections:
-    if d.confidence > 0.8 and d.class_name == "NO-Hardhat":
-        print("Violation detected.")
-```
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-```go
-// Get image from camera stream on construction site
-myCamera, err := camera.FromProvider(machine, "construction-site-cam")
-img, err = camera.DecodeImageFromCamera(context.Background(), utils.MimeTypeJPEG, nil, myCamera)
-
-// Use machine learning model to gather information from the image
-visService, err := vision.FromProvider(machine, "hardhat_detector")
-detections, err := visService.Detections(context.Background(), img, nil)
-
-// Check whether a person is detected not wearing a hardhat
-for i := 0; i < len(detections); i++ {
-  if (detection[i].confidence > 0.8) && (detection[i].class_name == "NO-Hardhat")  {
-    logger.Info("Violation detected.")
-  }
-}
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-<div class="explanation">
-  <div class="explanationtext">
-
-Computer vision enables your machine to use connected cameras to interpret the world around it.
-With inferences about a machine's surroundings, you can program machines to act based on this input using the vision service API.
-
-[Try the vision service →](/tutorials/projects/helmet/)
-
-  </div>
-  <div class="explanationvisual">
-
-{{<gif webm_src="/tutorials/helmet/hardhat.webm" mp4_src="/tutorials/helmet/hardhat.mp4" alt="A man without a hard hat is detected and labeled as No-Hardhat. Then he puts on a hard hat and a bounding box labeled Hardhat appears. He gives a thumbs-up to the camera.">}}
-
-  </div>
-</div>
-</div>
-
-{{% /tab %}}
-{{% tab name="Query captured data" %}}
-
-<div class="innertabcontentcontainer">
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python
-# Tag data from the my_camera component
-my_filter = create_filter(component_name="my_camera")
-tags = ["frontview", "trainingdata"]
-res = await data_client.add_tags_to_binary_data_by_filter(tags, my_filter)
-
-# Query sensor data by filter
-my_data = []
-my_filter = create_filter(
-    component_name="sensor-1",
-    start_time=Timestamp('2024-10-01 10:00:00', tz='US/Pacific'),
-    end_time=Timestamp('2024-10-12 18:00:00', tz='US/Pacific')
-)
-tabular_data, count, last = await data_client.tabular_data_by_filter(
-    my_filter, last=None)
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-<div class="explanation">
-  <div class="explanationtext">
-
-You can query synced sensor data, images, and any other binary or timeseries data from all your machines using the data client API.
-
-[Learn about Data Management →](/data-ai/capture-data/capture-sync/)
-
-  </div>
-</div>
-</div>
-{{% /tab %}}
-{{% tab name="Move arms" %}}
-<div class="innertabcontentcontainer">
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python
-# Add a table obstacle to a WorldState
-table_origin = Pose(x=-202.5, y=-546.5, z=-19.0)
-table_dimensions = Vector3(x=635.0, y=1271.0, z=38.0)
-table_object = Geometry(center=table_origin,
-                        box=RectangularPrism(dims_mm=table_dimensions))
-obstacles_in_frame = GeometriesInFrame(reference_frame="world",
-                                       geometries=[table_object])
-world_state = WorldState(obstacles=[obstacles_in_frame])
-
-# Destination pose to move to
-dest_in_frame = PoseInFrame(
-    reference_frame="world",
-    pose=Pose(x=510.0, y=0.0, z=526.0, o_x=0.7, o_y=0.0, o_z=-0.7, theta=0.0))
-
-# Move arm to destination pose
-motion_service = MotionClient.from_robot(robot, "builtin")
-await motion_service.move(
-    component_name="myArm",
-    destination=dest_in_frame, world_state=world_state)
-```
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-```go
-// Add a table obstacle to a WorldState
-obstacles := make([]spatialmath.Geometry, 0)
-tableOrigin := spatialmath.NewPose(
-  r3.Vector{X: 0.0, Y: 0.0, Z: -10.0},
-  &spatialmath.OrientationVectorDegrees{OX: 0.0, OY: 0.0, OZ: 1.0, Theta: 0.0},
-)
-tableDimensions := r3.Vector{X: 2000.0, Y: 2000.0, Z: 20.0}
-tableObj, err := spatialmath.NewBox(tableOrigin, tableDimensions, "table")
-obstacles = append(obstacles, tableObj)
-obstaclesInFrame := referenceframe.NewGeometriesInFrame(referenceframe.World, obstacles)
-worldState, err := referenceframe.NewWorldState([]*referenceframe.GeometriesInFrame{obstaclesInFrame}, nil)
-
-// Destination pose to move to
-destinationPose := spatialmath.NewPose(
-  r3.Vector{X: 510.0, Y: 0.0, Z: 526.0},
-  &spatialmath.OrientationVectorDegrees{OX: 0.7071, OY: 0.0, OZ: -0.7071, Theta: 0.0},
-)
-destPoseInFrame := referenceframe.NewPoseInFrame(
-  referenceframe.World, destinationPose)
-
-// Move arm to destination pose
-motionService, err := motion.FromProvider(robot, "builtin")
-_, err = motionService.Move(context.Background(), "myArm", destPoseInFrame, worldState, nil, nil)
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-<div class="explanation">
-  <div class="explanationtext">
-
-The motion service enables your machine to plan and move relative to itself, other machines, and the world. You can use it with the motion service API.
-
-[Try the motion service →](/tutorials/services/plan-motion-with-arm-gripper/)
-
-  </div>
-  <div class="explanationvisual">
-
-{{<gif webm_src="/tutorials/videos/motion_armmoving.webm" mp4_src="/tutorials/videos/motion_armmoving.mp4" alt="An arm moving with the motion service">}}
-
-  </div>
-</div>
-</div>
-{{% /tab %}}
-{{% tab name="Navigate bases" %}}
-<div class="innertabcontentcontainer">
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python
-my_nav = NavigationClient.from_robot(robot=robot, name="my_nav_service")
-
-# Create a new waypoint at the specified latitude and longitude
-location = GeoPoint(latitude=40.76275, longitude=-73.96)
-
-# Add waypoint to the service's data storage
-await my_nav.add_waypoint(point=location)
-
-my_nav = NavigationClient.from_robot(robot=robot, name="my_nav_service")
-
-# Set the service to operate in waypoint mode and begin navigation
-await my_nav.set_mode(Mode.ValueType.MODE_WAYPOINT)
-```
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-```go
-myNav, err := navigation.FromProvider(robot, "my_nav_service")
-
-// Create a new waypoint at the specified latitude and longitude
-location = geo.NewPoint(40.76275, -73.96)
-
-// Add waypoint to the service's data storage
-err := myNav.AddWaypoint(context.Background(), location, nil)
-
-myNav, err := navigation.FromProvider(robot, "my_nav_service")
-
-// Set the service to operate in waypoint mode and begin navigation
-mode, err := myNav.SetMode(context.Background(), Mode.MODE_WAYPOINT, nil)
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-<div class="explanation">
-  <div class="explanationtext">
-
-Autonomously navigate a machine to defined waypoints using the navigation service API.
-
-[Try the navigation service →](/tutorials/services/navigate-with-rover-base/)
-
-  </div>
-</div>
-</div>
-{{% /tab %}}
-{{% tab name="Check machine status" %}}
-
-<div class="innertabcontentcontainer">
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python
-# Get all machines in a location
-machines = await cloud.list_robots(location_id="abcde1fghi")
-
-for m in machines:
-    # Connect and get status information or latest logs
-    machine_parts = await cloud.get_robot_parts(m.id)
-    main_part = next(filter(lambda part: part.main_part, machine_parts), None)
-
-    try:
-        # Get status for machine
-        machine = await connect(main_part.fqdn)
-        status = await machine.get_machine_status()
-    except ConnectionError:
-        # If no connection can be made, get last logs
-        logs = await cloud.get_robot_part_logs(
-            robot_part_id=main_part.id, num_log_entries=5)
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-<div class="explanation">
-  <div class="explanationtext">
-
-Get status information and logs from all your deployed machines using the fleet management API.
-
-[Learn about Platform APIs →](/dev/reference/apis/#platform-apis)
-
-  </div>
-</div>
-</div>
-
-{{% /tab %}}
-{{% tab name="Train ML models" %}}
-
-<div class="innertabcontentcontainer">
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python
-# Start a training job to create a classification model based on the dataset
-job_id = await ml_training_client.submit_training_job(
-    org_id="abbc1c1c-d2e3-5f67-ab8c-de912345f678",
-    dataset_id="12ab3cd4e56f7abc89de1fa2",
-    model_name="recognize_gestures",
-    model_version="1",
-    model_type=ModelType.MODEL_TYPE_MULTI_LABEL_CLASSIFICATION,
-    tags=["follow", "stop"]
-)
-
-# Get status information for training job
-job_metadata = await ml_training_client.get_training_job(
-    id=job_id)
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-<div class="explanation">
-  <div class="explanationtext">
-
-Build machine learning models based on your machines' data any time using the ML training client API
-
-[Train and deploy ML models →](/data-ai/train/train-tf-tflite/)
-
-  </div>
-</div>
-</div>
-
-{{% /tab %}}
-{{% tab name="Manage access and resources" %}}
-
-<div class="innertabcontentcontainer">
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-```python
-# Create a new machine
-new_machine_id = await cloud.new_robot(
-    name="new-machine", location_id="abcde1fghi")
-
-# Get organization associated with authenticated user / API key
-org_list = await cloud.list_organizations()
-
-# Create a new API key with owner access for the new machine
-auth = APIKeyAuthorization(
-    role="owner",
-    resource_type="robot",
-    resource_id=new_machine_id
-)
-api_key, api_key_id = await cloud.create_key(
-    org_list[0].id, [auth], "key_for_new_machine")
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-<div class="explanation">
-  <div class="explanationtext">
-
-Viam allows you to organize and manage any number of machines. When collaborating with others, you can assign permissions using Role-Based Access Control (RBAC). Programmatically you can do this with the fleet management API.
-
-[Learn about access control →](/manage/manage/rbac/)
-
-  </div>
-</div>
-</div>
-
-{{% /tab %}}
-{{< /tabs >}}
diff --git a/docs/dev/reference/_index.md b/docs/dev/reference/_index.md
deleted file mode 100644
index 1be06e9480..0000000000
--- a/docs/dev/reference/_index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-linkTitle: "Reference"
-weight: 300
-layout: "empty"
-type: "docs"
-empty_node: true
-open_on_desktop: true
-header_only: true
-canonical: "/dev/reference/apis/"
----
diff --git a/docs/dev/reference/apis/_index.md b/docs/dev/reference/apis/_index.md
deleted file mode 100644
index eadb2aae82..0000000000
--- a/docs/dev/reference/apis/_index.md
+++ /dev/null
@@ -1,91 +0,0 @@
----
-title: "Viam's Client APIs"
-linkTitle: "APIs"
-weight: 10
-type: "docs"
-description: "Access and control your machine or fleet with the SDKs' client libraries for the resource and robot APIs."
-images: ["/general/code.png"]
-tags: ["client", "sdk", "viam-server", "networking", "apis", "robot api"]
-aliases:
-  - /program/sdks/
-  - /program/apis/
-  - /build/program/apis/
-  - /appendix/apis/
-no_list: true
-date: "2024-10-01"
-# updated: ""  # When the content was last entirely checked
----
-
-Every Viam {{< glossary_tooltip term_id="resource" text="resource" >}} exposes an [application programming interface (API)](https://en.wikipedia.org/wiki/API) described through [protocol buffers](https://developers.google.com/protocol-buffers).
-
-The API methods provided by the SDKs for each of these resource APIs wrap gRPC client requests to the machine when you execute your program, providing you a convenient interface for accessing information about and controlling the {{< glossary_tooltip term_id="resource" text="resources" >}} you have [configured](/operate/modules/configure-modules/) on your machine.
-
-## Platform APIs
-
-{{< cards >}}
-{{% manualcard link="/dev/reference/apis/fleet/" title="Fleet Management API" %}}
-
-Create and manage organizations, locations, and machines, get logs from individual machines, and manage fragments and permissions.
-
-{{% /manualcard %}}
-{{% manualcard link="/dev/reference/apis/data-client/" title="Data Client API" %}}
-
-Upload, download, filter, tag or perform other tasks on data like images or sensor readings.
-
-{{% /manualcard %}}
-{{% manualcard link="/dev/reference/apis/robot/" title="Machine Management API" %}}
-
-Manage your machines: connect to your machine, retrieve status information, and send commands remotely.
-
-{{% /manualcard %}}
-{{% manualcard link="/dev/reference/apis/ml-training-client/" title="ML Training Client API" %}}
-
-Submit and manage ML training jobs running on Viam.
-
-{{% /manualcard %}}
-{{% manualcard link="/dev/reference/apis/billing-client/" title="Billing Client API" %}}
-
-Retrieve billing information from Viam.
-
-{{% /manualcard %}}
-
-{{< /cards >}}
-
-## Component APIs
-
-These APIs provide interfaces for controlling and getting information from the {{< glossary_tooltip term_id="component" text="components" >}} of a machine:
-
-{{< cards >}}
-{{< card link="/dev/reference/apis/components/arm/" customTitle="Arm API" noimage="True" >}}
-{{< card link="/dev/reference/apis/components/base/" customTitle="Base API" noimage="True" >}}
-{{< card link="/dev/reference/apis/components/board/" customTitle="Board API" noimage="True" >}}
-{{< card link="/dev/reference/apis/components/button/" customTitle="Button API" noimage="True" >}}
-{{< card link="/dev/reference/apis/components/camera/" customTitle="Camera API" noimage="True" >}}
-{{< card link="/dev/reference/apis/components/encoder/" customTitle="Encoder API" noimage="True" >}}
-{{< card link="/dev/reference/apis/components/gantry/" customTitle="Gantry API" noimage="True" >}}
-{{< card link="/dev/reference/apis/components/generic/" customTitle="Generic API" noimage="True" >}}
-{{< card link="/dev/reference/apis/components/gripper/" customTitle="Gripper API" noimage="True" >}}
-{{< card link="/dev/reference/apis/components/input-controller/" customTitle="Input controller API" noimage="True" >}}
-{{< card link="/dev/reference/apis/components/motor/" customTitle="Motor API" noimage="True" >}}
-{{< card link="/dev/reference/apis/components/movement-sensor/" customTitle="Movement sensor API" noimage="True" >}}
-{{< card link="/dev/reference/apis/components/power-sensor/" customTitle="Power sensor API" noimage="True" >}}
-{{< card link="/dev/reference/apis/components/sensor/" customTitle="Sensor API" noimage="True" >}}
-{{< card link="/dev/reference/apis/components/servo/" customTitle="Servo API" noimage="True" >}}
-{{< card link="/dev/reference/apis/components/switch/" customTitle="Switch API" noimage="True" >}}
-{{< /cards >}}
-
-## Service APIs
-
-These APIs provide interfaces for controlling and getting information from the services you configured on a machine.
-
-{{< cards >}}
-{{% card link="/dev/reference/apis/services/data/" customTitle="Data management service API" noimage="True" %}}
-{{% card link="/dev/reference/apis/services/vision/" customTitle="Vision service API" noimage="True" %}}
-{{% card link="/dev/reference/apis/services/ml/" customTitle="ML model service API" noimage="True" %}}
-{{% card link="/dev/reference/apis/services/motion/" customTitle="Motion service API" noimage="True" %}}
-{{% card link="/dev/reference/apis/services/navigation/" customTitle="Navigation service API" noimage="True" %}}
-{{% card link="/dev/reference/apis/services/generic/" customTitle="Generic service API" noimage="True" %}}
-{{% card link="/dev/reference/apis/services/slam/" customTitle="SLAM service API" noimage="True" %}}
-{{% card link="/dev/reference/apis/services/base-rc/" customTitle="Base Remote Control service API" noimage="True" %}}
-{{% card link="/dev/reference/apis/services/discovery/" customTitle="Discovery service API" noimage="True" %}}
-{{< /cards >}}
diff --git a/docs/dev/reference/apis/services/SLAM.md b/docs/dev/reference/apis/services/SLAM.md
deleted file mode 100644
index 2c5b29897e..0000000000
--- a/docs/dev/reference/apis/services/SLAM.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: "SLAM service API"
-linkTitle: "SLAM"
-weight: 60
-type: "docs"
-tags: ["slam", "services"]
-description: "Give commands to get a machine's position within a map."
-icon: true
-images: ["/services/icons/slam.svg"]
-date: "2022-01-01"
-aliases:
-  - /appendix/apis/services/slam/
-# updated: ""  # When the content was last entirely checked
----
-
-The SLAM service API allows you to get a machine's position within a map.
-
-The [SLAM service](/operate/reference/services/slam/) supports the following methods:
-
-{{< readfile "/static/include/services/apis/generated/slam-table.md" >}}
-
-## API
-
-{{< readfile "/static/include/services/apis/generated/slam.md" >}}
diff --git a/docs/dev/reference/architecture.md b/docs/dev/reference/architecture.md
deleted file mode 100644
index a4417624e8..0000000000
--- a/docs/dev/reference/architecture.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-linkTitle: "Architecture"
-title: "Viam Architecture"
-weight: 800
-type: "docs"
-layout: "empty"
-canonical: "/operate/reference/architecture/"
----
diff --git a/docs/dev/reference/changelog.md b/docs/dev/reference/changelog.md
deleted file mode 100644
index 08381f9e65..0000000000
--- a/docs/dev/reference/changelog.md
+++ /dev/null
@@ -1,1658 +0,0 @@
----
-title: "Changelog"
-linkTitle: "Changelog"
-weight: 20
-draft: false
-type: "docs"
-description: "A log of added features, improvements, and changes over time."
-aliases:
-  - "/appendix/release-notes/"
-  - "/components/arm/ur5e/"
-  - "/operate/reference/components/arm/ur5e/"
-  - "/components/camera/single-stream/"
-  - "/components/camera/dual-stream/"
-  - "/components/camera/align-color-depth-extrinsics/"
-  - "/components/camera/align-color-depth-homography/"
-  - "/components/board/customlinux/"
-  - "/components/board/jetson/"
-  - "/components/board/pca9685/"
-  - "/components/board/ti/"
-  - "/components/gripper/softrobotics/"
-  - "/components/motor/encoded-motor/"
-  - "/components/motor/gpiostepper/"
-  - "/components/motor/roboclaw/"
-  - "/components/movement-sensor/adxl345/"
-  - "/components/movement-sensor/dual-gps-rtk/"
-  - "/components/movement-sensor/gps-nmea-rtk-pmtk/"
-  - "/components/movement-sensor/gps-nmea-rtk-serial/"
-  - "/components/movement-sensor/gps-nmea/"
-  - "/components/movement-sensor/wheeled-odometry/"
-  - "/components/power-sensor/ina219/"
-  - "/components/power-sensor/ina226/"
-  - "/components/sensor/bme280/"
-  - "/components/sensor/ds18b20/"
-  - "/components/sensor/sensirion-sht3xd/"
-  - /build/configure/processes/
-  - /configure/processes/
-  - /manage/reference/processes
-  - /appendix/changelog/
-layout: "changelog"
-outputs:
-  - rss
-  - html
-date: "2024-09-18"
-# updated: ""  # When the content was last entirely checked
----
-
-{{% changelog color="changed" title="GetImages replaced GetImage" date="2025-10-31" %}}
-
-[`GetImage`](/dev/reference/apis/components/camera/#getimage) is deprecated.
-Use [`GetImages`](/dev/reference/apis/components/camera/#getimages) instead.
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Fragment prefix" date="2025-10-29" %}}
-
-You can now set prefixes on fragments to avoid name collisions.
-For more information, see [Add fragment prefix](/manage/fleet/reuse-configuration/#add-fragment-prefix).
-
-{{% /changelog %}}
-
-{{% changelog color="changed" title="FromProvider replaces FromRobot and FromDependencies in Golang" date="2025-10-21" %}}
-
-`resource.FromRobot` and `resource.FromDependencies` are deprecated.
-Use [`resource.FromProvider`](https://pkg.go.dev/go.viam.com/rdk/resource#FromProvider) instead.
-
-{{% /changelog %}}
-
-{{% changelog color="changed" title="Fragment Variables" date="2025-10-06" %}}
-
-[Fragments](/manage/fleet/reuse-configuration/) now support variables, allowing you to define variable values per-machine.
-
-{{% /changelog %}}
-
-{{% changelog color="changed" title="Alerting on error logs" date="2025-09-10" %}}
-
-[Triggers](/manage/troubleshoot/alert/) now support sending alerts for error, warning, and info logs.
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Machine job scheduling" date="2025-08-19" %}}
-
-Added support for scheduling automated jobs on machines that run at specified intervals.
-Jobs can target any configured component or service and execute methods using unix-cron expressions or Golang duration strings.
-This enables automation of routine tasks such as data collection, sensor readings, maintenance operations, and system checks.
-
-See [Schedule automated jobs](/manage/software/scheduled-jobs/) for configuration details and examples.
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Merge datasets" date="2025-08-11" %}}
-
-You can now merge datasets to combine their data into a new dataset using the web UI.
-For more information, see [Merge datasets](/data-ai/train/create-dataset/#merge-datasets).
-
-{{% /changelog %}}
-
-{{% changelog color="removed" title="Deprecated: AddTagsToBinaryDataByFilter and RemoveTagsFromBinaryDataByFilter" date="2025-08-07" %}}
-
-The methods `AddTagsToBinaryDataByFilter` and `RemoveTagsFromBinaryDataByFilter` are deprecated.
-
-Instead use [BinaryDataByFilter](/dev/reference/apis/data-client/#binarydatabyfilter), [AddTagsToBinaryDataByIDs](/dev/reference/apis/data-client/#addtagstobinarydatabyids), and [RemoveTagsFromBinaryDataByIDs](/dev/reference/apis/data-client/).
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Use folders to organize resources" date="2025-08-01" %}}
-
-You can now use folders on machines and in fragments to organize resources.
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Bluetooth provisioning" date="2025-07-28" %}}
-
-Added support for Bluetooth Low Energy (BLE) provisioning, allowing devices to be set up over Bluetooth connection.
-For an example implementation, see the [Flutter Provisioning package](https://github.com/viamrobotics/viam_flutter_provisioning/).
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Annual billing support for subscription billing model" date="2025-07-23" %}}
-
-You can now configure annual billing alongside monthly billing options for your organizations.
-See [white-labeled billing documentation](/manage/manage/white-labeled-billing/) for configuration details.
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Build custom Viam applications" date="2025-07-17" %}}
-
-You can now create and use Viam applications to build custom applications that interact with your Viam-powered machines through the Viam SDKs.
-For more information, see [Viam applications](/operate/control/viam-applications/).
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Start modules with a TCP connection" date="2025-07-14" %}}
-
-You can now configure to start modules with a TCP connection. See [Module Configuration](/operate/modules/advanced/module-configuration/) for more information.
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Auto-predictions UI for dataset annotation" date="2025-07-11" %}}
-
-You can now automatically tag your dataset images using existing ML models with the new auto-predictions feature.
-For more information, see [Annotate images](/data-ai/train/annotate-images/).
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Notes section for resource configuration cards" date="2025-07-10" %}}
-
-You can now add descriptive notes to any resource in your machine configuration, including components, services, remotes, local resources, processes, triggers, packages, and modules.
-The Notes section appears at the bottom of each resource configuration card in both machine builder and fragment builder.
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Data regions for organizations" date="2025-06-30" %}}
-
-Organizations can now specify continent-level [data regions](/manage/manage/data-regions/) (North America or Europe) to control where data is geographically stored. You can only change this region in organizations that have not yet synced any data.
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Threshold selection for dataset inference" date="2025-06-24" %}}
-
-You can now configure confidence thresholds when running ML model inference on datasets. The new threshold selection modal allows you to set a confidence threshold between 0.0 and 1.0 to filter inference results, helping reduce false positives and focus on high-confidence predictions.
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Move machines between locations" date="2025-06-10" %}}
-
-Organization owners and location owners can now move machines between locations within their organization using the web UI.
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Module and namespace renaming" date="2025-06-09" %}}
-
-You can now rename modules and organization namespaces through the web UI.
-For more information, see [Rename a module](/operate/modules/advanced/manage-modules/#rename-a-module) and [Update a namespace for your organization](/operate/modules/advanced/metajson/#update-a-namespace-for-your-organization).
-
-{{% /changelog %}}
-
-{{% changelog color="removed" title="Frame tab removed, use Add Frame button" date="2025-05-15" %}}
-
-The frame tab no longer exists.
-To add a frame to a component, click the **+ Add frame** button on the component's configuration card.
-
-{{% /changelog %}}
-
-{{% changelog color="changed" title="Deprecated explicit dependencies" date="2025-05-05" %}}
-
-Some older modules use "explicit dependencies" which require users to list the names of dependencies in the `depends_on` field of the resource's configuration, for example:
-
-```json {class="line-numbers linkable-line-numbers" data-line="8"}
-{
-  "name": "mime-type-sensor",
-  "api": "rdk:component:sensor",
-  "model": "jessamy:my-module:my-sensor",
-  "attributes": {
-    "camera_name": "camera-1"
-  },
-  "depends_on": ["camera-1"]
-}
-```
-
-This explicit dependency handling is deprecated and not recommended when writing new modules.
-
-We now recommend using dependencies as described in the [Module dependencies](/operate/modules/advanced/dependencies/) documentation.
-The implicit way of handling dependencies does not require users to list the names of dependencies in the `depends_on` field.
-
-{{% /changelog %}}
-
-{{% changelog color="changed" title="Validate method signature for optional dependencies" date="2025-05-05" %}}
-
-The `Validate` method signature in Python and Go modules has been updated to better distinguish between required and optional dependencies:
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-Old signature:
-
-```python {class="line-numbers linkable-line-numbers"}
-def validate_config(
-    cls, config: ComponentConfig
-) -> Sequence[str]:
-    deps = []
-    return deps
-```
-
-New signature:
-
-```python {class="line-numbers linkable-line-numbers"}
-def validate_config(
-    cls, config: ComponentConfig
-) -> Tuple[Sequence[str], Sequence[str]]:
-    req_deps = []
-    opt_deps = []
-    return req_deps, opt_deps
-```
-
-This is not currently a breaking change for Python modules, though the old signature is deprecated.
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-Old signature:
-
-```go {class="line-numbers linkable-line-numbers"}
-Validate(path string) ([]string, error)
-```
-
-New signature:
-
-```go {class="line-numbers linkable-line-numbers"}
-Validate(path string) (requiredDeps []string, optionalDeps []string, error)
-```
-
-This is a breaking change for Go modules.
-
-{{% /tab %}}
-{{< /tabs >}}
-
-See [Module dependencies](/operate/modules/advanced/dependencies/) for more information.
-
-{{% /changelog %}}
-
-<!-- If there is no concrete date for a change that makes sense, use the end of the month it was released in. -->
-
-{{% changelog color="added" title="System log forwarding" date="2025-05-14" %}}
-
-You can now configure `viam-agent` to forward system logs from journald to the cloud. This allows you to view system logs from your machine alongside Viam's own logs.
-
-To enable system log forwarding, add the `forward_system_logs` field to the `system_configuration` object in your machine's `agent` configuration. This field accepts a comma-separated list of service identifiers to include or exclude from forwarding.
-
-For more information, see [Configure operating system logging](/manage/fleet/system-settings/#forward-system-logs-to-the-cloud).
-
-{{% /changelog %}}
-
-{{% changelog color="removed" title="Processes" date="2025-05-06" %}}
-
-Processes were removed in `viam-server` v0.74.0.
-Instead [use modules for control logic](/operate/modules/write-a-logic-module/#5-implement-docommand).
-
-{{% /changelog %}}
-
-{{% changelog color="changed" title="Viam provisioning" date="2025-03-24" %}}
-
-You can now set any `viam-agent` configuration values to customized defaults.
-If you are using `viam-agent` version X.X.X or newer, the provisioning file is called <FILE>viam-defaults.json</FILE> and uses new syntax and field names.
-When provisioning devices using an older version of `viam-agent`, the configuration file needs to be called <FILE>viam-provisioning.json</FILE>.
-
-If you are using the old <FILE>viam-provisioning.json</FILE> you must also use the old syntax and field names.
-
-{{% expand "Click to see old syntax and field names." %}}
-
-{{< tabs >}}
-{{% tab name="Template" %}}
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "manufacturer": "<NAME>", # your company name
-  "model": "<NAME>", # the machine's model
-  "fragment_id": "<ID>", # the fragment id, required for mobile app
-  "hotspot_prefix": "<PREFIX>", # machine creates a hotspot with prefix-hostname during setup
-  "disable_dns_redirect": true, # disable if using a mobile app
-  "hotspot_password": "<PASSWORD>", # password for the WiFi or bluetooth hotspot
-  "networks" : []
-}
-```
-
-{{% /tab %}}
-{{% tab name="Example" %}}
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "manufacturer": "Skywalker",
-  "model": "C-3PO",
-  "fragment_id": "2567c87d-7aef-41bc-b82c-d363f9874663",
-  "hotspot_prefix": "skywalker-setup",
-  "disable_dns_redirect": true,
-  "hotspot_password": "skywalker123",
-  "roaming_mode": false,
-  "offline_timeout": "3m30s",
-  "user_timeout": "2m30s",
-  "fallback_timeout": "15m"
-}
-```
-
-This file configures some basic metadata, specifies a [fragment](/manage/fleet/reuse-configuration/#modify-fragment-settings-on-a-machine) to use to configure the machine, and provides the WiFi hotspot network name and password to use on startup.
-It also configures timeouts to control how long `viam-agent` waits for a valid local WiFi network to come online before creating its hotspot network, and how long to keep the hotspot active before terminating it.
-
-{{% /tab %}}
-{{< /tabs >}}
-
-<!-- prettier-ignore -->
-| Name       | Type   | Required? | Description |
-| ---------- | ------ | --------- | ----------- |
-| `manufacturer` | string | Optional | Purely informative. May be displayed on captive portal or provisioning app. Default: `"viam"`. |
-| `model` | string | Optional | Purely informative. May be displayed on captive portal or provisioning app. Default: `"custom"`. |
-| `fragment_id` | string | Optional | The `fragment_id` of the fragment to configure machines with. Required when using the Viam mobile app for provisioning. The Viam mobile app uses the fragment to configure the machine. |
-| `hotspot_interface` | string | Optional | The interface to use for hotspot/provisioning/wifi management. Default: first discovered 802.11 device. |
-| `hotspot_prefix` | string | Optional | `viam-agent` will prepend this to the hostname of the device and use the resulting string for the provisioning hotspot SSID or the Bluetooth device name(`<hotspot_prefix>-<hostname>`).  Default: `"viam-setup"`. |
-| `hotspot_password` | string | Optional | Depending on the provisioning method, this is either the Wifi password or bluetooth connection password for the provisioning hotspot. **Important:** When provisioning devices with the Viam mobile app, the password must currently be `"viamsetup"`. Be aware that if you do not set a custom password this may be a security risk. Default: `"viamsetup"`. |
-| `disable_dns_redirect` | boolean | Optional | By default, ALL DNS lookups using the provisioning hotspot will redirect to the device. This causes most phones/mobile devices to automatically redirect the user to the captive portal as a "sign in" screen. When disabled, only domains ending in .setup (ex: viam.setup) will be redirected. This generally avoids displaying the portal to users and is mainly used in conjunction with a mobile provisioning application workflow. Default: `false`. |
-| `roaming_mode` | boolean | Optional | By default, the device will only attempt to connect to a single wifi network (the one with the highest priority), provided during initial provisioning/setup using the provisioning mobile app or captive web portal. Wifi connection alone is enough to consider the device as "online" even if the global internet is not reachable. If the primary network configured during provisioning cannot be connected to and roaming mode is enabled, the device will attempt connections to all configured networks in `networks`, and only consider the device online if the internet is reachable. Default: `false`. |
-| `offline_timeout` | boolean | Optional | Will only enter provisioning mode (hotspot) after being disconnected longer than this time. Useful on flaky connections, or when part of a system where the device may start quickly, but the wifi/router may take longer to be available. Default: `"2m"` (2 minutes). |
-| `user_timeout` | boolean | Optional | Amount of time before considering a user (using the captive web portal or provisioning app) idle, and resuming normal behavior. Used to avoid interrupting provisioning mode (for example for network tests/retries) when a user might be busy entering details. Default: `"5m"` (5 minutes). |
-| `fallback_timeout` | boolean | Optional | Provisioning mode will exit after this time, to allow other unmanaged (for example wired) or manually configured connections to be tried. Provisioning mode will restart if the connection/online status doesn't change. Default: `"10m"` (10 minutes). |
-| `networks` | array | Optional | Add additional networks the machine can connect to for provisioning. We recommend that you add WiFi settings in the operating system (for example, directly in NetworkManager) rather than in this file, or in the corresponding machine config, if networks aren't needed until after initial provisioning. Default: `[]`. |
-| `wifi_power_save` | boolean | Optional | If set, will explicitly enable or disable power save for all WiFi connections managed by NetworkManager.  |
-| `device_reboot_after_offline_minutes` | integer | Optional | If set, `viam-agent` will reboot the device after it has been offline for the specified duration. Default: `0` (disabled). |
-
-{{% /expand%}}
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Store metadata" date="2025-03-28" %}}
-
-You can store and retrieve arbitrary metadata about your organization, location, machine, and machine part with the [Fleet Management API](/dev/reference/apis/fleet/).
-
-{{% hiddencontent %}}
-It is not possible to store metadata associated with a Viam user.
-{{% /hiddencontent %}}
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Hot Data Store" date="2025-03-11" %}}
-
-The [hot data store](/data-ai/data/hot-data-store/) allows you to access recent data faster.
-
-{{% /changelog %}}
-
-{{% changelog color="changed" title="Config uses API instead of type and namespace" date="2025-03-25" %}}
-
-The JSON configuration for a resource now uses a field called `api` for the {{< glossary_tooltip term_id="api-namespace-triplet" text="API triplet" >}} instead of the deprecated `type` and `namespace` fields.
-For example, instead of:
-
-```json
-{
-  "name": "my_board",
-  "namespace": "rdk",
-  "type": "board",
-  "model": "viam:nvidia:jetson"
-}
-```
-
-You should use:
-
-```json
-{
-  "name": "my_board",
-  "api": "rdk:component:board",
-  "model": "viam:nvidia:jetson"
-}
-```
-
-Backward compatibility is maintained for existing configurations.
-
-{{% /changelog %}}
-
-{{% changelog color="removed" title="Managed Processes" date="2025-02-01" %}}
-
-Managed Processes are now deprecated and will be removed in a future version of `viam-server`.
-Instead [use modules for control logic](/operate/modules/write-a-logic-module/#5-implement-docommand).
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="White labeled billing and custom pricing" date="2025-02-01" %}}
-
-You can now [set custom pricing](/manage/manage/white-labeled-billing/) for your organizations and add your logo to invoices and other billing materials.
-
-{{% /changelog %}}
-
-{{% changelog color="removed" title="Stream removed from Go camera interface" date="2025-02-01" %}}
-
-The `Stream` API method has been removed from the Go SDK camera interface.
-For updated Go usage information, see [`GetImage`](/dev/reference/apis/components/camera/#getimage).
-
-{{% /changelog %}}
-
-{{% changelog color="changed" title="Subtype renamed to API" date="2025-01-28" %}}
-
-In the Python SDK, all references to `subtype` that refer to the {{< glossary_tooltip term_id="api-namespace-triplet" text="API namespace triplet" >}} have been renamed to `api` to be consistent with the RDK:
-
-- The `SUBTYPE` variable in every resource is now `API`
-
-- Registry method name changes:
-
-  - `register_subtype()` → `register_api()`
-  - `lookup_subtype()` → `lookup_api()`
-  - `REGISTERED_SUBTYPES()` → `REGISTERED_APIS()`
-
-- Parameter name changes:
-
-  - Methods like `register_resource_creator()`, `lookup_api()`, `lookup_resource_creator()`, and `lookup_validator()` now use `api` instead of `subtype` parameter names
-
-- DataClient changes:
-  - References to `resource_subtype` have been changed to `resource_api`
-  - Backwards compatibility is maintained with aliases and deprecation warnings
-
-Who is affected:
-
-- Users with unusual Python module implementations (not using the CLI module generator or `EasyResource`)
-- All users adding [custom APIs](/operate/reference/advanced-modules/create-subtype/)
-
-For example, if your module contains `Vision.SUBTYPE`, change it as follows:
-
-```python {class="line-numbers linkable-line-numbers"}
-# Old way
-module.add_model_from_registry(Vision.SUBTYPE, my_model.MODEL)
-
-# New way
-module.add_model_from_registry(Vision.API, my_model.MODEL)
-```
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Button API and switch API" date="2025-01-27" %}}
-
-Two new component APIs, the [button API](/dev/reference/apis/components/button/) and [switch API](/dev/reference/apis/components/switch/), have been added.
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Discovery service API" date="2025-01-27" %}}
-
-The [discovery service API](/dev/reference/apis/services/discovery/) has been added.
-You can now write modules that discover resources on a machine.
-
-{{% /changelog %}}
-
-{{% changelog color="removed" title="DiscoverComponents" date="2025-01-27" %}}
-
-The `DiscoverComponents` method has been removed from the machine management API.
-Instead, use a [discovery service](/operate/reference/services/discovery/) to discover resources on a machine.
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="OAuth" date="2025-01-27" %}}
-
-You can now [authenticate end users with OAuth](/manage/manage/oauth/).
-
-{{% /changelog %}}
-
-{{% changelog color="added" title="Over-the-air updates for the Micro-RDK" date="2025-01-08" %}}
-
-You can now update microcontroller firmware from anywhere using the [OTA update service](/operate/install/setup-micro/#configure-over-the-air-updates).
-
-{{% /changelog %}}
-
-{{% changelog date="2024-11-12" color="added" title="Builtin models moved to modules" %}}
-
-The following resource models have moved to modules.
-
-<!-- prettier-ignore -->
-| Resource | Model |
-| -------- | ----- |
-| arm | [`lite6`](https://app.viam.com/module/viam/ufactory) |
-| arm | [`xArm6`](https://app.viam.com/module/viam/ufactory) |
-| arm | [`xArm7`](https://app.viam.com/module/viam/ufactory) |
-| arm | [`ur5e`](https://app.viam.com/module/viam/universal-robots) |
-| board | [`customlinux`](https://app.viam.com/module/viam/customlinux) |
-| board | [`jetson`](https://app.viam.com/module/viam/nvidia) |
-| board | [`pca9685`](https://app.viam.com/module/viam/pca) |
-| board | [`odroid`](https://app.viam.com/module/viam/hardkernel) |
-| board | [`ti`](https://app.viam.com/module/viam/texas-instruments) |
-| board | [`pi`](https://app.viam.com/module/viam/raspberry-pi) |
-| board | [`orange-pi`](https://app.viam.com/module/viam/orange-pi) |
-| board | [`upboard`](https://app.viam.com/module/viam/up) |
-| motor | [`tmc5072`](https://app.viam.com/module/viam/analog-devices) |
-| motor | [`28byj-48`](https://app.viam.com/module/viam/uln2003) |
-| encoder | [`ams-as5048`](https://app.viam.com/module/viam/ams) |
-| movement sensor | [`adxl345`](https://app.viam.com/module/viam/analog-devices) |
-| movement sensor | [`dual-gps-rtk`](https://app.viam.com/module/viam/gps) |
-| movement sensor | [`gps-nmea-rtk-pmtk`](https://app.viam.com/module/viam/gps) |
-| movement sensor | [`gps-nmea-rtk-serial`](https://app.viam.com/module/viam/gps) |
-| movement sensor | [`gps-nmea`](https://app.viam.com/module/viam/gps) |
-| movement sensor | [`imu-wit`](https://app.viam.com/module/viam/wit-motionn) |
-| movement sensor | [`imu-wit-hwt905`](https://app.viam.com/module/viam/wit-motion) |
-| movement sensor | [`mpu6050`](https://app.viam.com/module/michaellee1019/mpu6050_orientation) |
-| power sensor | [`ina219`](https://app.viam.com/module/viam/texas-instruments) |
-| power sensor | [`ina226`](https://app.viam.com/module/viam/texas-instruments) |
-| power sensor | [`renogy`](https://app.viam.com/module/rand/renogy) |
-| sensor | [`bme280`](https://app.viam.com/module/viam/bosch) |
-| sensor | [`sensirion-sht3xd`](https://app.viam.com/module/viam/sensirion) |
-| sensor | [`pi`](https://app.viam.com/module/viam/raspberry-pi) |
-| sensor | [`ultrasonic`](https://app.viam.com/module/viam/ultrasonic) |
-| ML model | [`TFLite CPU`](https://app.viam.com/module/viam/tflite_cpu) |
-| vision service | [`obstacles-depth`](https://app.viam.com/module/viam/obstacles-pointcloud) |
-| vision service | [`obstacles-distance`](https://app.viam.com/module/viam/obstacles-distance) |
-| vision service | [`obstacles-pointcloud`](https://app.viam.com/module/viam/obstacles-pointcloud) |
-
-The following models were removed:
-
-<!-- prettier-ignore -->
-| Resource | Model |
-| -------- | ----- |
-| gripper | `softrobotics` |
-| motor | `encoded-motor` |
-| motor | `gpiostepper` |
-| motor | `roboclaw` |
-| sensor | `ds18b20` |
-
-{{% /changelog %}}
-
-{{% changelog date="2024-11-05" color="added" title="MoveThroughJointPositions to arm interface" %}}
-The [arm interface](/dev/reference/apis/components/arm/) now includes a [MoveThroughJointPositions](https://pkg.go.dev/go.viam.com/rdk/components/arm#Arm) method that moves an arm through an ordered array of joint positions.
-{{% /changelog %}}
-
-{{% changelog date="2024-10-16" color="added" title="Set data retention policies" %}}
-
-You can now set how long data collected by a component should remain stored in the Viam Cloud in the component's data capture configuration.
-For more information, see [Data management service](/data-ai/capture-data/capture-sync/).
-
-{{% /changelog %}}
-
-{{% changelog date="2024-09-20" color="added" title="Pi models moved to module" %}}
-
-The Raspberry Pi 4, 3, and Zero 2 W boards are now supported by [`viam:raspberry-pi:rpi`](https://app.viam.com/module/viam/raspberry-pi).
-
-{{% /changelog %}}
-
-{{% changelog date="2024-08-26" color="added" title="ESP32 cameras" %}}
-
-`viam-micro-server` now supports cameras on ESP32s.
-For more information, see [Configure an esp32-camera](/operate/reference/components/camera/esp32-camera/).
-
-{{% /changelog %}}
-
-{{% changelog date="2024-08-26" color="changed" title="Micro-RDK now called viam-micro-server" %}}
-
-The lightweight version of `viam-server` that is built from the Micro-RDK is now referred to as `viam-micro-server`.
-For more information, see [viam-micro-server](/operate/reference/viam-micro-server/).
-
-{{% /changelog %}}
-
-{{% changelog date="2024-08-26" color="added" title="Provisioning" %}}
-
-You can now configure provisioning for machines with the Viam Agent.
-For more information, see [Configure provisioning with viam-agent](/manage/fleet/provision/setup/).
-
-{{% /changelog %}}
-
-{{% changelog date="2024-08-16" color="added" title="Data capture for vision" %}}
-
-Data capture is now possible for the vision service.
-For more information, see [Supported components and services](/data-ai/capture-data/capture-sync/#click-to-see-resources-that-support-data-capture-and-cloud-sync).
-
-{{% /changelog %}}
-
-{{% changelog date="2024-08-01" color="added" title="Create custom training scripts" %}}
-
-You can now upload custom training scripts to the Viam Registry and use them to train machine learning models.
-For more information, see [Create custom training scripts](/data-ai/train/train/).
-
-{{% /changelog %}}
-
-{{% changelog date="2024-07-19" color="changed" title="Operators can now view data" %}}
-
-The operator role now has view permissions for the data in the respective resource a user has access to.
-For more information, see [Data and machine learning permissions](/manage/manage/rbac/#data-and-machine-learning).
-
-{{% /changelog %}}
-
-{{% changelog date="2024-06-14" color="changed" title="Python get_robot_part_logs parameters" %}}
-
-The `errors_only` parameter has been removed from [`get_robot_part_logs()`](/dev/reference/apis/fleet/#getrobotpartlogs) and replaced with `log_levels`.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-05-28" color="changed" title="Return type of analog Read" %}}
-
-The board analog API [`Read()`](/dev/reference/apis/components/board/#readanalogreader) method now returns an `AnalogValue` struct instead of a single int.
-The struct contains an int representing the value of the reading, min and max range of values, and the precision of the reading.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-05-28" color="added" title="CaptureAllFromCamera and GetProperties to vision API" %}}
-
-The vision service now supports two new methods: [`CaptureAllFromCamera`](/dev/reference/apis/services/vision/#captureallfromcamera) and [`GetProperties`](/dev/reference/apis/services/vision/#getproperties).
-
-{{% /changelog %}}
-
-{{% changelog date="2024-05-14" color="changed" title="Renamed GeoObstacle to GeoGeometry" %}}
-
-The motion service API parameter `GeoObstacle` has been renamed to `GeoGeometry`.
-This affects users of the [`MoveOnGlobe()`](/dev/reference/apis/services/motion/#moveonglobe) method.
-
-{{% /changelog %}}
-
-{{< changelog date="2024-05-09" color="changed" title="Return type of GetImage" >}}
-
-The Python SDK introduced a new image container class called [`ViamImage`](https://python.viam.dev/autoapi/viam/components/camera/index.html#viam.components.camera.ViamImage).
-The camera component's [`GetImage()`](/dev/reference/apis/components/camera/#getimage) method now returns a `ViamImage` type, and the vision service's [`GetDetections()`](/dev/reference/apis/services/vision/#getdetections) and [`GetClassifications()`](/dev/reference/apis/services/vision/#getclassifications) methods take in `ViamImage` as a parameter.
-
-You can use the helper functions `viam_to_pil_image` and `pil_to_viam_image` provided by the Python SDK to convert the `ViamImage` into a [`PIL Image`](https://omz-software.com/pythonista/docs/ios/Image.html) and vice versa.
-
-{{< expand "Click for an example of using the ViamImage -> PIL Image helper functions." >}}
-
-```python {class="line-numbers linkable-line-numbers"}
-from viam.media.utils.pil import pil_to_viam_image, viam_to_pil_image
-
-# Get the ViamImage from your camera.
-frame = await my_camera.get_image()
-
-# Convert "frame" to a PIL Image representation.
-pil_frame = viam_to_pil_image(frame)
-
-# Use methods from the PIL Image class to get size.
-x, y = pil_frame.size[0], pil_frame.size[1]
-# Crop image to get only the left two fifths of the original image.
-cropped_pil_frame = pil_frame.crop((0, 0, x / 2.5, y))
-
-# Convert back to ViamImage.
-cropped_frame = pil_to_viam_image(cropped_pil_frame)
-
-# Get detections from your vision service.
-detections = await detector.get_detections(cropped_frame)
-```
-
-{{< /expand >}}
-{{< /changelog >}}
-
-{{% changelog date="2024-05-08" color="removed" title="WriteAnalog from Go SDK" %}}
-
-The `WriteAnalog()` method has been removed from the Go SDK.
-Use [`AnalogByName()`](/dev/reference/apis/components/board/#analogbyname) followed by [`Write()`](/dev/reference/apis/components/board/#writeanalog) instead.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-04-30" color="changed" title="Python SDK data retrieval behavior" %}}
-
-[`tabular_data_by_filter()`](/dev/reference/apis/data-client/#tabulardatabyfilter) and [`binary_data_by_filter()`](/dev/reference/apis/data-client/#binarydatabyfilter) now return paginated data.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-04-30" color="changed" title="Renamed AnalogReader to Analog" %}}
-
-`AnalogReader` has been renamed to `Analog`.
-The functionality remains the same, but code that uses analogs must be updated.
-`AnalogReaderByName()` and `AnalogReaderNames()` have become [`AnalogByName()`](/dev/reference/apis/components/board/#analogbyname) and `AnalogNames()` (since deprecated), respectively.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-04-30" color="added" title="Part online and part offline triggers" %}}
-
-You can now configure [triggers](/manage/troubleshoot/alert/) to execute actions when a {{< glossary_tooltip term_id="part" text="machine part" >}} comes online or goes offline.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-04-30" color="removed" title="Status from Board API" %}}
-
-Viam has removed support for the following board API methods: `Status()`, `AnalogStatus()`, `DigitalInterruptStatus()`, `Close()`, `Tick()`, `AddCallback()`, and `RemoveCallback()`.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-04-19" color="removed" title="Removed and replaced camera models" %}}
-
-Viam has removed support for following builtin camera models: `single_stream`, `dual_stream`, `align_color_depth_extrinsics`, and `align_color_depth_homography`.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-04-17" color="changed" title="Updated GetCloudMetadata response" %}}
-
-In addition to the existing returned metadata, the [`GetCloudMetadata`](/dev/reference/apis/robot/#getcloudmetadata) method now returns `machine_id` and `machine_part_id` as well.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-04-16" color="improved" title="Viam web UI" %}}
-
-The machine page UI has been updated significantly.
-In addition to other improvements, your component, service, and other resource config cards are all displayed on one page instead of in separate tabs.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-03-01" color="added" title="Additional ML models" %}}
-
-Viam has added support for the TensorFlow, PyTorch, and ONNX ML model frameworks, expanding upon the existing support for TensorFlow Lite models.
-You can now upload your own ML model using any of these frameworks for use with the Vision service.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-03-01" color="added" title="Ultrasonic sensor for `viam-micro-server`" %}}
-
-You can now use the [ultrasonic sensor component](/operate/reference/components/sensor/ultrasonic-micro-rdk/) with [`viam-micro-server`](/operate/reference/viam-micro-server/) to integrate an [HC-S204](https://www.sparkfun.com/products/15569) ultrasonic distance sensor into a machine running `viam-micro-server`.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-03-01" color="added" title="Edit a machine configuration that uses a fragment" %}}
-
-You can now edit the configuration of an existing machine that has been configured with a fragment by using [the `fragment_mods` object](/manage/fleet/reuse-configuration/#modify-fragment-settings-on-a-machine) in your configuration.
-You can use the `fragment_mods` objects to be able to deploy a fragment to a fleet of machines, but still be able to make additional per-machine edits as needed.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-03-01" color="added" title="Dual GPS movement sensor" %}}
-
-You can now use the [dual GPS movement sensor component](https://github.com/viam-modules/gps) to integrate a movement sensor that employs two GPS sensors into your machine.
-The dual GPS movement sensor calculates a compass heading from both GPS sensors, and returns the midpoint position between the two sensors as its position.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-03-01" color="added" title="Viam Agent" %}}
-
-You can now use the [Viam Agent](/manage/reference/viam-agent/) to provision your machine or fleet of machines during deployment.
-The Viam Agent is a software provisioning manager that you can install on your machine which manages your `viam-server` installation, including installation and ongoing updates, as well as providing flexible deployment configuration options, such as pre-configured WiFi network credentials.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-02-12" color="added" title="Generic service" %}}
-
-You can now use the [generic service](/operate/reference/components/generic/) to define new, unique types of services that do not already have an [appropriate API](/dev/reference/apis/#service-apis) defined for them.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-02-12" color="added" title="ML models in the registry" %}}
-
-You can now upload machine learning (ML) models to the Viam Registry, in addition to modules.
-You may upload models you have trained yourself using Viam, or models you have trained outside of Viam.
-When uploading, you have the option to make your model available to the general public for reuse.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-01-31" color="added" title="Sensor-controlled base" %}}
-
-Viam has added a [sensor-controlled base](/operate/reference/components/base/sensor-controlled/) component model, which supports a robotic base that receives feedback control from a movement sensor.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-01-31" color="added" title="Visualize captured data" %}}
-
-You can now [visualize your data](/data-ai/data/visualize/) using many popular third-party visualization tools, including Grafana, Tableau, Google's Looker Studio, and more.
-You can visualize any data, such as sensor readings, that you have [synced](/data-ai/capture-data/capture-sync/) to Viam from your machine.
-
-{{% /changelog %}}
-
-{{% changelog date="2024-01-31" color="added" title="Use triggers to trigger actions" %}}
-
-You can now configure [triggers](/data-ai/data/alert-data/) (previously called webhooks) to execute actions when certain types of data are sent from your machine to the cloud.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-12-31" color="added" title="Filtered camera module" %}}
-
-Viam has added a [`filtered-camera` module](https://app.viam.com/module/erh/filtered-camera) that selectively captures and syncs only the images that match the detections of an ML model.
-For example, you could train an ML model that is focused on sports cars, and only capture images from the camera feed when a sports car is detected in the frame.
-
-Check out [this guide](/data-ai/capture-data/filter-before-sync/) for more information.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-12-31" color="added" title="Raspberry Pi 5 Support" %}}
-
-You can now run `viam-server` on a Raspberry Pi 5 with the new board model [`pi5`](https://app.viam.com/module/viam/raspberry-pi).
-
-{{% /changelog %}}
-
-{{% changelog date="2023-12-31" color="added" title="Role-based access control" %}}
-
-Users can now have [access to different fleet management capabilities](/manage/manage/rbac/) depending on whether they are an owner or an operator of a given organization, location, or machine.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-11-30" color="added" title="Authenticate with location API key" %}}
-
-You can now use [API keys for authentication](/dev/tools/cli/#authenticate).
-API keys allow you to assign the minimum required permissions for usage.
-Location secrets, the previous method of authentication, is deprecated and will be removed in a future release.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-11-30" color="added" title="Queryable sensor data" %}}
-
-Once you have added the data management service and synced data, such as sensor readings, to Viam, you can now run queries against both captured data as well as its metadata using either SQL or MQL.
-
-For more information, see [Query Data with SQL or MQL](/data-ai/data/query/).
-
-{{% /changelog %}}
-
-{{% changelog date="2023-11-30" color="changed" title="Model training from datasets" %}}
-
-To make it easier to iterate while training machine learning models from image data, you now train models from [datasets](/data-ai/train/create-dataset/).
-
-{{% /changelog %}}
-
-{{% changelog date="2023-11-30" color="improved" title="Manage users access" %}}
-
-You can now manage users access to machines, locations, and organizations.
-For more information, see [Access Control](/manage/manage/rbac/)
-
-{{% /changelog %}}
-
-{{% changelog date="2023-10-31" color="added" title="Test an ML model in browser" %}}
-
-After you upload and train a machine learning model, you can test its results in the **Data** tab.
-
-This allows you to refine models by iteratively tagging more images for training based on observed performance.
-
-For more information, see [Test classification models with existing images in the cloud](/operate/reference/services/vision/mlmodel/#existing-images-in-the-cloud).
-
-To use this update, the classifier must have been trained or uploaded after September 19, 2023.
-The current version of this feature exclusively supports classification models.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-10-31" color="added" title="PLC support" %}}
-
-The Viam platform now supports the [Revolution Pi line of PLCs](https://revolutionpi.com/) from KUNBUS in the form of a [module](https://app.viam.com/module/viam-labs/viam-revolution-pi).
-This collaboration allows you to leverage the Raspberry Pi-based Revolution Pi, which runs on Linux and has a [specially designed I/O modules](https://www.raspberrypi.com/products/compute-module-4/?variant=raspberry-pi-cm4001000) for streamlined interaction with industrial controls, eliminating the need for additional components.
-
-Read the [Viam PLC Support](https://www.viam.com/post/viam-plc-support-democratizing-access-to-smart-ot-and-ics) blog post for a step-by-step guide on using a PLC with Viam.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-10-31" color="improved" title="SLAM map creation" %}}
-
-The [Cartographer-module](/operate/reference/services/slam/cartographer/) now runs in Viam's cloud for creating or updating maps.
-This enhancement allows you to:
-
-- Generate larger maps without encountering session timeouts
-- Provide IMU input to improve map quality
-- Save maps to the **SLAM library**
-- Create or update maps using previously captured LiDAR and IMU data
-- Deploy maps to machines
-
-{{% /changelog %}}
-
-{{% changelog date="2023-09-30" color="added" title="Modular registry" %}}
-
-The [registry](https://app.viam.com/registry/) enables you to use, create, and share custom modules, extending the capabilities of Viam beyond the components and services that are natively supported.
-
-You can:
-
-- Publish modules on the registry
-- Add modules to any machine's configuration with a few clicks
-- Select the desired module version for deployment, make changes at your convenience, and deploy the updates to a single machine or an entire fleet.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-09-30" color="added" title="Mobile app" %}}
-
-You can use a [mobile application](/manage/troubleshoot/teleoperate/default-interface/#viam-mobile-app), available for download now in the [Apple](https://apps.apple.com/us/app/viam-robotics/id6451424162) and [Google Play](https://play.google.com/store/apps/details?id=com.viam.viammobile&hl=en&gl=US) app stores, to connect to and control your Viam-powered machines directly from your mobile device.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-09-30" color="added" title="Power sensor component" %}}
-
-You now have the capability to use a [power sensor component](/operate/reference/components/power-sensor/) to monitor the voltage, current, and power consumption within your machine's system.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-09-30" color="added" title="Filter component's data before the cloud" %}}
-Viam has written a module that allows you to filter data based on specific criteria before syncing it to [Viam's cloud](/data-ai/capture-data/capture-sync/).
-It equips machines to:
-
-- Remove data that is not of interest
-- Facilitate high-interval captures while saving data based on your defined metrics
-- Prevent the upload of unnecessary data
-
-To learn more, see [this tutorial](/tutorials/configure/pet-photographer/) on creating and configuring a data filtration module.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-08-31" color="added" title="Configure a custom Linux board" %}}
-
-You can now use boards like the [Mediatek Genio 500 Pumpkin](https://ologicinc.com/portfolio/mediateki500/) that run Linux operating systems with the [`customlinux` board model](https://github.com/viam-modules/customlinux/).
-
-{{% /changelog %}}
-
-{{% changelog date="2023-08-31" color="improved" title="Image inspection for ML training" %}}
-
-This update enables you to get a closer examination of your image and streamline your image annotation experience by making it easier to add bounding boxes and labels in the **Data** tab.
-
-With the latest improvements, you can now:
-
-- Navigate between images using the arrow keys in the main image view
-- Expand images for a more detailed inspection by clicking the expand button on the right image panel
-- Move between full-screen images effortlessly with the <> arrow buttons or arrow keys
-- Return to the standard view by using the escape key or collapse button
-
-{{% /changelog %}}
-
-{{% changelog date="2023-08-31" color="added" title="Duplicate component button" %}}
-
-You now have the ability to duplicate any config component, service, module, remote, or process.
-
-To use this feature:
-
-- Click on the duplicate component icon at the top right of any resource
-- Optionally, you can modify the component name to distinguish it
-- Adjust any attributes, such as motor pin numbers
-
-{{% /changelog %}}
-
-{{% changelog date="2023-07-31" color="added" title="Apple SSO authentication" %}}
-
-Viam now supports sign-up/log-in through Apple Single Sign-On.
-
-Note that currently, accounts from different SSO providers are treated separately, with no account merging functionality.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-07-31" color="improved" title="Arm component API" %}}
-
-Arm models now support the [`GetKinematics` method](/dev/reference/apis/components/arm/#getkinematics) in the arm API, allowing you to request and receive kinematic information.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-06-30" color="added" title="View sensor data within Viam" %}}
-
-You can now [view your sensor data](https://app.viam.com/data/view?view=sensors) directly in the web UI to verify data creation and accuracy.
-If you depend on sensor data to plan and control machine operations, this feature increases access to data and supports a more efficient workflow.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-06-30" color="added" title="Session management in the Python SDK" %}}
-
-The Python SDK now includes sessions, a safety feature that automatically cancels operations if the client loses connection to your machine.
-
-[Session management](/dev/reference/apis/sessions/) helps you to ensure safer operation of your machine when dealing with actuating controls.
-Sessions are enabled by default, with the option to [disable sessions](/dev/reference/apis/sessions/#disable-default-session-management).
-
-{{% /changelog %}}
-
-{{% changelog date="2023-06-30" color="added" title="Connect an ODrive motor controller as a Viam module" %}}
-
-You can integrate and control ODrive motor controllers with Viam using the [`odrive` module from the registry](https://github.com/viamrobotics/odrive).
-
-See the [Odrive module readme](https://github.com/viamrobotics/odrive) to learn how to connect and use an ODrive motor controller with Viam, and view the sample configurations.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-06-30" color="added" title="Implement custom robotic arms as Viam modules" %}}
-
-When prototyping a robotic arm, you can now facilitate movement without creating your own motion planning.
-This update enables you to implement custom models of an arm component as a modular resource by coding three endpoints of the [Arm API](/dev/reference/apis/components/arm/#api):
-
-- `getJointPositions`
-- `movetoJointPositions`
-- `GetKinematics`
-
-Then, use the [motion planning service](/operate/reference/services/motion/) to specify poses, and Viam handles the rest.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-06-30" color="improved" title="Gantry component" %}}
-
-To better control gantries with Viam, you can now:
-
-- Specify speed values when calling the `MovetoPosition` method on [Gantry components](/operate/reference/components/gantry/).
-  This allows you to define the speed at which each axis moves to the desired position, providing enhanced precision and control over the gantry's movement.
-- Set a home position for Gantry components to facilitate position resetting or maintain consistent starting points.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-06-30" color="improved" title="Optimized Viam-trained object detection models" %}}
-
-This update for TFlite object detection models [trained with the machine learning service](/data-ai/train/train-tf-tflite/) brings significant improvements, including:
-
-- 76% faster model inference for camera streams
-- 64% quicker model training for object detection
-- 46% reduction in compressed model size
-
-{{% /changelog %}}
-
-{{% changelog date="2023-05-31" color="added" title="TypeScript SDK beta release" %}}
-
-The beta release of the [TypeScript SDK](https://github.com/viamrobotics/viam-typescript-sdk/) allows you to create a web interface to work with your machine, as well as create custom components and services.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-05-31" color="added" title="Train object detection ML models" %}}
-
-You now have the capability to directly [train a TFlite object detection models](/data-ai/train/train-tf-tflite/).
-
-This update allows you to:
-
-- Add labels by drawing bounding boxes around specific objects in your images or a single image.
-- Create a curated subset of data for training by filtering images based on labels or tags.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-05-31" color="added" title="Permissions for organizations in Viam" %}}
-
-Now when you invite collaborators to join your organization, you can assign permissions to members by setting one of these roles:
-
-- **Owner**: These members can see and edit every tab on the machine page, as well as manage users in the app.
-  This role is best for those on your team who are actively engineering and building machines.
-
-- **Operator**: These members can only see and use the [remote control tab](/manage/troubleshoot/teleoperate/default-interface/).
-  This role is best for those on your team who are teleoperating or remotely controlling machines.
-
-For more information about assigning permissions and collaborating with others on Viam, see [Manage access](/manage/manage/access/).
-
-{{% /changelog %}}
-
-{{% changelog date="2023-05-31" color="improved" title="Control RoboClaw motor controllers with the driver" %}}
-
-When using a RoboClaw motor controller without encoders connected to your motors, you now have more direct control over the RoboClaw's functionality within the web UI or through the motor API.
-
-For example, in the web UI, you can now set **Go For** values for these motors, utilizing a time-based estimation for the number of revolutions.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-05-31" color="improved" title="Camera webcam names and setting framerates" %}}
-
-The updates to the camera component have improved the process of connecting to and using cameras with your machines.
-
-The latest updates enable you to:
-
-- View readable webcam names in the **video path** of your camera component.
-- Specify your preferred framerate by selecting the desired value in the newly added **framerate field** on the **CONFIGURE** tab.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-05-31" color="improved" title="Additions to code samples" %}}
-
-The updated code samples now includes:
-
-- Options for C++ and TypeScript
-- The ability to hide or display your machines' [secrets](/dev/reference/apis/)
-
-Access these samples in the **Code sample** tab on your machine's page to connect to your machine in various languages.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-05-31" color="improved" title="Delete data in bulk" %}}
-
-You can manage the data synced to Viam's cloud with the new capability for bulk data deletion on the **Data** tab.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-04-25" color="changed" title="Vision service" %}}
-
-{{% alert title="Important: Breaking Change" color="note" %}}
-
-The [vision service](/operate/reference/services/vision/) became more modular in RDK [v0.2.36](https://github.com/viamrobotics/rdk/releases/tag/v0.2.36), API [v0.1.118](https://github.com/viamrobotics/api/releases/tag/v0.1.118), and Python SDK [v0.2.18](https://github.com/viamrobotics/viam-python-sdk/releases/tag/v0.2.18).
-
-Find more information on each of the changes below.
-
-{{% /alert %}}
-
-<!-- markdownlint-disable MD001 -->
-
-#### Use individual vision service instances
-
-You need to create **an individual vision service instance** for each detector, classifier, and segmenter model.
-You can no longer be able to create one vision service and register all of your detectors, classifiers, and segmenters within it.
-
-{{%expand "Click for details on how to migrate your code." %}}
-
-#### API calls
-
-Change your existing API calls to get the new vision service instance for your detector, classifier, or segmenter model directly from the `VisionClient`:
-
-{{< tabs >}}
-{{% tab name="New Way" %}}
-
-Change your existing API calls to get the new vision service instance for your detector, classifier, or segmenter model directly from the `VisionClient`:
-
-```python {class="line-numbers linkable-line-numbers"}
-my_object_detector = VisionClient.from_robot(robot, "find_objects")
-img = await cam.get_image()
-detections = await my_object_detector.get_detections(img)
-```
-
-{{% /tab %}}
-{{% tab name="Old Way" %}}
-
-```python {class="line-numbers linkable-line-numbers"}
-vision = VisionServiceClient.from_robot(robot)
-img = await cam.get_image()
-detections = await vision.get_detections(img, "find_objects")
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-#### Color detector configurations
-
-You can replace existing color detectors by [configuring new ones in the UI](/operate/reference/services/vision/color_detector/) or you can update the JSON configuration of your machines:
-
-{{< tabs >}}
-{{% tab name="New Way" %}}
-
-```json
-"services": [
-    {
-        "name": "blue_square",
-        "type": "vision",
-        "model": "color_detector",
-        "attributes": {
-            "segment_size_px": 100,
-            "detect_color": "#1C4599",
-            "hue_tolerance_pct": 0.07,
-            "value_cutoff_pct": 0.15
-        }
-    },
-    {
-        "name": "green_triangle",
-        "type": "vision",
-        "model": "color_detector",
-        "attributes": {
-            "segment_size_px": 200,
-            "detect_color": "#62963F",
-            "hue_tolerance_pct": 0.05,
-            "value_cutoff_pct": 0.20
-        }
-    },
-    ... // other services
-]
-```
-
-{{% /tab %}}
-{{% tab name="Old Way" %}}
-
-```json
-"services": [
-    {
-        "name": "vision",
-        "type": "vision",
-        "attributes": {
-            "register_models": [
-            {
-                "parameters": {
-                    "segment_size_px": 100,
-                    "detect_color": "#1C4599",
-                    "hue_tolerance_pct": 0.07,
-                    "value_cutoff_pct": 0.15
-                },
-                "name": "blue_square",
-                "type": "color_detector"
-            },
-            {
-                "parameters": {
-                    "segment_size_px": 200,
-                    "detect_color": "#62963F",
-                    "hue_tolerance_pct": 0.05,
-                    "value_cutoff_pct": 0.20
-                },
-                "name": "green_triangle",
-                "type": "color_detector"
-            }
-            ]
-        }
-    },
-    ... // other services
-]
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-#### TFLite detector configurations
-
-You can replace existing TFLite detectors by [configuring new ones in the UI](/operate/reference/services/vision/mlmodel/) or you can update the JSON configuration of your machines:
-
-{{< tabs >}}
-{{% tab name="New Way" %}}
-
-```json
-"services": [
-    {
-        "name": "person_detector",
-        "type": "mlmodel",
-        "model": "tflite_cpu",
-        "attributes": {
-            "model_path": "/path/to/file.tflite",
-            "label_path": "/path/to/labels.tflite",
-            "num_threads": 1
-        }
-    },
-    {
-        "name": "person_detector",
-        "type": "vision",
-        "model": "mlmodel",
-        "attributes": {
-            "mlmodel_name": "person_detector"
-        }
-    },
-    ... // other services
-]
-```
-
-{{% /tab %}}
-{{% tab name="Old Way" %}}
-
-```json
-"services": [
-    {
-        "name": "vision",
-        "type": "vision",
-        "attributes": {
-            "register_models": [
-            {
-                "parameters": {
-                    "model_path": "/path/to/file.tflite",
-                    "label_path": "/path/to/labels.tflite",
-                    "num_threads": 1
-                },
-                "name": "person_detector",
-                "type": "tflite_detector"
-            }
-            ]
-        }
-    },
-    ... // other services
-]
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-#### TFLite Classifier configurations
-
-You can replace existing TFLite classifiers by [configuring new ones in the UI](/operate/reference/services/vision/mlmodel/) or you can update the JSON configuration of your machines:
-
-{{< tabs >}}
-{{% tab name="New Way" %}}
-
-```json
-"services": [
-    {
-        "name": "fruit_classifier",
-        "type": "mlmodel",
-        "model": "tflite_cpu",
-        "attributes": {
-            "model_path": "/path/to/classifier_file.tflite",
-            "label_path": "/path/to/classifier_labels.txt",
-            "num_threads": 1
-        }
-    },
-    {
-        "name": "fruit_classifier",
-        "type": "vision",
-        "model": "mlmodel",
-        "attributes": {
-            "mlmodel_name": "fruit_classifier"
-        }
-    },
-    ... // other services
-]
-```
-
-{{% /tab %}}
-{{% tab name="Old Way" %}}
-
-```json
-"services": [
-    {
-        "name": "vision",
-        "type": "vision",
-        "attributes": {
-            "register_models": [
-            {
-                "parameters": {
-                    "model_path": "/path/to/classifier_file.tflite",
-                    "label_path": "/path/to/classifier_labels.txt",
-                    "num_threads": 1
-                },
-                "name": "fruit_classifier",
-                "type": "tflite_classifier"
-            }
-            ]
-        }
-    },
-    ... // other services
-]
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-#### Radius Clustering 3D segmenter configurations
-
-You can replace existing Radius Clustering 3D segmenters by [configuring new ones in the UI](https://app.viam.com/module/viam/obstacles-pointcloud) or you can update the JSON configuration of your machines:
-
-{{< tabs >}}
-{{% tab name="New Way" %}}
-
-```json
-"services": [
-    {
-        "name": "rc_segmenter",
-        "type": "vision",
-        "model": "obstacles_pointcloud"
-        "attributes": {
-            "min_points_in_plane": 1000,
-            "min_points_in_segment": 50,
-            "clustering_radius_mm": 3.2,
-            "mean_k_filtering": 10
-        }
-    },
-    ... // other services
-]
-```
-
-{{% /tab %}}
-{{% tab name="Old Way" %}}
-
-```json
-"services": [
-    {
-        "name": "vision",
-        "type": "vision",
-        "attributes": {
-            "register_models": [
-            {
-                "parameters": {
-                    "min_points_in_plane": 1000,
-                    "min_points_in_segment": 50,
-                    "clustering_radius_mm": 3.2,
-                    "mean_k_filtering": 10
-                },
-                "name": "rc_segmenter",
-                "type": "radius_clustering_segmenter"
-            }
-            ]
-        }
-    },
-    ... // other services
-]
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-#### Detector to 3D segmenter configurations
-
-You can replace existing Radius Clustering 3D segmenters by [configuring new ones in the UI](/operate/reference/services/vision/detector_3d_segmenter/) or you can update the JSON configuration of your machines:
-
-{{< tabs >}}
-{{% tab name="New Way" %}}
-
-```json
-"services": [
-    {
-        "name": "my_segmenter",
-        "type": "vision",
-        "model": "detector_3d_segmenter"
-        "attributes": {
-            "detector_name": "my_detector",
-            "confidence_threshold_pct": 0.5,
-            "mean_k": 50,
-            "sigma": 2.0
-        }
-    },
-    ... // other services
-]
-```
-
-{{% /tab %}}
-{{% tab name="Old Way" %}}
-
-```json
-"services": [
-    {
-        "name": "vision",
-        "type": "vision",
-        "attributes": {
-            "register_models": [
-            {
-                "parameters": {
-                    "detector_name": "my_detector",
-                    "confidence_threshold_pct": 0.5,
-                    "mean_k": 50,
-                    "sigma": 2.0
-                },
-                "name": "my_segmenter",
-                "type": "detector_segmenter"
-            }
-            ]
-        }
-    },
-    ... // other services
-]
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-{{% /expand%}}
-
-#### Add and remove models using the machine config
-
-You must add and remove models using the [machine config](/operate/modules/configure-modules/#configure-hardware-or-software-on-your-machine).
-You will no longer be able to add or remove models using the SDKs.
-
-#### Add machine learning vision models to a vision service
-
-The way to add machine learning vision models is changing.
-You will need to first register the machine learning model file with the [ML model service](/data-ai/ai/deploy/) and then add that registered model to a vision service.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-03-31" color="added" title="Machine learning for image classification models" %}}
-
-You can now [train](/data-ai/train/train-tf-tflite/) and [deploy](/data-ai/ai/deploy/) image classification models with the [data management service](/data-ai/capture-data/capture-sync/) and use your machine's image data directly within Viam.
-Additionally, you can upload and use existing machine learning models with your machines.
-For more information on using data synced to the cloud to train machine learning models, read [train a TFlite](/data-ai/train/train-tf-tflite/) or [another model](/data-ai/train/train/).
-
-{{% /changelog %}}
-
-{{% changelog date="2023-03-31" color="added" title="Motion planning with new `constraint` parameter" %}}
-
-A new parameter, [`constraint`](/operate/reference/services/motion/constraints/), has been added to the [Motion service API](/dev/reference/apis/services/motion/#api), allowing you to define restrictions on the machine's movement.
-The constraint system also provides flexibility to specify that obstacles should only impact specific frames of a machine.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-03-31" color="added" title="Fragments in machine configuration" %}}
-
-You can now access {{< glossary_tooltip term_id="fragment" text="fragments" >}} in your machine configuration.
-The configurations you added will now show up automatically in the **Builder** view on your machine's **CONFIGURE** tab.
-This makes it easier to monitor what fragments you've added to your machine and how they're configured.
-
-For more information, see [Fragments](/manage/fleet/reuse-configuration/).
-
-{{% /changelog %}}
-
-{{% changelog date="2023-03-31" color="improved" title="Sticky GPS keys" %}}
-
-GPS keys you enter are now saved in your local storage.
-This ensures that when you reload the page, your GPS keys remain accessible.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-03-31" color="improved" title="More reliable camera streams" %}}
-
-The camera component's streams are smoother and more reliable with recent improvements.
-
-Additionally, camera streams automatically restart if you momentarily lose internet connection.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-03-31" color="improved" title="UI updates to Logs and History" %}}
-
-The latest UI updates enable you to:
-
-- Load a previous configuration for reverting changes made in the past
-- Search logs by filtering keywords or log levels such as _info_ or _error_ messages
-- Change your timestamp format to **ISO** or **Local** depending on your preference.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-02-28" color="added" title="Rover reuse in Try Viam" %}}
-
-You now have the option to reuse a machine config from a previous Try Viam session.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-02-28" color="added" title="TypeScript SDK" %}}
-
-Find more information in the [TypeScript SDK docs](https://ts.viam.dev/).
-
-{{% /changelog %}}
-
-{{% changelog date="2023-02-28" color="added" title="Frame system visualizer" %}}
-
-When adding [frames](/operate/reference/services/frame-system/) to your machine's config, you can now use the **Frame System** subtab of the **CONFIGURE** tab to more easily visualize the relative positions of frames.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-02-28" color="added" title="Support for microcontrollers" %}}
-
-`viam-micro-server` is a lightweight version of `viam-server` that can run on an ESP32.
-Find more information in the [`viam-micro-server` docs](/operate/reference/viam-micro-server/).
-
-{{% /changelog %}}
-
-{{% changelog date="2023-01-31" color="added" title="Remote control power input" %}}
-
-On your machine's **CONTROL** tab, you can now set the power of a [base](/operate/reference/components/base/).
-The base control UI previously always sent 100% power to the base's motors.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-01-31" color="added" title="New encoder model: AMS AS5048" %}}
-
-The [AMS AS5048](https://github.com/viam-modules/ams) is now supported.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-01-31" color="added" title="GetLinearAcceleration method" %}}
-
-The movement sensor API now includes a [GetLinearAcceleration](/dev/reference/apis/components/movement-sensor/#getlinearacceleration) method.
-
-{{% /changelog %}}
-
-{{% changelog date="2023-01-31" color="added" title="Support for capsule geometry" %}}
-
-The [motion service](/operate/reference/services/motion/) now supports capsule geometries.
-
-The UR5 arm model has been improved using this new geometry type.
-
-{{% /changelog %}}
-
-{{% changelog date="2022-12-28" color="added" title="Modular resources" %}}
-
-You can now implement your own custom {{< glossary_tooltip term_id="resource" text="resources" >}} as _modular resources_ in the [registry](https://app.viam.com/registry/).
-
-{{% alert title="Important: Breaking Change" color="note" %}}
-
-All users need to update to the latest version of the RDK (V3.0.0) to access machines using the web UI.
-
-{{% /alert %}}
-
-{{% /changelog %}}
-
-{{% changelog date="2022-12-28" color="added" title="URDF kinematic file support" %}}
-
-You can now supply kinematic information using URDF files when implementing your own arm models.
-
-{{% /changelog %}}
-
-{{% changelog date="2022-12-28" color="added" title="New movement sensor models" %}}
-
-There are two new movement sensor {{< glossary_tooltip term_id="model" text="models" >}}:
-
-- [ADXL345](https://github.com/viam-modules/analog-devices): A 3-axis accelerometer
-- [MPU-6050](https://github.com/viam-modules/tdk-invensense): A 6-axis accelerometer and gyroscope
-
-{{% /changelog %}}
-
-{{% changelog date="2022-12-28" color="improved" title="Camera performance and reliability" %}}
-
-- Improved server-side logic to choose a mime type based on the camera image type, unless a specified mime type is supplied in the request.
-  **The default mime type for color cameras is now JPEG**, which improves the streaming rate across every SDK.
-- Added discoverability when a camera reconnects without changing video paths.
-  This now triggers the camera discovery process, where previously users would need to manually restart the RDK to reconnect to the camera.
-
-{{% /changelog %}}
-
-{{% changelog date="2022-12-28" color="improved" title="Motion planning with remote components" %}}
-
-The [motion service](/operate/reference/services/motion/) is now agnostic to the networking topology of a machine.
-
-- Kinematic information is now transferred over the robot API.
-  This means that the motion service is able to get kinematic information for every component on the machine, regardless of whether it is on a main or remote viam-server.
-- Arms are now an input to the motion service.
-  This means that the motion service can plan for a machine that has an arm component regardless of whether the arm is connected to a main or {{< glossary_tooltip term_id="remote-part" text="remote-part" >}} instance of `viam-server`.
-
-{{% /changelog %}}
-
-{{% changelog date="2022-12-28" color="improved" title="Motion planning path smoothing" %}}
-
-- RRT\* paths now undergo rudimentary smoothing, resulting in improvements to path quality with negligible change to planning performance.
-- Plan manager now performs direct interpolation for any solution within some factor of the best score, instead of only in the case where the best inverse kinematics solution could be interpolated.
-
-{{% /changelog %}}
-
-{{% changelog date="2022-12-28" color="improved" title="Data synchronization reliability" %}}
-
-Previously, data synchronization used bidirectional streaming.
-Now is uses a simpler unary approach that is more performant on batched unary calls, is easier to load balance, and maintains ordered captures.
-
-{{% /changelog %}}
-
-{{% changelog date="2022-11-28" color="changed" title="Camera configuration" %}}
-
-**Changed** the configuration schemes for the following camera models:
-
-- Webcam
-- FFmpeg
-- Transform
-- Join pointclouds
-
-For information on configuring any camera model, see [Camera Component](/operate/reference/components/camera/).
-
-{{% /changelog %}}
-
-{{% changelog date="2022-11-15" color="added" title="New servo model" %}}
-
-A new [servo model called `gpio`](/operate/reference/components/servo/gpio/) supports servos connected to non-Raspberry Pi boards.
-
-{{% /changelog %}}
-
-{{% changelog date="2022-11-15" color="added" title="RTT indicator in the app" %}}
-
-A badge in the web UI now displays RTT (round trip time) of a request from your client to the machine.
-Find this indicator of the time to complete one request/response cycle on your machine's **CONTROL** tab, in the **Operations & Sessions** card.
-
-{{% /changelog %}}
-
-{{% changelog date="2022-11-15" color="added" title="Python 3.8 support" %}}
-
-The Python SDK now supports Python 3.8 and newer.
-We suggest using Python 3.10 or newer.
-{{% /changelog %}}
-
-{{% changelog date="2022-11-15" color="added" title="New parameter: `extra`" %}}
-
-A new API method parameter, `extra`, allows you to extend {{< glossary_tooltip term_id="modular-resource" text="modular resource" >}} functionality by implementing the new field according to whatever logic you choose.
-`extra` has been added to the following APIs: arm, data management, gripper, input controller, motion, movement sensor, navigation, pose tracker, sensor, SLAM, vision.
-
-{{% alert title="IMPORTANT: Breaking change" color="note" %}}
-
-Users of the Go SDK _must_ update code to specify `extra` in the arguments that pass into each request.
-
-`extra` is an optional parameter in the Python SDK.
-
-{{% /alert %}}
-
-{{% /changelog %}}
-
-{{% changelog date="2022-11-15" color="added" title="Service dependencies" %}}
-
-`viam-server` now initializes and configures resources in the correct order.
-For example, if the SLAM service depends on a LiDAR, it will always initialize the LiDAR before the SLAM service.
-
-{{% alert title="IMPORTANT: Breaking change" color="note" %}}
-
-If you are using the SLAM service, you now need to specify sensors used by the SLAM service in the `depends_on` field of the SLAM configuration.
-Other service configurations are not affected.
-
-{{% /alert %}}
-
-{{% /changelog %}}
-
-{{% changelog date="2022-11-15" color="removed" title="Width and height fields from camera API" %}}
-
-Removed `width` and `height` from the response of the [`GetImage`](/dev/reference/apis/components/camera/#getimage) method in the camera API.
-This does not impact any existing camera models.
-If you write a custom camera model, you no longer need to implement the `width` and `height` fields.
-
-{{% /changelog %}}
diff --git a/docs/dev/reference/contributing.md b/docs/dev/reference/contributing.md
deleted file mode 100644
index cd3b6a7b35..0000000000
--- a/docs/dev/reference/contributing.md
+++ /dev/null
@@ -1,896 +0,0 @@
----
-title: "Contributing to the Docs"
-linkTitle: "Contributing to the docs"
-weight: 99
-type: "docs"
-description: "Learn about our style guide and how to work with hugo to contribute to these docs."
-toc_hide: true
-aliases:
-  - /dev/contributing/
-  - /appendix/contributing/
----
-
-Thank you for wanting to help us make the docs better.
-Every contribution is appreciated.
-
-{{< alert title="Note" color="note" >}}
-Before you start, please review this document and our [Code of Conduct](https://www.viam.com/community-guidelines).
-{{< /alert >}}
-
-## Goals
-
-The Viam documentation aims to:
-
-- Educate users (explain concepts, provide an overview of what is possible)
-- Help users accomplish tasks (performing an action, building a thing)
-
-We do that by providing concise and well-structured documentation to users.
-When users stumble, we provide avenues for feedback, so we can take action and prevent other users from running into similar issues.
-
-## Voice
-
-We aim to be friendly but not colloquial, direct, and concise.
-
-Here are a few additional pointers:
-
-| Subject              | Judgment      |
-| -------------------- | ------------- |
-| Emoji ✨             | No            |
-| Exclamation marks    | Use sparingly |
-| Rhetorical questions | No            |
-
-## Audience
-
-We write for a technical audience that spans from entry-level to expert.
-However, common tools and concepts such as version control, moving files with ssh, JSON are beyond the scope of our docs.
-To make the content as accessible as possible we will, where possible, include actions to be taken and text that guides the user as to what they are achieving when performing these actions.
-
-For example, when copying a file to another machine with ssh, we would describe the action with words like "Use ssh to move the file onto the other machine" alongside the command to move the file.
-Explaining ssh goes beyond the scope of our docs.
-Where needed, we will link to supporting documentation but not provide supporting documentation ourselves where it would duplicate existing external documentation.
-Use your judgment to determine when we need to explain more and when we need to link to supporting content.
-When in doubt, ask during review.
-
-## Project structure
-
-All documentation is in the [docs folder](https://github.com/viamrobotics/docs/tree/main/docs).
-For information about Hugo and how to develop locally, see the [README](https://github.com/viamrobotics/docs/blob/main/README.md).
-
-## Content types
-
-When creating a new piece of content, decide which one of the four content types the content should be.
-Note this in a comment in the front matter of the file.
-
-The docs use the [Diátaxis Framework](https://diataxis.fr/) as the basis of the content structure with the following four content types:
-
-- **Explanation (conceptual)**: An understanding-oriented piece of content.
-  This content provides background knowledge on a topic and tends to be referenced in how-to guides and tutorials.
-  For example the [`viam-server` page](/operate/reference/viam-server/).
-  It’s useful to have a real or imagined "Why?" question to serve as a prompt.
-
-  {{< expand "Click to view template" >}}
-
-  ```md
-  # Concept
-
-  Introductory paragraph.
-  Possibly containing further subsections or links to relevant conceptual information.
-
-  ## Subconcept
-
-  Paragraphs containing explanation. Add imagery as needed.
-
-  - Provide context and address potential points of confusion. - Add real or hypothetical examples.
-
-  Possibly more Subconcept sections.
-
-  ### Do x with subconcept (optional)
-
-  Information on potential ways to apply the concept (possibly linking to how-tos or containing how-tos).
-
-  ## Next steps
-
-  Links to related content.
-  ```
-
-  {{< /expand >}}
-
-- **How-to Guide (procedural)**: A task-oriented piece of content that directs a reader to perform actions step by step to complete a task, like instructions to sauté onions.
-  Generally starts with a description of the task and things to consider, and then provides a set of numbered steps to follow.
-  For example, the [Move a base](/operate/mobility/move-base/) page.
-
-  {{< expand "Click to view template" >}}
-
-  ```md
-  # Do This Task
-
-  Description of task and considerations. Possibly containing further subsections.
-
-  ## Do x
-
-  1. Ordered list of actions to perform. Written in imperative form. Add imagery as needed.
-
-  (possibly more Do X sections)
-
-  ## Next steps
-
-  Links to related content.
-  ```
-
-  {{< /expand >}}
-
-- **Tutorial**: A learning-oriented piece of content that functions as a lesson for the reader.
-  A tutorial helps readers to learn and apply skills by doing something meaningful and attainable, like a recipe to cook a full meal.
-
-  {{< expand "Click to view template" >}}
-
-  ```md
-  # Do X with Y
-
-  Outline the why.
-  Tell the story of the machine.
-  Explain the machine's use and origin.
-
-  ## Requirements
-
-  What does the reader need to already know.
-  What will you be using (hardware/software).
-
-  ## Build X
-
-  Build steps.
-
-  ## Configure your X
-
-  Configuration steps.
-
-  ## Program your X
-
-  Code and directions.
-
-  ## Next steps
-
-  Link to other tutorials with cards or text.
-
-  {{</* cards */>}}
-  {{%/* card link="/tutorials/get-started/blink-an-led" */%}}
-  {{</* /cards */>}}
-  ```
-
-  For the full template see [template.md](https://github.com/viamrobotics/docs/blob/main/docs/tutorials/template.md).
-
-  {{< /expand >}}
-
-- **Reference**: A concise, information-oriented piece of content that generally starts with an overview/introduction and then a list of some kind (configuration options, API methods, etc.).
-  Examples include the [API pages](/dev/reference/apis/) as well as [component and service pages](/operate/reference/components/arm/).
-
-  Example template: [Component template](https://github.com/viamrobotics/docs/blob/main/docs/components/component/_index.md).
-
-  {{< expand "Click to view template" >}}
-
-  ```md
-  # Product, Feature or API Name
-
-  Description or introduction.
-  Possibly containing further subsections.
-
-  ## List or table of items (heading optional as needed)
-
-  - Unordered list of options
-
-  (possibly more information for each option)
-
-  ## Next steps
-
-  Links to related content.
-  ```
-
-  {{< /expand >}}
-
-## Style guide
-
-All docs are written in [Hugo Markdown](https://www.markdownguide.org/tools/hugo/).
-Most Markdown formatting is supported.
-For a brief introduction to Markdown, check out this [Markdown Cheatsheet](https://gist.github.com/npentrel/e1dd14816f7c7724edf70ab2a2ed2952).
-Some additional formatting options are supported with [Hugo Shortcodes](https://gohugo.io/content-management/shortcodes/).
-
-We follow the [Rackspace Style Guide](https://web.archive.org/web/20200829151826/https://developer.rackspace.com/docs/style-guide/) with many rules encoded in Vale rules.
-
-Additional we enforce the following substitutions:
-
-<!-- vale off -->
-<!-- prettier-ignore -->
-| Do not say | Instead say |
-| ---------- | ----------- |
-| web app, cloud app | Viam or web UI |
-| viam app, Viam App | Viam or web UI |
-| Viam-server, Viam server, Viam-Server | viam-server |
-| Config Tab, Config tab, Configure Tab | CONFIGURE tab |
-| Vision service, Vision Service | vision service |
-| Motion service, Motion Service | motion service |
-| slam service, Slam service, SLAM Service | SLAM service |
-| Data Management Service, Data Management service | data management service |
-| in the website | on the website |
-| on the app | in the app |
-| user of an org | member of an org |
-| main part and child part, main part and non-main part | main part and sub-part |
-| subpart | sub-part |
-| drop down | dropdown |
-| drop-down | dropdown |
-| RPLIDAR, Rplidar | RPlidar |
-| compute parts | computer |
-| microprocessor | Raspberry Pi or Jetson or another specific term |
-
-<!-- vale on -->
-
-### Vale linting
-
-{{< alert title="Tip" color="tip" >}}
-We recommend you work in Visual Studio Code and install the [Vale extension](https://marketplace.visualstudio.com/items?itemName=errata-ai.vale-server) to use the vale linter.
-{{< /alert >}}
-
-When you open a PR, your changes will be checked against a few style rules.
-To run this check locally, follow the instructions in the [Vale Readme](https://github.com/viamrobotics/docs/blob/main/.github/vale/README.md).
-
-### `markdownlint`
-
-We recommend you work in Visual Studio Code and install the [markdownlint extension](https://marketplace.visualstudio.com/items?itemName=DavidAnson.vscode-markdownlint).
-
-### UI elements
-
-Use **bold** text for UI elements, such as tabs and buttons.
-
-### Example values
-
-Use examples that resemble real data. For emails this could be `amanda@viam.com`.
-
-When using placeholders in code examples, follow the [Google developer documentation style guide's rules for formatting placeholders](https://developers.google.com/style/placeholders).
-
-### Images and screenshots
-
-Use screenshots in introductory materials and where the surrounding text is not enough to direct the reader. Be aware that screenshots tend to get outdated quickly and come with a maintenance burden.
-
-Rules for images:
-
-- **Place images in the `assets` folder.** The folder uses the same content structure as the docs. Your images should be in the folder the page that uses it is in. However, there is no need to duplicate an image into multiple places if you use it in multiple pages.
-- All images require alt text.
-- All images **should** be smaller than 1MB. Hugo throws a warning during local builds (such as `make serve-prod`) if an image exceeds this size. Use an image compressor like [TinyPNG](https://tinypng.com/). This is to reduce the overall page and repo size.
-
-#### Remove EXIF data automatically
-
-{{< alert title="Important" color="note" >}}
-
-To ensure that you do not accidentally add `EXIF` data on images, please install [exiftool](https://exiftool.org/install.html) and add the following lines to the `.git/hooks/pre-commit` file in your local repository.
-
-```sh {class="command-line" data-prompt="$"}
-if [ "git diff --name-only | grep -EI '.*(png|jpg|jpeg)$' | wc -l" ];
-then
-list= $(git diff --diff-filter=d --name-only | grep -EI ".*(png|jpg|jpeg)$")
-for item in $list
-do
-exiftool -all= $item
-done
-fi
-```
-
-If you don't already have a `.git/hooks/pre-commit` file in your `docs` git repo directory, you can copy the existing `pre-commit.sample` file in that directory as `pre-commit` to use the sample template, or create a new `pre-commit` file in that directory with the above content.
-If you create a new file, you must also make it executable with: `chmod 755 /path/to/my/.git/hooks/pre-commit`.
-
-With this configuration in place, each commit you make will remove EXIF data from any image files (with extension `.png`, `.jpg`, or `.jpeg`) that are part of your commit.
-{{< /alert >}}
-
-#### Image markup
-
-If the image is supposed to take up the full width of the page use the regular markdown syntax: `![alt text](path)`.
-
-```md
-![Raspberry Pi](/installation/thumbnails/raspberry-pi-4-b-2gb.png)
-```
-
-If the image is smaller use the `imgproc` shortcode with an appropriate resize value.
-
-```md
-<!-- Remove space between curly braces -->
-
-{ {<imgproc src="PATH/TO/IMAGE.png" resize="300x" declaredimensions=true alt="ALT">} }
-
-{ {<imgproc src="/installation/thumbnails/raspberry-pi-4-b-2gb.png" resize="x60" declaredimensions=true alt="Raspberry Pi">} }
-
-{ {<imgproc src="/installation/thumbnails/raspberry-pi-4-b-2gb.png" resize="x200" declaredimensions=true alt="Raspberry Pi">} }
-```
-
-![Raspberry Pi](/installation/thumbnails/raspberry-pi-4-b-2gb.png)
-
-{{<imgproc src="/installation/thumbnails/raspberry-pi-4-b-2gb.png" resize="x60" declaredimensions=true alt="Raspberry Pi">}}
-
-{{<imgproc src="/installation/thumbnails/raspberry-pi-4-b-2gb.png" resize="x200" declaredimensions=true alt="Raspberry Pi">}}
-
-The `imgproc` shortcode will:
-
-- convert the image into the `webp` format (which is more efficient) and resize the image
-- resize the image in the current format and set that image as a backup in case `webp` is not supported. This does reduce file size when the website is being served. However, the source file should still be smaller than 1MB to minimize overall page and repo size. For more information on the resize options see [Image Processing](https://gohugo.io/content-management/image-processing/).
-
-Only specify `declaredimensions` if the image is **not** responsive (if it doesn't resize). The only images that you'd want to use declaredimensions on are the ones that take up the same space on mobile as on desktop.
-
-An example of this are the small board icons on the front page which should never be a different size than they are.
-The pictures in cards, however, need to resize because they change size based on the available screen space.
-
-Screenshot should most often be added with normal markdown syntax. Then they'll take up the max size they can on a big screen but be smaller on mobile. If you want to resize a large image, use the largest size the image can take up as the image to `resize` the image to.
-
-{{< alert title="Note" color="note" >}}
-You cannot directly use the `<img>` html tag for images in the assets folder because the images, once built, are renamed.
-If you really need to use html directly, place the image in the `static` folder.
-{{< /alert >}}
-
-### GIFs and videos
-
-We encourage the use of GIFs and Videos.
-Our docs have two kinds of videos:
-
-- Regular videos with video controls and audio
-- GIF-like videos that do not have video controls or audio and function like GIFs
-
-#### Regular videos
-
-For regular videos that should use the video shortcode as follows:
-
-```md
-<!-- remove space -->
-
-{ {<video webm_src="/heart.webm" mp4_src="/heart.mp4" alt="A robot drawing a heart" poster="/general/heart.jpg">} }
-```
-
-{{<video webm_src="/heart.webm" mp4_src="/heart.mp4" alt="A robot drawing a heart" poster="/general/heart.jpg">}}
-
-We use `webm` and `mp4` source files for videos because they are generally smaller.
-The poster is an image that gets loaded as a preview.
-
-{{% expand "Click to see the commands for converting videos to these formats" %}}
-
-To create the `webm` and mp4 files use these commands:
-
-{{< tabs >}}
-{{% tab name="macOS" %}}
-
-```sh {id="video-conversion-macos" class="command-line" data-prompt="$"}
-ffmpeg -i PATH_TO_GIF_OR_VID -vcodec libx264 -vf "format=yuv420p,scale=720:-2" -b:v 300k PATH_TO_GIF_OR_VID.mp4
-ffmpeg -i PATH_TO_GIF_OR_VID -c:v libvpx-vp9 -b:v 0 -crf 41 my-animation.webm
-```
-
-{{% /tab %}}
-{{% tab name="Linux" %}}
-
-```sh {class="command-line" data-prompt="$"}
-ffmpeg -i PATH_TO_GIF_OR_VID -vcodec libx264 -vf "format=yuv420p,scale=720:-2" -b:v 300k PATH_TO_GIF_OR_VID.mp4
-ffmpeg -i PATH_TO_GIF_OR_VID -c:v libvpx-vp9 -b:v 0 -crf 41 my-animation.webm
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-The first command:
-
-- uses the `libx264` codec
-- uses the `yuv420p` pixel format
-- scales the video to `720px` width
-- changes the bitrate to `300k` - you can change this value but check that the result is usable and reasonably small
-
-The second command:
-
-- uses the `libvpx-vp9` codec
-- `-crf 41` sets the quality level.
-  Valid values are 0-63.
-  Lower numbers are higher quality
-
-To create a preview image use this command:
-
-{{< tabs >}}
-{{% tab name="macOS" %}}
-
-```sh {class="command-line" data-prompt="$"}
-ffmpeg -ss 00:00:05 -i PATH_TO_GIF_OR_VID.mp4 -frames:v 1 PATH_TO_GIF_OR_VID.jpg
-```
-
-{{% /tab %}}
-{{% tab name="Linux" %}}
-
-```sh {class="command-line" data-prompt="$"}
-ffmpeg -ss 00:00:05 -i PATH_TO_GIF_OR_VID.mp4 -frames:v 1 PATH_TO_GIF_OR_VID.jpg
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-The command takes a screenshot at `00:00:05`.
-
-{{% /expand%}}
-
-#### GIF-like videos
-
-GIF-like videos on our pages are generally used to show robot actions.
-We do not use the GIF file format within our docs because it uses a lot of bandwidth - more than videos - and the [best practice](https://developer.chrome.com/en/docs/lighthouse/performance/efficient-animated-content/) is to not use them.
-
-Instead, we use a video div with two sources:
-
-```md
-<!-- remove space -->
-
-{ {<gif webm_src="/heart.webm" mp4_src="/heart.mp4" alt="A robot drawing a heart">}}
-```
-
-{{<gif webm_src="/heart.webm" mp4_src="/heart.mp4" alt="A robot drawing a heart">}}
-
-**Place the files into the `static` directory.**
-
-{{% expand "Click to see instructions for creating the video files" %}}
-To create the `webm` and `mp4` source files, you need to convert the video/gif you have.
-**The resulting `webm` and `mp4` file should always be less than 1MB.**
-A good first thing to do is to upload the video to [Ezgif](https://ezgif.com) and reduce the file size by:
-
-- cutting the video
-- cropping the video
-- changing the size
-- (on GIFs) changing the quality
-- (on GIFs) using the optimize function to remove every second frame and then adjusting the speed
-- (on GIFs) using the frames editor to remove frames that are similar and holding the previous frame longer instead
-
-Once you have a gif that is reasonably small, run these commands:
-
-{{< tabs >}}
-{{% tab name="macOS" %}}
-
-```sh {class="command-line" data-prompt="$"}
-ffmpeg -i PATH_TO_GIF_OR_VID -vcodec libx264 -vf "format=yuv420p,scale=400:-2" -b:v 300k -an PATH_TO_GIF_OR_VID.mp4
-ffmpeg -i PATH_TO_GIF_OR_VID -c:v libvpx-vp9 -b:v 0 -crf 41 my-animation.webm
-```
-
-{{% /tab %}}
-{{% tab name="Linux" %}}
-
-```sh {class="command-line" data-prompt="$"}
-ffmpeg -i PATH_TO_GIF_OR_VID -vcodec libx264 -vf "format=yuv420p,scale=400:-2" -b:v 300k -an PATH_TO_GIF_OR_VID.mp4
-ffmpeg -i PATH_TO_GIF_OR_VID -c:v libvpx-vp9 -b:v 0 -crf 41 my-animation.webm
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-The first command:
-
-- uses the `libx264` codec
-- uses the `yuv420p` pixel format
-- scales the video to `400px` width - if you are working with screenshots that need to be bigger, adjust this number.
-- changes the bitrate to `300k` - you can change this value but check that the result is usable
-- removes the audiotrack with `-an`
-
-The second command:
-
-- uses the `libvpx-vp9` codec
-- `-crf 41` sets the quality level.
-  Valid values are 0-63.
-  Lower numbers are higher quality
-
-{{< alert title="Caution" color="caution" >}}
-
-Some MP4 files aren't natively supported on iPhones depending on the [video codec used](https://confluence.atlassian.com/confkb/unable-to-play-embedded-mp4-videos-on-ipad-or-iphone-in-confluence-305037325.html).
-If you add an MP4 file, test it on an iPhone with the deployed link on the PR.
-
-{{< /alert >}}
-
-{{< alert title="Important" color="note" >}}
-The gif can and should be used only in the frontmater `images` variable and only if close in size to 1MB.
-The `images` variable sets it to be the preview image on social platforms (for example it will be the preview when you share a link on slack).
-Link previews do not support `webm` and `mp4` but they do support gifs.
-{{< /alert >}}
-{{% /expand%}}
-
-{{% expand "Click to see instructions for creating video commands for your terminal" %}}
-
-If you'd like to use commands like `webm2mp4` add this to your `.zshrc`:
-
-```sh {class="command-line" data-prompt="$"}
-function webm2gif() {
-vid=$1
-ext=${vid##*.}
-vdirname=`dirname $vid`
-vfname=`basename $vid $ext`
-ffmpeg -t 8 -i ${vdirname}/${vfname}webm -vf "fps=5,scale=320:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" -loop 0 ${vdirname}/${vfname}gif
-}
-
-function mp42gif() {
-vid=$1
-ext=${vid##*.}
-vdirname=`dirname $vid`
-vfname=`basename $vid $ext`
-ffmpeg -t 8 -i ${vdirname}/${vfname}mp4 -vf "fps=10,scale=320:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" -loop 0 ${vdirname}/${vfname}gif
-}
-
-function gif2webm() {
-vid=$1
-ext=${vid##*.}
-vdirname=`dirname $vid`
-vfname=`basename $vid $ext`
-ffmpeg -i ${vdirname}/${vfname}gif -c vp9 -b:v 0 -crf 41 -an ${vdirname}/${vfname}webm
-}
-
-function gif2mp4() {
-vid=$1
-ext=${vid##*.}
-vdirname=`dirname $vid`
-vfname=`basename $vid $ext`
-ffmpeg -i ${vdirname}/${vfname}gif -vcodec libx264 -vf "format=yuv420p,scale=400:-2" -b:v 300k -an ${vdirname}/${vfname}mp4
-}
-
-function gif2mp4-withsound() {
-vid=$1
-ext=${vid##*.}
-vdirname=`dirname $vid`
-vfname=`basename $vid $ext`
-ffmpeg -i ${vdirname}/${vfname}gif -vcodec libx264 -vf "format=yuv420p,scale=-2:720" -b:v 300k ${vdirname}/${vfname}mp4
-}
-
-function mp42webm() {
-vid=$1
-ext=${vid##*.}
-vdirname=`dirname $vid`
-vfname=`basename $vid $ext`
-ffmpeg -i ${vdirname}/${vfname}mp4 -c vp9 -b:v 0 -crf 41 -an ${vdirname}/${vfname}webm
-}
-
-function mp42webm-withsound() {
-vid=$1
-ext=${vid##*.}
-vdirname=`dirname $vid`
-vfname=`basename $vid $ext`
-ffmpeg -i ${vdirname}/${vfname}mp4 -c vp9 -b:v 0 -crf 41 ${vdirname}/${vfname}webm
-}
-
-function webm2mp4() {
-vid=$1
-ext=${vid##*.}
-vdirname=`dirname $vid`
-vfname=`basename $vid $ext`
-ffmpeg -i ${vdirname}/${vfname}webm -vcodec libx264 -vf "format=yuv420p,scale=400:-2" -b:v 300k -an ${vdirname}/${vfname}mp4
-}
-
-function webm2mp4-withsound() {
-vid=$1
-ext=${vid##*.}
-vdirname=`dirname $vid`
-vfname=`basename $vid $ext`
-ffmpeg -i ${vdirname}/${vfname}webm -vcodec libx264 -vf "format=yuv420p,scale=-2:720" -b:v 300k ${vdirname}/${vfname}mp4
-}
-
-function mp42jpg {
-vid=$1
-ext=${vid##*.}
-vdirname=`dirname $vid`
-vfname=`basename $vid $ext`
-ffmpeg -ss 00:00:05 -i ${vdirname}/${vfname}mp4 -frames:v 1 ${vdirname}/${vfname}jpg
-}
-```
-
-{{< alert title="Important" color="note" >}}
-The `2gif` commands only turn the first 5 seconds of a video into a low res gif.
-{{< /alert >}}
-
-{{% /expand%}}
-
-{{% alert title="Note" color="note" %}}
-
-If you use `videos` to add a video preview for a page (such as to a tutorial), you should also add a <file>.gif</file> version of the video to the front matter.
-Hugo uses the GIF as a link preview image that gets displayed on external sites when someone shares the link, for example on Slack or Twitter.
-
-Why?
-
-- GIFs take more bandwidth than MP4 and WEBM videos, so on our page, we prefer to use MP4 and WEBM.
-- Link previews using `og:image` only support GIFs
-- Automatic conversion between the formats is possible but we also need to make sure that the resulting GIFs are presentable and under 1MB.
-
-{{% /alert %}}
-
-## Formatting guide
-
-### Front matter
-
-Each file that generates a page in Hugo starts with front matter that looks like this:
-
-```markdown
----
-title: "Build a line-following robot with only a rover and a webcam"
-linkTitle: "Line Follower"
-weight: 90
-type: "docs"
-description: "Instructions for building a line-following robot that uses a webcam to track lines."
-# SME: "SME Name"
----
-```
-
-- The `description` gets used for previews.
-- The `weight` determines the ordering of pages in the side navigation bar.
-
-#### Prod/Draft/Future pages
-
-Add `draft: true` to the Front Matter to set a page to Draft.
-You can commit and push the page and it won’t display in production.
-Add `future: true` to the Front Matter to begin building a page to production on a certain date (for example, a release date).
-
-### File names
-
-File names are kebab-case, with hyphens, such as `upload-model.md`.
-
-### One sentence per line
-
-To make reviews easier, each new sentence should begin on a new line.
-
-### Add hyperlinks (sparingly)
-
-Where related resources would be helpful to a reader, link them. However:
-
-- Links are an opportunity for a reader to get lost or get distracted. If that happens, a link is not helpful. Placing links near the end of a section/page can help avoid this.
-- Avoid a page becoming a sea of blue hyperlinks. Excessive linking can make a page harder to view and read.
-
-{{< alert title="Important" color="note" >}}
-Links should always have descriptive text. Never write "Click here" with `here` as the link text. Instead use "To learn more about X, read PAGE NAME" with the page name as the link text.
-{{< /alert >}}
-
-When linking to an image or another page within the docs please use relative links (`appendix/contributing/`) or (`/appendix/contributing/`).
-
-{{< alert title="Note" color="note" >}}
-You **must** add a trailing slash on links.\*\*
-This is enforced with `htmltest`.
-{{< /alert >}}
-
-### Glossary
-
-We have built a glossary into our docs. Jargon and product-specific concepts should have an entry in the `appendix/glossary` folder. You can use a glossary entry on any page like this:
-
-```md
-<!-- Remove spaces between curly braces -->
-
-This text will have additional information on hover for the
-word { {< glossary_tooltip term_id="smart-machine" text="smart machine" >} }.
-```
-
-### Reusable text snippets
-
-If you need to use the same text in multiple locations, for example when cautioning users to disconnect power before changing connections or providing a commonly used instruction set or procedure, you can use reusable snippets.
-
-The following is an example of the <file>secret-share.md</file> alert added using the snippet shortcode:
-
-{{% figure src="/general/snippet-shortcode.png" alt="Snippet shortcode usage." title="Snippet Shortcode Usage" %}}
-
-{{% snippet "secret-share.md" %}}
-
-### Including another file
-
-{{< readfile "/static/include/sample.md" >}}
-
-Section content before this line is contained in an included file: <file>/static/include/sample.md</file>
-
-### Tab Panels
-
-{{< tabs name="TabPanelExample" >}}
-{{% tab name="Support"%}}
-**Supported**
-
-- Markdown and HTML images
-  - Images should be included with the imgproc shortcode.
-    You cannot directly use the `<img>` html tag for images in the assets folder because the images, once built, are renamed.
-    If you really need to use html directly, place the image in the static folder.
-- Alert Shortcode
-- PRISM syntax highlighting (the three backticks)
-- "codelang" highlighting (add codelang="language" to tab element).
-  It's very ugly, needs css work, and is not recommended at this time.
-
-### Not supported
-
-- Footnotes
-- Expanders
-
-### Example usage
-
-```md
-# remove spaces
-
-{ {<imgproc src="/general/tabbed-panel-markdown.png" resize="300x" declaredimensions=true alt="Screen capture of Tab/Tabs Shortcode Usage" style="border:solid 1px black">} }
-```
-
-{{<imgproc src="/general/tabbed-panel-markdown.png" resize="300x" declaredimensions=true alt="Screen capture of Tab/Tabs Shortcode Usage" style="border:solid 1px black">}}
-
-{{% /tab %}}
-{{% tab name="Examples" %}}
-
-<div>
- <h3>What is Rendered?</h3>
- <p>It renders <i>vanilla</i> HTML and markdown, Alerts, and images.
- For example, these two images:</p>
-
-- **Markdown Image Example**<br>
-  ![expand example](/general/expander-markdown.png)<br>
-- **HTML Image Example** (with border)<br>
-  {{<imgproc src="/general/expander-markdown.png" resize="800x" declaredimensions=true alt="Screen capture of Tab/Tabs Shortcode Usage">}}
-
-</div>
-<br>
-
-{{% /tab %}}
-{{< /tabs >}}
-
-### Code with syntax highlighting
-
-Line numbering is off by default.
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "word": "Three backticks and the language name enables Prism syntax highlighting."
-}
-```
-
-With just line 6 highlighted.
-See [the prism line highlight extension](https://prismjs.com/plugins/line-highlight/) for more info:
-
-```python {class="line-numbers linkable-line-numbers" data-line="6"}
-while (True):
-    # When True, sets the LED pin to high or on.
-    await led.set(True)
-    print('LED is on')
-
-    await asyncio.sleep(1)
-
-    # When False, sets the pin to low or off.
-    await led.set(False)
-    print('LED is off')
-
-    await asyncio.sleep(1)
-```
-
-With linked lines and lines 8-10 highlighted.
-
-```python {id="some-python-unique-id" class="linkable-line-numbers" data-line="8-10"}
-while (True):
-    # When True, sets the LED pin to high or on.
-    await led.set(True)
-    print('LED is on')
-
-    await asyncio.sleep(1)
-
-    # When False, sets the pin to low or off.
-    await led.set(False)
-    print('LED is off')
-
-    await asyncio.sleep(1)
-```
-
-### Alert shortcodes
-
-{{< alert title="Important" color="note" >}}
-This is an alert.
-{{< /alert >}}
-
-#### How to use notes, cautions, and warnings
-
-**Info/Tip**: Use to convey helpful information or clarification.
-They both use the same color.
-
-**Note/Important/Stability Notice**: These call attention to something important.
-When creating alerts about important messages, set the title attribute as `title="Important"`.
-If you want to include a more detailed title or message, use `title="Important: $message"` to provide additional context.
-
-**Caution**: Provide notice that a certain action or event could damage hardware or cause data loss.
-
-**Warning**: Use to notify the reader of an issue to avoid loss of life, personal injury, and health hazards.
-Electrical and physical safety fall into this category.
-
-{{< alert title="Tip" color="tip" >}}
-The "title" and "color" keywords and the names of colors ("tip," "note," and so on) are case sensitive.
-If you use uppercase, alerts will not have a title and the color border will be incorrect.
-{{< /alert >}}
-
-{{< figure src="/general/alert-markdown.png"  alt="The shortcodes used to display Alerts." title="Shortcodes for Alerts" >}}
-
-{{< alert title="Tip" color="tip" >}}
-Provide a tip.
-{{< /alert >}}
-
-{{< alert title="Info" color="info" >}}
-Use to expand on something from the body text or to provide additional information.
-{{< /alert >}}
-
-{{< alert title="Important" color="note" >}}
-This is to call the reader's attention to something important.
-{{< /alert >}}
-
-{{< alert title="Stability Notice" color="note" >}}
-Let the reader know that a feature is experimental and that breaking changes are likely to occur.
-{{< /alert >}}
-
-{{< alert title="Caution" color="caution" >}}
-This provides notices that a certain action or event could damage hardware or cause data loss.
-{{< /alert >}}
-
-{{< alert title="Warning" color="warning" >}}
-Use to notify the reader of information to avoid loss of life, personal injury, and health hazards.
-{{< /alert >}}
-
-### Using expanders
-
-Expanders allow to you add long sections of code to your topic and hide them until the reader decides to view it.
-
-Within the expander, you can still use most other shortcodes and syntax highlighting from Prism functions properly.
-The shortcode displays your expander's title in a light blue bar to make it noticeable.<br><br>
-
-**Screen Capture of an Expander**
-{{<imgproc src="/general/expander-example.png" resize="1000x" declaredimensions=true alt="Screen capture of the expander control rendered on a documentation page" style="border:solid 1px black">}}
-
-#### Usage
-
-1. Add the shortcode tags.
-   Make sure that the title is suitable for your use.
-1. Drop in the material you want to hide until the reader wants it.
-
-{{<imgproc src="/general/expander-markdown.png" resize="400x" declaredimensions=true alt="ALT" style="border:solid 1px black">}}
-
-{{%expand "Click to view the source" %}}
-<br>
-
-Add the text to hide here.
-
-**Prism syntax highlighting works in expanders, as do most other shortcodes.**
-
-```python
-print("Code snippets work")
-```
-
-{{% /expand%}}
-
-### Figures
-
-The figure shortcode enhances the existing figure and figurecaption html tags.
-Figure supports the standard html attributes associated with the html img and figure tags, as well as an **attr** element for attribution text and **attrlink** if you wish to add a link to the attribution text.
-
-{{< figure src="/general/figure-shortcode.png"  alt="The shortcode used to display an image, its caption, and its attribution." title="Figure Shortcode" >}}
-
-This shortcode places the caption (that is the "title") above the table.
-The **title** is set in 12pt italic with a green underline.
-
-Figure styles the Attribution text as body text.
-
-### Footnotes
-
-To add a footnote:
-
-```md
-"Some completely[^f] random text."
-
-[^f]: this is the text for the footnote
-```
-
-You can place the footnote text immediately beneath the paragraph where you put the marker.
-Hugo will place it at the bottom of the page.
-
-## Pull requests
-
-If you are making a small change, like fixing a typo or editing a few lines of text, you do not need to create an issue.
-However, if you plan to make bigger changes, we ask that you create an issue and discuss the change with us in advance.
-
-To get started:
-
-1. Fork the official repo into your personal GitHub.
-2. Clone the forked repo to your local system.
-3. Add the remote path for the 'official' repository: `git remote add upstream git@github.com:viamrobotics/docs.git`
-
-When you are ready to contribute changes to the docs:
-
-1. Make sure you are on the main branch: `git switch main`
-2. Sync your forked main branch with the official repo: `git pull upstream main`
-3. Create a new branch for your changes: `git switch -c my-new-feature`
-4. Edit some docs...
-5. Commit your changes: `git commit -am 'Add some feature'`
-6. Make sure your local branch is still up-to-date with the official repo: `git pull upstream main`
-7. Push to the branch: `git push origin my-new-feature`
-8. Submit a pull request
-
-## Questions
-
-If you have questions or would like to chat, please find us on the [Community Discord](https://discord.gg/viam).
diff --git a/docs/dev/reference/sdks/_index.md b/docs/dev/reference/sdks/_index.md
deleted file mode 100644
index ed3a74240c..0000000000
--- a/docs/dev/reference/sdks/_index.md
+++ /dev/null
@@ -1,39 +0,0 @@
----
-title: "Write control code with Viam SDKs"
-linkTitle: "SDKs"
-weight: 10
-type: "docs"
-description: "Write code to control your machine with Viam's Python, Go, TypeScript, Flutter, and C++ SDKs."
-aliases:
-  - /sdks/
----
-
-## Backend SDKs
-
-The backend SDKs allow you to build business logic to control [components](/dev/reference/apis/#component-apis) and [services](/dev/reference/apis/#service-apis), as well as manage your [fleet](/dev/reference/apis/fleet/) and [data](/dev/reference/apis/data-client/), and [billing information](/dev/reference/apis/billing-client/), or [provision](/manage/fleet/provision/setup/) machines.
-With the backend SDKs you can also create custom {{< glossary_tooltip term_id="modular-resource" text="modular resources" >}}.
-
-{{< sectionlist-custom class="horizontal" >}}
-{{% sectionlist-custom-item link="/dev/reference/sdks/python/" %}}
-{{% sectionlist-custom-item link="/dev/reference/sdks/go/" %}}
-{{% sectionlist-custom-item link="/dev/reference/sdks/cpp/" %}}
-{{< /sectionlist-custom >}}
-<br>
-
-## Frontend SDKs
-
-The frontend TypeScript SDK allows you to control your machine's [components](/dev/reference/apis/#component-apis), as well as manage your [data](/dev/reference/apis/data-client/) or [provision](/manage/fleet/provision/setup/) machines.
-
-{{< sectionlist-custom class="horizontal" >}}
-{{% sectionlist-custom-item link="/dev/reference/sdks/typescript/" %}}
-{{< /sectionlist-custom >}}
-<br>
-
-## Mobile SDK
-
-The mobile SDK allows you to build iOS and Android apps to control your machine's [components](/dev/reference/apis/#component-apis), as well as manage your [fleet](/dev/reference/apis/fleet/) and [data](/dev/reference/apis/data-client/), or [provision](/manage/fleet/provision/setup/) machines.
-
-{{< sectionlist-custom class="horizontal">}}
-{{% sectionlist-custom-item link="/dev/reference/sdks/flutter/" %}}
-{{< /sectionlist-custom >}}
-<br>
diff --git a/docs/dev/reference/try-viam/_index.md b/docs/dev/reference/try-viam/_index.md
deleted file mode 100644
index ed51ad2af4..0000000000
--- a/docs/dev/reference/try-viam/_index.md
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: "Try Viam"
-linkTitle: "Try Viam"
-childTitleEndOverwrite: "Try Viam"
-weight: 85
-type: "docs"
-description: "Try Viam by taking over a Viam Rover in our robotics lab."
-videos: ["/appendix/try-viam/rover.webm", "/appendix/try-viam/rover.mp4"]
-videoAlt: "Rover reservation management page"
-images: ["/appendix/try-viam/rover.gif"]
-no_list: true
-aliases:
-  - "/getting-started/try-viam/"
-  - "/tutorials/viam-rover/"
-  - /get-started/try-viam/tutorials/
-  - "/appendix/try-viam/tutorials/"
-  - "/try-viam/"
-  - "/get-started/try-viam/"
-  - "/appendix/try-viam-faq/"
-  - "/try-viam/faq/"
-  - "get-started/try-viam/faq/"
-  - /appendix/try-viam/
-  - /appendix/get-started/try-viam/faq/
-date: "2022-01-01"
-# updated: ""  # When the content was last entirely checked
----
-
-Viam is a general {{< glossary_tooltip term_id="smart-machine" text="smart machine">}} platform that can run on any hardware.
-The easiest way to try Viam is to [rent and remotely configure and control a Viam Rover](https://app.viam.com/try) located on-site at Viam in New York:
-
-<table>
-  <tr>
-    <th>{{<imgproc src="/appendix/try-viam/try-viam-1.svg" class="fill alignright" style="width: 300px" declaredimensions=true alt="ALT">}}
-      <b>1. Click on TRY in Viam</b>
-      <p>Log into Viam and go to the <a href="https://app.viam.com/try">TRY tab</a>. Don’t have a Viam account? Follow the prompts to sign up for an account.</p>
-    </th>
-  </tr>
-  <tr>
-    <td>{{<imgproc src="/appendix/try-viam/try-viam-2.svg" class="fill alignleft" style="width: 300px" declaredimensions=true alt="ALT">}}
-      <b>2. Reserve your slot</b>
-      <p>If no one’s using a Viam Rover, you’ll take over immediately.
-Otherwise, you’ll see an estimated time for the next slot, and we’ll send you an email when it’s your turn.
-See <a href="/dev/reference/try-viam/reserve-a-rover//">detailed instructions</a>.</p>
-    </td>
-  </tr>
-  <tr>
-    <td>{{<imgproc src="/appendix/try-viam/try-viam-3.svg" class="fill alignright" style="width: 300px" declaredimensions=true alt="ALT">}}
-      <b>3. Get started with Viam</b>
-      <p>Try a Viam Rover in our robotics lab. <a href="/manage/troubleshoot/teleoperate/default-interface/#web-ui">Drive</a> or <a href="/tutorials/control/drive-rover/">program</a> the rover to see how you can build a machine with Viam.</a></p>
-    </td>
-  </tr>
-</table>
-
-## Next steps
-
-{{< cards >}}
-{{% card link="/tutorials/control/drive-rover/" %}}
-{{% card link="/dev/reference/try-viam/rover-resources/" %}}
-{{< /cards >}}
diff --git a/docs/dev/reference/try-viam/reserve-a-rover.md b/docs/dev/reference/try-viam/reserve-a-rover.md
deleted file mode 100644
index 9d1fd6ae00..0000000000
--- a/docs/dev/reference/try-viam/reserve-a-rover.md
+++ /dev/null
@@ -1,138 +0,0 @@
----
-title: "Reserve a Viam Rover"
-linkTitle: "Reserve a Viam Rover"
-weight: 10
-type: "docs"
-description: "Reserve a Viam Rover located on-site at Viam in NYC."
-images: ["/appendix/try-viam/try-viam-reserve-preview.png"]
-imageAlt: "Rover reservation page"
-tags: ["try viam", "app"]
-aliases:
-  - "/try-viam/reserve-a-rover/"
-  - "/get-started/try-viam/reserve-a-rover/"
-  - /appendix/try-viam/reserve-a-rover
-toc_hide: true
-date: "2022-01-01"
-# updated: ""  # When the content was last entirely checked
----
-
-_Try Viam_ is a way to try out the Viam platform without setting up any hardware yourself.
-You can take over a Viam Rover in our robotics lab to play around!
-
-Watch this tutorial video for a walkthrough of Try Viam, including [how to reserve a Viam Rover](#using-the-reservation-system), [navigate the Viam platform](/operate/), and [drive the rover](/operate/reference/components/base/wheeled/#test-the-base):
-
-{{<youtube embed_url="https://www.youtube-nocookie.com/embed/YYpZ9CVDwMU" max-width="600px">}}
-
-## Using the reservation system
-
-### Create a reservation
-
-{{< readfile "/static/include/try-viam/create-a-reservation.md" >}}
-
-### Access your rover rental
-
-Once your reservation starts and the system has configured your rover, click **TRY MY ROVER** from the [**TRY VIAM** page](https://app.viam.com/try) or, if you were queuing, click **Take Me to My Rover** in the confirmation email.
-
-{{<gif webm_src="/appendix/try-viam/rover-reservation.webm" mp4_src="/appendix/try-viam/rover-reservation.mp4" alt="Rover reservation management page" max-width="1000px">}}
-
-{{<imgproc src="appendix/try-viam/navigation-bar.png" resize="800x" alt="Navigation bar with the Viam Rover time remaining indicator.">}}
-
-### Limitations
-
-When using a rented Viam rover, adding {{< glossary_tooltip term_id="module" text="modules" >}} is disabled for security purposes.
-
-### Extend your reservation
-
-{{< readfile "/static/include/try-viam/extend-a-reservation.md" >}}
-
-### Cancel my reservation
-
-{{< readfile "/static/include/try-viam/cancel-a-reservation.md" >}}
-
-## Next steps
-
-{{< cards >}}
-{{% card link="/tutorials/control/drive-rover/" %}}
-{{< /cards >}}
-
-## FAQ
-
-Try Viam allows you to try the Viam platform without setting up any hardware yourself.
-You can take over and play around with a Viam Rover in our robotics lab from anywhere in the world!
-
-### How do I make a reservation to take over a Viam Rover?
-
-{{< readfile "/static/include/try-viam/create-a-reservation.md" >}}
-
-### My machine had an error, a system crash, or is physically stuck
-
-1. Please notify Viam support on [our Community Discord](https://discord.gg/viam).
-2. Use the **Add Viam Support** button on your machine's Location page to give Viam Support access to your _location_.
-   Refer to [Grant access](/manage/manage/access/#grant-access).
-
-### Can I extend my time?
-
-Sure!
-
-{{< readfile "/static/include/try-viam/extend-a-reservation.md" >}}
-
-### Can I cancel my reservation/session?
-
-Yes.
-
-{{< readfile "/static/include/try-viam/cancel-a-reservation.md" >}}
-
-### How can I reuse my borrowed rover?
-
-After using Try Viam, your machine config stays in your Viam account.
-You can access your machine page, write code to control it, and modify its config after your reservation time ends.
-
-When you next borrow a rover you can choose to configure it with a previous rover configuration from your account or create a new rover with the standard starting config.
-
-{{< alert title="Tip" color="tip" >}}
-You can also reuse your code for the rover for other machines that you configure with Viam in the future.
-{{< /alert >}}
-
-### What happens to my borrowed rover after the rental session?
-
-1. On session expiration, Viam removes the "live" status from the machine.
-2. Viam then removes your config from the physical machine in preparation for its next rental.
-3. The Rover Rental Location and the final config of all previous rental rovers remain visible to your organization.
-   You can continue modifying the configurations as desired.
-
-### Can I rename my machine or change the location?
-
-You can rename your machine or change the location.
-If you change the location, you must refresh the page.
-
-### Which organization does this machine e belong to?
-
-Your machine belongs to the [organization](/manage/reference/organize/) you were in when you made the request.
-
-### Can I share this Location with a friend to work on the machine together?
-
-Sure, you can [invite other users to your organization](/manage/manage/access/#grant-access) to collaborate on your machine.
-As members of your organization, those users have full control of your machine.
-Another collaboration option is to use screen sharing in a Zoom or Webex session.
-
-### How many active rentals can I have?
-
-You can only borrow one rover at a time.
-You cannot join the queue for another reservation while you have an active rental session.
-If you would like to, you can [extend your reservation](/dev/reference/try-viam/reserve-a-rover/#extend-your-reservation).
-
-### I loved my experience - can I play around more?
-
-Yes! You can borrow the rover as many times as you’d like.
-Here are some tutorials which you can follow:
-
-- [Drive with the Viam SDK](/tutorials/control/drive-rover/)
-
-If you want to get your own Viam Rover, [you can](https://viam.com/resources/rover).
-
-### Why can't I use the rover's microphone?
-
-For security reasons, Viam has disabled the microphone on rover rentals.
-The microphone on [Viam Rovers shipped to you](/dev/reference/try-viam/rover-resources/) functions normally.
-
-{{< snippet "social.md" >}}
diff --git a/docs/dev/reference/try-viam/rover-resources/_index.md b/docs/dev/reference/try-viam/rover-resources/_index.md
deleted file mode 100644
index 2b7572f77d..0000000000
--- a/docs/dev/reference/try-viam/rover-resources/_index.md
+++ /dev/null
@@ -1,55 +0,0 @@
----
-title: "Your own Viam Rover"
-linkTitle: "Your own Viam Rover"
-weight: 80
-simple_list: true
-type: docs
-tags: ["rover", "viam rover"]
-images: ["/appendix/try-viam/rover-resources/viam-rover/box-contents.jpg"]
-imageAlt: "A Viam Rover in a box"
-aliases:
-  - "/viam-rover-resources/"
-  - "/rover-resources/"
-  - "/try-viam/rover-resources/"
-  - "/get-started/try-viam/rover-resources/"
-  - /appendix/try-viam/rover-resources/
-description: If you want a convenient mobile base for robotics projects, order a Viam rover and set it up.
-date: "2022-01-01"
-# updated: ""  # When the content was last entirely checked
----
-
-{{< alert title="Tip" color="tip" >}}
-If you want a convenient mobile {{% glossary_tooltip term_id="base" text="base"%}} for a variety of robotics projects, you can now [order your own Viam rover](https://www.viam.com/resources/rover).
-{{< /alert >}}
-
-<div class="td-max-width-on-larger-screens">
-<div class="row">
-    <div class="col">
-        <a href="https://www.viam.com/resources/rover" target="_blank">
-            {{<imgproc src="appendix/try-viam/rover-resources/viam-rover/rover-front.jpg" resize="400x" alt="The front of the assembled Viam Rover" style="width:400px; min-width:300px; float: left" >}}
-    </div>
-    <div class="col" style= "min-width:300px;">
-        <p>
-            The <a href="https://www.viam.com/resources/rover" target="_blank">Viam Rover 2</a> arrives preassembled with two encoded motors with suspension, a webcam with a microphone unit, a 6 axis IMU, power management and more.
-            It is primarily designed for use with a Raspberry Pi 4.
-            Featuring an anodized aluminum chassis with expandable mounting features, the rover can comfortably navigate indoor environments with a 20 lb payload.
-            You can customize your rover by mounting <a href="/operate/reference/components/sensor/">sensors</a>, <a href="/operate/reference/components/camera/">LiDAR</a>, and <a href="/operate/reference/components/arm/">arms</a>.
-        </p>
-    </div>
-</div>
-</div>
-
-{{< alert title="Important" color="note" >}}
-You must purchase the following hardware separately:
-
-- A Raspberry Pi 4
-- Four 18650 batteries or RC-type battery (with charger)
-- A MicroSD card and an adapter/reader
-
-{{< /alert >}}
-
-### Next steps
-
-{{< cards >}}
-{{% card link="/dev/reference/try-viam/rover-resources/rover-tutorial/" %}}
-{{< /cards >}}
diff --git a/docs/dev/reference/try-viam/rover-resources/rover-tutorial-1.md b/docs/dev/reference/try-viam/rover-resources/rover-tutorial-1.md
deleted file mode 100644
index 8f42290bf3..0000000000
--- a/docs/dev/reference/try-viam/rover-resources/rover-tutorial-1.md
+++ /dev/null
@@ -1,298 +0,0 @@
----
-title: "Unbox and Set Up your Viam Rover 1"
-linkTitle: "Unbox and Set Up your Viam Rover 1"
-weight: 15
-type: "docs"
-tags: ["rover", "tutorial"]
-images: ["/appendix/try-viam/rover-resources/viam-rover/box-contents.jpg"]
-imageAlt: "A Viam Rover 1 in a box"
-description: "A list of the contents of the Viam Rover 1 kit, instructions for wiring your rover, and links for additional hardware."
-aliases:
-  - "/rover-resources/rover-tutorial/"
-  - "/try-viam/rover-resources/rover-tutorial/"
-  - "/get-started/try-viam/rover-resources/rover-tutorial/"
-  - /appendix/try-viam/rover-resources/rover-tutorial-1/
-date: "2022-01-01"
-# updated: ""  # When the content was last entirely checked
----
-
-{{% alert title="Tip" color="tip" %}}
-A new version of the Viam Rover is now available, the [Viam Rover 2](https://www.viam.com/resources/rover).
-If you have purchased a Viam Rover 2, follow [these instructions](/dev/reference/try-viam/rover-resources/rover-tutorial/) instead.
-{{% /alert %}}
-
-The [Viam Rover 1](https://www.viam.com/resources/rover) arrives preassembled with two encoded motors with suspension, a webcam with a microphone unit, and a 3D accelerometer module.
-
-{{< alert title="Important" color="note" >}}
-You must purchase the following hardware separately:
-
-- A Raspberry Pi 4
-- Four 18650 batteries (with charger)
-- A MicroSD card and an adapter/reader
-  {{< /alert >}}
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover/rover-front.jpg" resize="400x" declaredimensions=true alt="The front of the assembled Viam Rover 1">}}
-
-This guide covers what's inside the kit, describes each component, provides instructions for wiring your rover, and includes links for additional hardware.
-
-## What's inside the kit
-
-1. One assembled Viam Rover 1.
-
-   {{<imgproc src="appendix/try-viam/rover-resources/viam-rover/rover-side.jpg" resize="400x" declaredimensions=true alt="The side of the assembled Viam Rover 1">}}
-
-1. Four M2.5 screws for mounting your Raspberry Pi.
-
-   {{<imgproc src="appendix/try-viam/rover-resources/viam-rover/screws.jpg" resize="200x" declaredimensions=true alt="Four screws" >}}
-
-1. Two spare stiffer suspension springs.
-   You can swap them out with the springs that come with the rover if you need stiffer suspension for higher payload applications.
-
-   {{<imgproc src="appendix/try-viam/rover-resources/viam-rover/suspension-springs.jpg" resize="200x" declaredimensions=true alt="Two suspension springs" >}}
-
-1. Three different Allen wrenches (1.5 mm, 2 mm, and 2.5 mm) to unscrew the top and mount the Raspberry Pi.
-
-   {{<imgproc src="appendix/try-viam/rover-resources/viam-rover/allen-wrenches.png" resize="180x" alt="Three allen wrenches" >}}
-
-1. Ten female-to-female jumper wires.
-   All of the wires' colors correspond to the included wiring diagram.
-   Six are for the motor controller and four are for the accelerometer.
-
-   {{<imgproc src="appendix/try-viam/rover-resources/viam-rover/jumper-wires.jpg" resize="400x" declaredimensions=true alt="Ten colorful jumper wires" >}}
-
-All together, your kit looks like this:
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover/box-contents.jpg" resize="400x" declaredimensions=true alt="A Viam Rover 1 shipping box contents" >}}
-
-## Rover components
-
-### Dual drive motors with suspension and integrated motor encoders
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover/encoder-motors.jpg" resize="400x" declaredimensions=true alt="two motors with encoders" >}}
-
-The motors come with integrated encoders.
-For information on encoders, see [Encoder Component](/operate/reference/components/encoder/).
-For more information on encoded DC motors, see [Encoded Motors](/operate/reference/components/motor/encoded-motor/).
-
-The kit also includes stiffer suspension springs that you can substitute for the ones on the rover.
-Generally, a stiff suspension helps with precise steering control.
-In contrast, a soft suspension allows the wheels to move up and down to absorb small bumps on the rover's path.
-
-### Motor driver
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover/motor-driver.png" resize="400x" declaredimensions=true alt="A L298N motor driver" >}}
-
-The kit comes with an L298N driver dual H-Bridge DC motor driver.
-L298 is a high voltage and high current motor drive chip, and H-Bridge is typically used to control the rotating direction and speed of DC motors.
-
-### 720p webcam, with integrated microphone
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover/webcam.jpg" resize="400x" declaredimensions=true alt="Webcam with cables" >}}
-
-The webcam that comes with the kit is a standard USB camera device and the rover has a custom camera mount for it.
-For more information, see [Camera Component](/operate/reference/components/camera/).
-
-### 3D accelerometer
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover/accelerometer.jpg" resize="400x" declaredimensions=true alt="A ADXL345 accelerometer" >}}
-
-The [ADXL345](https://github.com/viam-modules/analog-devices/) sensor manufactured by Analog Devices is a digital 3-axis accelerometer that can read acceleration up to ±16g for high-resolution (13-bit) measurements.
-You can access it with a SPI (3-wire or 4-wire) or I<sup>2</sup>C digital interface.
-
-In Viam, you can configure it as a [movement sensor component](/operate/reference/components/movement-sensor/).
-
-### Buck converter
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover/buck-converter.jpg" resize="400x" declaredimensions=true alt="A mini560 buck converter" >}}
-
-A buck converter is a DC-to-DC power converter and you use it to step down voltage from its input to its output.
-The 5A mini560 step-down module has high conversion efficiency and low heat generation.
-
-### Toggle switch
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover/toggle-switch.jpg" resize="400x" declaredimensions=true alt="A toggle switch" >}}
-
-The toggle switch comes wired to the rover and you use it to turn the power on and off.
-
-### Battery pack
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover/battery-pack.jpg" resize="400x" declaredimensions=true alt="A battery pack" >}}
-
-The rover comes with a battery holder.
-You must purchase four 18650 batteries (and a charger) separately.
-The battery holder also has a female jack for an external DC power supply.
-
-#### Four 18650 batteries with a charger
-
-An 18650 battery is a lithium-ion rechargeable battery.
-We recommend the button-top type, though either button or flat top can work.
-We have used batteries approximately 67.5mm in length, but the battery housing includes a spring to accommodate most batteries of that approximate length.
-Any brand is suitable as long as you comply with the battery safety requirements.
-
-Check the [safety](#safety) section for more information.
-
-## Safety
-
-Read all instructions fully before using this product.
-
-This product is not a toy and is not suitable for children under 12.
-
-Switch the rover off when not in use.
-
-{{< alert title="Warning" color="warning" >}}
-Lithium-ion batteries may pose a flammable hazard.
-This product requires four 18650 lithium-ion batteries.
-Refer to the battery manufacturer’s operating instructions to ensure safe operation of the Viam Rover 1.
-Dispose of lithium-ion batteries per manufacturer instructions.
-{{< /alert >}}
-
-{{< alert title="Caution" color="caution" >}}
-Damage may occur to the Raspberry Pi and/or Viam Rover 1 if wired incorrectly.
-Refer to the manufacturer’s instructions for correct wiring.
-{{< /alert >}}
-
-Disclaimer: This product is preliminary and experimental in nature, and is provided "AS IS" without any representation or warranty of any kind.
-Viam does not make any promise or warranty that the product will meet your requirements or be error free.
-Some states do not allow the exclusion or disclaimer of implied warranties, so the above exclusions may not apply to you.
-
-## Setup
-
-This is the recommended order to assemble your rover:
-
-1. [Install Raspberry Pi OS on the microSD card.](#install-raspberry-pi-os)
-2. [Unscrew the top of the rover and screw the Pi to the base.](#attach-the-raspberry-pi-to-the-rover)
-3. [Connect the components.](#connect-the-wires)
-4. [Screw the top of the rover back on and turn the rover on.](#turn-the-rover-on)
-5. [Install `viam-server` and connect to Viam.](#connect-to-viam)
-
-### Install Raspberry Pi OS
-
-Install a 64-bit Raspberry Pi OS onto your Pi following our [Raspberry Pi installation guide](/operate/reference/prepare/rpi-setup/).
-Follow all steps as listed.
-You must also enable I<sup>2</sup>C on your Pi using `sudo raspi-config` so that your Pi can communicate with the accelerometer on your rover.
-
-### Attach the Raspberry Pi to the Rover
-
-Once you have installed Raspberry Pi OS and `viam-server`, put your SD card in the slot on your Pi.
-To be able to attach the Raspberry Pi, unscrew the top of the rover with the biggest Allen key.
-Then use the smallest Allen key and the provided M2.5 screws to attach the Raspberry Pi to your rover in the designated spots.
-The following image shows the four mounting holes for the Pi, circled in red:
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover/topless-rover.jpg" resize="500x" alt="The Viam Rover 1 base with the top removed. The motors, chips and wires are exposed." >}}
-
-{{< alert title="Tip" color="tip" >}}
-The rover's design allows you to reach the SD card slot at all times, so you can remove or reinsert the SD card without removing the top of the rover.
-{{< /alert >}}
-
-### Connect the wires
-
-{{< alert title="Tip" color="tip" >}}
-To make it easier for you to see which pin is which, you can print out this [Raspberry Pi Leaf](/appendix/try-viam/viam-raspberry-leaf-8.5x11.pdf) which has labels for the pins and carefully push it onto the pins or fold or cut it so you can hold it up to the Raspberry Pi pins.
-If you use A4 paper, use this [Raspberry Pi Leaf](/appendix/try-viam/viam-raspberry-leaf-A4.pdf) instead.
-
-If you are having trouble punching the pins through, you can pre-punch the pin holes with a pen.
-Only attach the paper when the Pi is unplugged.
-To make attaching the paper easier, use a credit card or a small screwdriver.
-{{< /alert >}}
-
-Wire your Pi to the buck converter, the acceleration tilt module, and the DC motor driver:
-
-![Closeup of the wiring diagram, showcasing the Pi, motor driver, accelerometer, and buck converter, wired according to the table below.](/appendix/try-viam/rover-resources/viam-rover/rover-wiring-diagram.png)
-
-The following pinout corresponds to the diagram:
-
-<!-- prettier-ignore -->
-| Component | Component Pin | Raspberry Pi Pin | Wire Color |
-| --------- | --- | ---------------- | ---------- |
-| Buck Converter | GND | 39 | black |
-| Buck Converter | 5V | 4 | red |
-| Acceleration Tilt Module | GND | 34 | black |
-| Acceleration Tilt Module | 3.3V power | 17 | red |
-| Acceleration Tilt Module | SDA | 3 | maroon |
-| Acceleration Tilt Module | SCL | 5 | pink |
-| DC Motor Driver | En B | 22 | gray |
-| DC Motor Driver | In 4 | 18 | yellow |
-| DC Motor Driver | In 3 | 16 | white |
-| DC Motor Driver | In 2 | 13 | green |
-| DC Motor Driver | In 1 | 11 | blue |
-| DC Motor Driver | En A | 15 | purple |
-| DC Motor Driver | GND | 6 | black |
-| DC Motor Driver | Encoder Left | 35 | yellow |
-| DC Motor Driver | 3.3V power | 1 | red |
-| DC Motor Driver | Encoder Right | 37 | white |
-
-{{< alert title="Tip" color="tip" >}}
-En A and En B pins have little plastic jumpers that you need to remove before wiring.
-
-The motor driver on the Viam Rover 1 has 8 pins and 6 wires.
-You must wire it with the outside row pins:
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover/wiring-closeup.jpg" resize="400x" declaredimensions=true alt="closeup of the motor driver wiring" >}}
-{{< /alert >}}
-
-Then connect the camera's USB cable to the Pi.
-
-![Wiring diagram showcasing the Pi, motors, driver, camera, and all other rover components.](/appendix/try-viam/rover-resources/viam-rover/rover-wiring-diagram-full.png)
-
-![the Pi, motors, driver, and all other rover components](/appendix/try-viam/rover-resources/viam-rover/rover-with-pi.jpg)
-
-### Turn the rover on
-
-Once you have wired up all the components, reattach the top of the rover and fasten the screws.
-Insert the batteries and turn the rover on.
-If the Pi has power, the lights on the Raspberry Pi will light up.
-
-### Connect to Viam
-
-While the Pi boots, go to the [Viam](https://app.viam.com/robots) and add a new machine.
-Navigate to the **CONFIGURE** tab and find your machine's card.
-An alert will be present directing you to **Set up your machine part**.
-Click **View setup instructions** to open the setup instructions.
-Follow the instructions to install `viam-server` on **Linux / Aarch64**.
-
-{{< glossary_tooltip term_id="RDK" text="RDK" >}} type.
-`ssh` into your Pi and follow the setup instructions to install and run `viam-server` on the machine.
-
-To configure your rover so you can start driving it, [add the Viam fragment to your Machine](/dev/reference/try-viam/rover-resources/rover-tutorial-fragments/).
-
-## Next steps
-
-Before you can use your Viam rover with the Viam platform you need to configure your rover:
-
-{{< cards >}}
-{{% card link="/dev/reference/try-viam/rover-resources/rover-tutorial-fragments/" %}}
-{{< /cards >}}
-
-After you have configured your rover, follow one of these tutorials:
-
-{{< cards >}}
-{{% card link="/tutorials/control/drive-rover/" %}}
-{{% card link="/tutorials/services/navigate-with-rover-base/" %}}
-{{< /cards >}}
-
-### Rover build
-
-If you want to learn more about the rover, you can find the CAD files and bill-of-materials (BOM) on [GitHub](https://github.com/viamrobotics/Rover-VR1).
-
-### Extensibility
-
-Due to the aluminum chassis and its expandable mounting features, you can extend the Viam Rover 1.
-With it, you can customize your rover by mounting additional sensors, lidar, robot arms, or other components.
-The following are just a few ideas, but you can expand or modify the rover kit with any components you want:
-
-- For GPS navigation, we support NMEA (using serial and I<sup>2</sup>C) and RTK.
-  Make and model don't make a difference as long as you use these protocols.
-  See [Movement Sensor Component](/operate/reference/components/movement-sensor/) for more information.
-- For [LiDAR laser range scanning](/operate/reference/services/slam/cartographer/), we recommend RPlidar (including A1, which is a sub-$100 LIDAR).
-- For robot arms, we tried the [Yahboom DOFBOT robotics arm](https://category.yahboom.net/products/dofbot-jetson_nano) with success.
-
-### Mount an RPlidar to the rover
-
-If you are mounting an RPlidar to your rover, be sure to position the RPlidar so that it faces forward in the direction of travel, facing in the same direction as the included webcam.
-For example, if you are using the [RPlidar A1](https://www.slamtec.com/en/Lidar/A1) model, mount it to the Rover so that the pointed end of the RPlidar mount housing points in the direction of the front of the Rover.
-This ensures that the generated {{< glossary_tooltip term_id="slam" text="SLAM" >}} map is oriented in the expected direction relative to the Rover, with the top of the generated map corresponding to the direction the RPlidar is facing when you initiate mapping.
-
-If you need a mount plate for your RPlidar A1 or A3 model, you can 3D print an adapter plate using the following:
-
-- [RPlidar A1 adapter STL](https://github.com/viamrobotics/Rover-VR1/blob/master/CAD/RPIidarA1_adapter.STL)
-- [RPlidar A3 adapter STL](https://github.com/viamrobotics/Rover-VR1/blob/master/CAD/RPIidarA3_adapter.STL)
diff --git a/docs/dev/reference/try-viam/rover-resources/rover-tutorial-fragments.md b/docs/dev/reference/try-viam/rover-resources/rover-tutorial-fragments.md
deleted file mode 100644
index 527586dd5a..0000000000
--- a/docs/dev/reference/try-viam/rover-resources/rover-tutorial-fragments.md
+++ /dev/null
@@ -1,213 +0,0 @@
----
-title: "Configure your Viam Rover with a Fragment"
-linkTitle: "Configure your Viam Rover"
-weight: 20
-type: "docs"
-tags: ["rover", "tutorial"]
-description: "Configure your rover by adding the Viam-provided configuration fragment to your rover."
-aliases:
-  - "/try-viam/rover-resources/rover-tutorial-fragments/"
-  - "/get-started/try-viam/rover-resources/rover-tutorial-fragments/"
-  - /appendix/try-viam/rover-resources/rover-tutorial-fragments/
-date: "2022-01-01"
-# updated: ""  # When the content was last entirely checked
----
-
-To be able to drive your rover, you need to configure it.
-Viam provides reusable {{% glossary_tooltip term_id="fragment" text="*fragments*" %}} for [Viam rovers](https://www.viam.com/resources/rover).
-
-## Prerequisites
-
-- An assembled Viam Rover.
-  For assembly instructions, see [Unbox and Set Up your Viam Rover](../rover-tutorial/)
-- The board is connected to Viam.
-  To add your Pi to Viam, refer to [the rover setup guide](/dev/reference/try-viam/rover-resources/rover-tutorial/#control-your-rover-on-viam).
-
-## Add the fragment
-
-Follow the appropriate instructions for the model of rover and board you have:
-
-{{< tabs >}}
-{{% tab name="Viam Rover 2 (RPi 5)" %}}
-
-Navigate to your machine's page.
-In the left-hand menu of the **CONFIGURE** tab, click the **+** (Create) icon next to the machine {{< glossary_tooltip term_id="part" text="part" >}} you want to add the fragment to.
-
-Select **Insert fragment**.
-Now, you can see the available fragments to add.
-Select [`ViamRover2-2024-rpi5`](https://app.viam.com/fragment/11d1059b-eaed-4ad8-9fd8-d60ad7386aa2/json) and click **Insert fragment** again to add the fragment to your machine configuration:
-
-{{<imgproc src="appendix/try-viam/rover-resources/fragments/fragments_list.png" resize="400x" style="width: 500px" alt="List of available fragments" class="shadow" >}}
-
-Click **Save** in the upper right corner of the page to save your new configuration.
-
-The fragment adds the following components to your machine's JSON configuration:
-
-- A [board component](/operate/reference/components/board/) named `local` representing the Raspberry Pi.
-- Two [motors](/operate/reference/components/motor/gpio/) (`right` and `left`)
-  - The configured pin numbers correspond to where the motor drivers are connected to the board.
-- Two [encoders](/operate/reference/components/encoder/single/), one for each motor
-- A wheeled [base](/operate/reference/components/base/), an abstraction that coordinates the movement of the right and left motors
-  - Width between the wheel centers: 356 mm
-  - Wheel circumference: 381 mm
-  - Spin slip factor: 1
-- A webcam [camera](/operate/reference/components/camera/webcam/)
-- An [accelerometer](https://github.com/viam-modules/tdk-invensense/)
-- A [power sensor](https://github.com/viam-modules/texas-instruments/)
-
-For information about how to configure components yourself when you are not using the fragment, click the links on each component above.
-To see the configured pin numbers and other values specific to this fragment, [view it in the app](https://app.viam.com/fragment?id=7c413f24-691d-4ae6-a759-df3654cfe4c8).
-
-{{% /tab %}}
-{{% tab name="Viam Rover 2 (RPi 4)" %}}
-
-Navigate to your machine's page.
-In the left-hand menu of the **CONFIGURE** tab, click the **+** (Create) icon next to the machine {{< glossary_tooltip term_id="part" text="part" >}} you want to add the fragment to.
-
-Select **Insert fragment**.
-Now, you can see the available fragments to add.
-Select [`ViamRover2-2024-rpi4-a`](https://app.viam.com/fragment/7c413f24-691d-4ae6-a759-df3654cfe4c8/json) and click **Insert fragment** again to add the fragment to your machine configuration:
-
-{{<imgproc src="appendix/try-viam/rover-resources/fragments/fragments_list.png" resize="400x" style="width: 500px" alt="List of available fragments" class="shadow" >}}
-
-Click **Save** in the upper right corner of the page to save your new configuration.
-
-The fragment adds the following components to your machine's JSON configuration:
-
-- A [board component](/operate/reference/components/board/) named `local` representing the Raspberry Pi.
-- Two [motors](/operate/reference/components/motor/gpio/) (`right` and `left`)
-  - The configured pin numbers correspond to where the motor drivers are connected to the board.
-- Two [encoders](/operate/reference/components/encoder/single/), one for each motor
-- A wheeled [base](/operate/reference/components/base/), an abstraction that coordinates the movement of the right and left motors
-  - Width between the wheel centers: 356 mm
-  - Wheel circumference: 381 mm
-  - Spin slip factor: 1
-- A webcam [camera](/operate/reference/components/camera/webcam/)
-- An [accelerometer](https://github.com/viam-modules/tdk-invensense/)
-- A [power sensor](https://github.com/viam-modules/texas-instruments/)
-
-For information about how to configure components yourself when you are not using the fragment, click the links on each component above.
-To see the configured pin numbers and other values specific to this fragment, [view it in the app](https://app.viam.com/fragment?id=7c413f24-691d-4ae6-a759-df3654cfe4c8).
-
-{{% /tab %}}
-{{% tab name="Viam Rover 1 (RPi 4)" %}}
-
-Navigate to your machine's page.
-In the left-hand menu of the **CONFIGURE** tab, click the **+** (Create) icon next to the machine {{< glossary_tooltip term_id="part" text="part" >}} you want to add the fragment to.
-
-Select **Insert fragment**.
-Now, you can see the available fragments to add.
-Select [`ViamRover202210b`](https://app.viam.com/fragment/3e8e0e1c-f515-4eac-8307-b6c9de7cfb84/json) and click **Insert fragment** again to add the fragment to your machine configuration:
-
-{{<imgproc src="appendix/try-viam/rover-resources/fragments/fragments_list.png" resize="400x" style="width: 500px" alt="List of available fragments" class="shadow" >}}
-
-Click **Save** in the upper right corner of the page to save your configuration.
-
-The fragment adds the following components to your machine's JSON configuration:
-
-- A [board component](/operate/reference/components/board/) named `local` representing the Raspberry Pi
-  - An I<sup>2</sup>C bus for connection to the accelerometer.
-- Two [motors](/operate/reference/components/motor/gpio/) (`right` and `left`)
-  - The configured pin numbers correspond to where the motor drivers are connected to the board.
-- Two [encoders](/operate/reference/components/encoder/single/), one for each motor
-- A wheeled [base](/operate/reference/components/base/), an abstraction that coordinates the movement of the right and left motors
-  - Width between the wheel centers: 260 mm
-  - Wheel circumference: 217 mm
-  - Spin slip factor: 1
-- A webcam [camera](/operate/reference/components/camera/webcam/)
-- An [accelerometer](https://github.com/viam-modules/analog-devices/)
-
-{{% alert title="Info" color="info" %}}
-
-This particular motor driver has pins labeled "ENA" and "ENB."
-Typically, this would suggest that they should be configured as enable pins, but on this specific driver these function as PWM pins, so we configure them as such.
-
-{{% /alert %}}
-
-For information about how you would configure a component yourself if you weren't using the fragment, click the links on each component above.
-To see the configured pin numbers and other values specific to this fragment, [view it in the app](https://app.viam.com/fragment?id=3e8e0e1c-f515-4eac-8307-b6c9de7cfb84).
-
-{{% /tab %}}
-{{% tab name="Viam Rover 2 (Jetson Nano)" %}}
-
-Navigate to your machine's page.
-In the left-hand menu of the **CONFIGURE** tab, click the **+** (Create) icon next to the machine {{< glossary_tooltip term_id="part" text="part" >}} you want to add the fragment to.
-
-Select **Insert fragment**.
-Now, you can see the available fragments to add.
-Select [`ViamRover2-2024-jetson-nano-a`](https://app.viam.com/fragment/747e1f43-309b-4311-b1d9-1dfca45bd097/json) and click **Insert fragment** again to add the fragment to your machine configuration.
-
-{{<imgproc src="appendix/try-viam/rover-resources/fragments/fragments_list.png" resize="400x" style="width: 500px" alt="List of available fragments" class="shadow" >}}
-
-Click **Save** in the upper right corner of the page to save your new configuration.
-
-The fragment adds the following components to your machine's JSON configuration:
-
-- A [board component](/operate/reference/components/board/) named `local` representing the Jetson.
-- Two [motors](/operate/reference/components/motor/gpio/) (`right` and `left`)
-  - The configured pin numbers correspond to where the motor drivers are connected to the board.
-- Two [encoders](/operate/reference/components/encoder/single/), one for each motor
-- A wheeled [base](/operate/reference/components/base/), an abstraction that coordinates the movement of the right and left motors
-  - Width between the wheel centers: 356 mm
-  - Wheel circumference: 381 mm
-  - Spin slip factor: 1
-- A webcam [camera](/operate/reference/components/camera/webcam/)
-- An [accelerometer](https://github.com/viam-modules/tdk-invensense/)
-- A [power sensor](https://github.com/viam-modules/texas-instruments/)
-
-For information about how to configure components yourself when you are not using the fragment, click the links on each component above.
-To see the configured pin numbers and other values specific to this fragment, [view it in the app](https://app.viam.com/fragment?id=747e1f43-309b-4311-b1d9-1dfca45bd097).
-
-{{% /tab %}}
-{{% tab name="Viam Rover 2 (Jetson Orin Nano)" %}}
-
-Navigate to your machine's page.
-In the left-hand menu of the **CONFIGURE** tab, click the **+** (Create) icon next to the machine {{< glossary_tooltip term_id="part" text="part" >}} you want to add the fragment to.
-
-Select **Insert fragment**.
-Now, you can see the available fragments to add.
-Select [`ViamRover2-2024-nano-orin-a`](https://app.viam.com/fragment/6208e890-8400-4197-bf0f-e8ddeca4e157/json) and click **Insert fragment** again to add the fragment to your machine configuration:
-
-{{<imgproc src="appendix/try-viam/rover-resources/fragments/fragments_list.png" resize="400x" style="width: 500px" alt="List of available fragments" class="shadow" >}}
-
-Click **Save** in the upper right corner of the page to save your new configuration.
-
-The fragment adds the following components to your machine's JSON configuration:
-
-- A [board component](/operate/reference/components/board/) named `local` representing the Jetson.
-- Two [motors](/operate/reference/components/motor/gpio/) (`right` and `left`)
-  - The configured pin numbers correspond to where the motor drivers are connected to the board.
-- Two [encoders](/operate/reference/components/encoder/single/), one for each motor
-- A wheeled [base](/operate/reference/components/base/), an abstraction that coordinates the movement of the right and left motors
-  - Width between the wheel centers: 356 mm
-  - Wheel circumference: 381 mm
-  - Spin slip factor: 1
-- A webcam [camera](/operate/reference/components/camera/webcam/)
-- An [accelerometer](https://github.com/viam-modules/tdk-invensense/)
-- A [power sensor](https://github.com/viam-modules/texas-instruments/)
-
-For information about how to configure components yourself when you are not using the fragment, click the links on each component above.
-To see the configured pin numbers and other values specific to this fragment, [view it in the app](https://app.viam.com/fragment?id=6208e890-8400-4197-bf0f-e8ddeca4e157).
-
-{{% /tab %}}
-{{< /tabs >}}
-
-## See the components on the configuration page
-
-Adding a fragment to your machine adds the configuration to your machine.
-The components and services included in the fragment will now appear as cards on the **CONFIGURE** tab, along with a card for your fragment:
-
-{{<imgproc src="appendix/try-viam/rover-resources/fragments/fragments_cards.png" resize="400x" style="width: 500px" alt="List of available fragments" class="shadow" >}}
-
-## Modify the config
-
-The fragment you added is read-only, but if you need to modify your rover's config you can [overwrite sections of the fragment](/manage/fleet/reuse-configuration/#modify-fragment-settings-on-a-machine).
-
-## Next steps
-
-After you have configured your rover, follow one of these tutorials:
-
-{{< cards >}}
-{{% card link="/tutorials/control/drive-rover/" %}}
-{{% card link="/tutorials/services/navigate-with-rover-base/" %}}
-{{< /cards >}}
diff --git a/docs/dev/reference/try-viam/rover-resources/rover-tutorial/_index.md b/docs/dev/reference/try-viam/rover-resources/rover-tutorial/_index.md
deleted file mode 100644
index 3bc800c210..0000000000
--- a/docs/dev/reference/try-viam/rover-resources/rover-tutorial/_index.md
+++ /dev/null
@@ -1,415 +0,0 @@
----
-title: "Unbox and Set Up your Viam Rover 2"
-linkTitle: "Unbox and Set Up your Viam Rover 2"
-weight: 10
-type: "docs"
-tags: ["rover", "tutorial"]
-images: ["/appendix/try-viam/rover-resources/viam-rover-2/box-contents.png"]
-imageAlt: "A Viam Rover 2 in a box"
-description: "A list of the contents of the Viam Rover 2 kit, instructions for wiring your rover, and links for additional hardware."
-no_list: true
-aliases:
-  - "/get-started/try-viam/rover-resources/rover-tutorial"
-  - /appendix/try-viam/rover-resources/rover-tutorial/
-date: "2022-01-01"
-# updated: ""  # When the content was last entirely checked
----
-
-{{% alert title="Tip" color="tip" %}}
-Another version of the Viam Rover was sold until January 2024.
-If you have purchased a Viam Rover 1, follow [these instructions](/dev/reference/try-viam/rover-resources/rover-tutorial-1/) instead.
-{{% /alert %}}
-
-The [Viam Rover 2](https://www.viam.com/resources/rover) arrives preassembled with two encoded motors with suspension, a webcam with a microphone unit, a 6 axis IMU, power management and more.
-It is primarily designed for use with a Raspberry Pi 4.
-You can use it with [other types of boards](#motherboard) with some additional setup.
-
-{{< alert title="Important" color="note" >}}
-You must purchase the following hardware separately:
-
-- A Raspberry Pi 4
-- Four 18650 batteries (with charger) or a RC type battery with dimensions no greater than 142mm x 47mm x 60mm (LxWxH) (with charger)
-- A MicroSD card and an adapter/reader
-  {{< /alert >}}
-
-This guide covers what's inside the kit and provides instructions for [setting up your rover](#setup).
-
-{{< alert title="Note" color="note" >}}
-The design for this rover is open source.
-Find the details on [GitHub](https://github.com/viamrobotics/Viam-Rover-2).
-{{< /alert >}}
-
-## What's inside the kit
-
-1. One assembled Viam Rover.
-
-   {{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/rover-side.png" resize="400x" declaredimensions=true alt="The side of the assembled Viam Rover">}}
-
-1. Four M2.5 screws for mounting your Raspberry Pi.
-
-   {{<imgproc src="appendix/try-viam/rover-resources/viam-rover/screws.jpg" resize="200x" declaredimensions=true alt="Four screws" >}}
-
-1. Two spare stiffer suspension springs.
-   You can swap them out with the springs that come with the rover if you need stiffer suspension for higher payload applications.
-
-   {{<imgproc src="appendix/try-viam/rover-resources/viam-rover/suspension-springs.jpg" resize="200x" declaredimensions=true alt="Two suspension springs" >}}
-
-1. Three different Allen wrenches (1.5 mm, 2 mm, and 2.5 mm) to unscrew the top and mount the Raspberry Pi.
-
-   {{<imgproc src="appendix/try-viam/rover-resources/viam-rover/allen-wrenches.png" resize="180x" alt="Three allen wrenches" >}}
-
-1. Four extenders to increase the height of the rover to house larger internal single-board computers (such as a Jetson Orin Nano).
-
-   {{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/extenders.png" resize="400x" declaredimensions=true alt="Four extenders" >}}
-
-1. Ribbon cable for connecting the Raspberry Pi 4 to the Viam Rover 2 printed circuit board.
-
-   {{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/ribbon-cable.png" resize="400x" declaredimensions=true alt="Ribbon cable" >}}
-
-All together, your kit looks like this:
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/box-contents.png" resize="400x" declaredimensions=true alt="A Viam Rover shipping box contents" >}}
-
-## Rover components
-
-### Dual drive motors with suspension and integrated motor encoders
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover/encoder-motors.jpg" resize="400x" declaredimensions=true alt="two motors with encoders" >}}
-
-The motors come with integrated encoders.
-For information on encoders, see [Encoder Component](/operate/reference/components/encoder/).
-For more information on encoded DC motors, see [Encoded Motors](/operate/reference/components/motor/encoded-motor/).
-
-The kit also includes stiffer suspension springs that you can substitute for the ones on the rover.
-Generally, a stiff suspension helps with precise steering control.
-In contrast, a soft suspension allows the wheels to move up and down to absorb small bumps on the rover's path.
-
-### Motor driver
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover/motor-driver.png" resize="400x" declaredimensions=true alt="A L298N motor driver" >}}
-
-The kit comes with an L298N driver dual H-Bridge DC motor driver.
-L298 is a high voltage and high current motor drive chip, and H-Bridge is typically used to control the rotating direction and speed of DC motors.
-
-### 720p webcam with integrated microphone
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover/webcam.jpg" resize="400x" declaredimensions=true alt="Webcam with cables" >}}
-
-The webcam that comes with the kit is a standard USB camera device and the rover has a custom camera mount for it.
-For more information, see [Camera Component](/operate/reference/components/camera/).
-
-### Motherboard
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/motherboard.png" resize="400x" declaredimensions=true alt="Viam rover 2 motherboard" >}}
-
-The Viam Rover 2 uses a motherboard to which all ancillary components (buck converter, motor driver, IMU, INA219) are mounted.
-This board includes an auxiliary Raspberry Pi 4 pinout that dupont connectors can be connected to, an auxiliary power input terminal, 5V, 3.3V and Ground pins.
-
-The motherboard also incorporates hole patterns for the following alternative single-board computers:
-
-- Jetson Nano and Orin Nano
-- Rock Pi S
-- Raspberry Pi Zero 2W
-- Raspberry Pi 5
-- Orange Pi Zero 2
-
-See [Alternative Board Configurations](#alternative-board-configurations) for a diagram of this.
-Note that these boards require additional parts to be purchased and will not work out of the box with the Viam Rover 2.
-
-### 6DOF IMU
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/mpu6050.png" resize="400x" declaredimensions=true alt="An MPU6050 gyroscope" >}}
-
-The MPU6050 sensor is a digital 6-axis accelerometer or gyroscope that can read acceleration and angular velocity.
-You can access it through the I2C digital interface.
-You configure it with Viam on your machine as a [movement sensor](https://github.com/viam-modules/tdk-invensense/).
-
-### INA219 power monitoring unit
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/ina219.png" resize="400x" declaredimensions=true alt="An INA219 unit" >}}
-
-The INA219 unit measures the voltage and current from the power supply.
-You can use it to measure battery life status and power consumption.
-It connects to the Raspberry Pi 4 through the I2C bus.
-You configure it with Viam on your machine as a [power sensor](https://github.com/viam-modules/texas-instruments/).
-
-### DC-DC 5V converter
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/buck-converter.png" resize="300x" declaredimensions=true alt="A OKY3502-4 buck converter" >}}
-
-The DC-to-DC power converter, or, buck converter, steps down voltage from its input to its output.
-The OKY3502-4 has a USB output that can provide an additional 5V supply to auxiliary components.
-
-### Switch and low voltage cutoff circuit
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/slide-switch.png" resize="400x" declaredimensions=true alt="The switch mounted on the Viam rover 2" >}}
-
-A slide switch is connected to the rover.
-Use it to turn the power on and off.
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/circuit.png" resize="400x" declaredimensions=true alt="Low-voltage cutoff circuit" >}}
-
-Mounted above the switch is a low voltage cutoff circuit that can be set to turn off power to the rover when the input voltage drops below a pre-set threshold.
-This can be helpful for preventing batteries fully discharging which can damage lithium ion batteries.
-
-### Battery holders
-
-The Viam Rover 2 comes with two battery holder options.
-The rover nominally operates with four 18650 batteries, but a higher capacity RC-type battery can be mounted into the rear of the rover.
-
-{{% alert title="Note" color="note" %}}
-With either battery option, you must purchase a charger separately.
-{{% /alert %}}
-
-#### 18650 battery pack
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/battery-pack.png" resize="400x" declaredimensions=true alt="A battery pack" >}}
-
-18650 batteries are the nominal power supply recommended for use with the Viam Rover 2.
-An 18650 battery is a lithium-ion rechargeable battery.
-We recommend the button-top type, though either button or flat top can work.
-Any brand is suitable as long as you comply with the battery safety requirements.
-
-#### Mount for RC-type battery
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/RC-mount.png" resize="400x" declaredimensions=true alt="RC battery mount" >}}
-
-You can mount a larger capacity RC-type battery into the rover.
-You must wire the appropriate connector into the switch circuit.
-
-RC-batteries are lithium-ion rechargeable batteries.
-Caution should always be taken when using such batteries, always comply with the battery safety requirements.
-Check the [safety](#safety) section for more information.
-
-## Safety
-
-Read all instructions fully before using this product.
-
-This product is not a toy and is not suitable for children under 12.
-
-Switch the rover off when not in use.
-
-{{< alert title="Warning" color="warning" >}}
-Lithium-ion batteries may pose a flammable hazard.
-This product requires four 18650 lithium-ion batteries OR an RC-type battery.
-DO NOT connect multiple power sources simultaneously.
-Refer to the battery manufacturer’s operating instructions to ensure safe operation of the Viam Rover.
-Dispose of lithium-ion batteries per manufacturer instructions.
-{{< /alert >}}
-
-{{< alert title="Caution" color="caution" >}}
-Damage may occur to the Raspberry Pi and/or Viam Rover if wired incorrectly.
-Refer to the manufacturer’s instructions for correct wiring.
-{{< /alert >}}
-
-Disclaimer: This product is preliminary and experimental in nature, and is provided "AS IS" without any representation or warranty of any kind.
-Viam does not make any promise or warranty that the product will meet your requirements or be error free.
-Some states do not allow the exclusion or disclaimer of implied warranties, so the above exclusions may not apply to you.
-
-## Setup
-
-{{% alert title="Important" color="info" %}}
-If you wish to use a Jetson Nano or Jetson Orin Nano, follow [this guide](./jetson-rover-setup/) instead.
-{{% /alert %}}
-
-### Install Raspberry Pi OS
-
-{{% alert title="Tip" color="tip" %}}
-If you are using another board, you can skip this step.
-{{% /alert %}}
-
-Install a 64-bit Raspberry Pi OS onto your Pi following our [Raspberry Pi installation guide](/operate/reference/prepare/rpi-setup/).
-Follow all steps as listed.
-You must also enable I<sup>2</sup>C on your Pi using `sudo raspi-config` so that your Pi can communicate with the accelerometer and power sensor on your rover.
-Once you have installed Raspberry Pi OS and `viam-server`, put your SD card in the slot on your Pi.
-
-### Add the power supply
-
-You can power the Viam Rover 2 using 18650 batteries or RC-type batteries.
-18650 batteries are the nominal power supply recommended for use with the rover, but RC-type batteries are higher capacity.
-
-{{< tabs >}}
-{{% tab name="18650 Batteries" %}}
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/rover-underview.png" resize="400x" declaredimensions=true alt="Under view of rover with battery pack." >}}
-
-The Viam Rover 2 arrives with the 18650 battery pack wired into the power input terminal block.
-The battery pack works with batteries 67.5 mm in length, but the battery housing includes a spring to accommodate most batteries of that approximate length.
-
-- Turn the rover over so that you can see the battery housing.
-- Place four 18650 batteries (taking care to ensure correct polarity orientation) inside the battery pack to provide power to the rover, which can be turned on and off through the power switch.
-
-{{% alert title="Tip" color="tip" %}}
-Ensure that the batteries are making contact with the terminals inside the battery pack.
-Some shorter batteries might need to be pushed along to ensure that contact is being made.
-{{% /alert %}}
-
-{{% /tab %}}
-{{% tab name="RC-Type Battery" %}}
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/rcbattery-underneath.png" resize="400x" declaredimensions=true alt="Under view of rover with battery pack." >}}
-
-For users who prefer a higher capacity battery option, the Viam Rover 2 can house RC-type batteries that do not exceed the following dimensions:- 142mm x 47mm x 60mm (LxWxH).
-Using a RC-type battery requires some re-wiring of the Viam Rover 2 which should only be undertaken by users who are comfortable handling electrical assemblies.
-Improper configuration of the power supply could result in damage to the battery and poses a fire hazard.
-A 4-S RC-type battery is recommended (14.8V).
-We make no recommendations regarding specific RC battery brands.
-
-To change the rover's power supply configuration for a RC-battery:
-
-1.  Ensure the 18650 battery holder contains no batteries
-2.  Unscrew the 18650 battery leads from the power input terminal.
-    Move these wires out of the way.
-3.  Screw in a power lead that matches that of the selected battery.
-    Common options include: EC-type connectors, XT-connectors or T-plugs.
-    Ensure lead is long enough to reach the battery.
-4.  Ensure that the polarity is correct (the polarity is marked on the PCB).
-    **Failure to do so may result in permanent damage to your Viam Rover 2 when powered on.**
-5.  Ensure that there is no short between the terminals (for example, due to a stray strand of wire). Use a multimeter to check continuity across the terminal to verify this.
-    Failure to do so may result in damage to the battery and may pose a fire hazard.
-6.  Place the battery in the receptacle between the two caster wheels:
-    {{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/RC-mount.png" resize="400x" declaredimensions=true alt="RC battery mount" >}}
-    Connect the battery to the lead that is wired into the power input terminal.
-    Although not necessary, slots in the bottom plate of the rover allow a velcro strap to be placed around the battery to secure it.
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% alert title="Caution" color="caution" %}}
-DO NOT connect both power supplies at the same time.
-These suggestions are alternative configurations.
-Connecting multiple batteries together may result in damage to the batteries and rover, it may also pose a fire hazard.
-{{% /alert %}}
-
-### Configure the low voltage cutoff circuit
-
-Now that you have connected your power supply to your rover, you need to configure the [low voltage cutoff circuit](#switch-and-low-voltage-cutoff-circuit).
-You must configure two settings:
-
-1.  The low voltage cutoff
-2.  The reconnect voltage
-
-The reconnect voltage is the voltage increment above the cutoff point that is needed for the power to reconnect.
-For both 18650 and RC-type battery inputs, the nominal voltage is 14.8V, so you should set the low voltage threshold to 14.7.
-You can adjust this value if using a battery that has an alternative nominal voltage.
-
-To set the low voltage cutoff and reconnect voltage:
-
-1.  Turn on the circuit using the switch.
-    The LED indicator should indicate a current voltage level of 14.8-16V depending on the battery charge status:
-
-    {{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/circuit-led.png" resize="300x" declaredimensions=true alt="LED with voltage level displayed on low voltage cutoff circuit" >}}
-
-2.  Hold down the left button until the LED display starts flashing with the low cutoff value.
-    The factory default low cutoff value is 12V.
-3.  Use the left (+) and right (-) buttons to set the voltage to 14.7V (or whatever you want the cutoff to be).
-4.  Wait for the indicator to stop flashing.
-5.  Hold down the right button until the LED display starts flashing with the reconnect voltage value. The factory default reconnect voltage is 2.0V.
-6.  Use the left (+) and right (-) buttons to set the reconnect voltage to 0.2V.
-7.  Wait for the indicator to stop flashing.
-
-Your voltage cutoff circuit is now configured.
-When the voltage drops below 14.8V (or reaches the cutoff point you chose), a relay will disconnect the motherboard.
-A minimum voltage of 14.9V will be needed to reconnect the power (that is, after charging the batteries).
-
-### Connect the ribbon cable, Pi, and camera
-
-{{% alert title="Tip" color="tip" %}}
-If you are using another board, follow the instructions in [Alternative board configurations](#alternative-board-configurations) in place of this step.
-{{% /alert %}}
-
-To be able to attach the Raspberry Pi, unscrew the top of the rover with the biggest Allen key.
-Then use the smallest Allen key and the provided M2.5 screws to attach the Raspberry Pi to your rover through the standoffs on the motherboard.
-The Raspberry Pi 4 should be mounted such that the USB ports are to the right, as viewed from above.
-
-Use the ribbon cable to connect the Raspberry Pi 4 to the motherboard.
-The ribbon cable comes connected to the motherboard out of the box, wrap it over the top of the Raspberry Pi 4 and connect with the GPIO pins as shown:
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/ribbon-cable1.png" resize="400x" declaredimensions=true alt="Ribbon cable attached to pi" >}}
-<br>
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/ribbon-cable2.png" resize="400x" declaredimensions=true alt="Ribbon cable attached to pi" >}}
-
-Also, connect the webcam's USB lead to any USB port on your Pi.
-
-Assuming you are using a Raspberry Pi 4, you can skip the following section and move to [Screw the top plate back on and switch the rover on](#screw-the-top-plate-back-on-and-switch-the-rover-on).
-
-### Alternative board configurations
-
-This guide assumes you are using a Raspberry Pi 4, but you can use [different boards](#motherboard) with your Viam Rover 2 with some modifications while attaching the boards.
-
-{{% alert title="Tip" color="tip" %}}
-If you are using a Jetson board, you should be following [this guide](./jetson-rover-setup/).
-{{% /alert %}}
-
-Reference the appropriate alternative hole pattern provided on the motherboard:
-
-{{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/hole-patterning.png" resize="400x" declaredimensions=true alt="Viam rover 2 motherboard hole patterns" >}}
-
-Detach the motherboard, unscrew the standoffs, and move them to the correct holes.
-Then, use the smallest Allen key and the provided M2.5 screws to attach your board to your rover through these standoffs.
-
-{{< expand "Raspberry Pi Zero 2W" >}}
-If you are using a Raspberry Pi Zero 2W, you should be able to connect your ribbon cable straight to the board.
-If not, you will have to take off the ribbon cable and use [dupont connectors](https://www.amazon.com/IWISS-1550PCS-Connector-Headers-Balancer/dp/B08X6C7PZM/) to wire a connection from the motherboard to the single-board computer's GPIO pins.
-{{< /expand >}}
-
-{{< expand "Raspberry Pi 5" >}}
-If you are using a Raspberry Pi 5, use the same screw placements as for the Raspberry Pi 4.
-The hardware setup is the same.
-The only difference is in the [configuration](/dev/reference/try-viam/rover-resources/rover-tutorial-fragments/).
-{{< /expand >}}
-
-Then connect the webcam's USB lead to any USB port on your board.
-
-If you need to increase the height of your rover to accommodate your board being larger than a Raspberry Pi 4, place the [height extender standoffs](#whats-inside-the-kit) now.
-
-### Screw the top plate back on and switch the rover on
-
-Screw the top plate back on with the biggest Allen key and use the power switch to turn the rover on.
-Wait a second for the low voltage cutoff relay to trip and provide power to the rover motherboard.
-If the Pi has power, the lights on the Raspberry Pi will light up.
-
-### Control your rover on Viam
-
-If you followed the instructions in the [Pi installation guide](/operate/reference/prepare/rpi-setup/), you should have already made a Viam account, installed `viam-server` on the board, and added a new machine.
-
-If not, add a new machine and follow the {{< glossary_tooltip term_id="setup" text="setup instructions" >}} until your machine is connected.
-
-To configure your rover so you can start driving it, [add a Viam Rover 2 fragment to your machine](/dev/reference/try-viam/rover-resources/rover-tutorial-fragments/).
-
-## Next steps
-
-Before you can use your Viam rover with the Viam platform you need to configure your rover:
-
-{{< cards >}}
-{{% card link="/dev/reference/try-viam/rover-resources/rover-tutorial-fragments/" %}}
-{{< /cards >}}
-
-After you have configured your rover, follow one of these tutorials:
-
-{{< cards >}}
-{{% card link="/tutorials/control/drive-rover/" %}}
-{{% card link="/tutorials/services/navigate-with-rover-base/" %}}
-{{< /cards >}}
-
-### Extensibility
-
-Due to the aluminum chassis and its expandable mounting features, you can extend the Viam Rover.
-With it, you can customize your rover by mounting additional sensors, lidar, robot arms, or other components.
-The following are just a few ideas, but you can expand or modify the rover kit with any components you want:
-
-- For GPS navigation, we support NMEA (using serial and I<sup>2</sup>C) and RTK.
-  Make and model don't make a difference as long as you use these protocols.
-  See [Movement Sensor Component](/operate/reference/components/movement-sensor/) for more information.
-- For [LiDAR laser range scanning](/operate/reference/services/slam/cartographer/), we recommend RPlidar (including A1, which is a sub-$100 LIDAR).
-- For robot arms, we tried the [Yahboom DOFBOT robotics arm](https://category.yahboom.net/products/dofbot-jetson_nano) with success.
-
-### Mount an RPlidar to the rover
-
-If you are mounting an RPlidar to your rover, be sure to position the RPlidar so that it faces forward in the direction of travel, facing in the same direction as the included webcam.
-For example, if you are using the [RPlidar A1](https://www.slamtec.com/en/Lidar/A1) model, mount it to the Rover so that the pointed end of the RPlidar mount housing points in the direction of the front of the Rover.
-This ensures that the generated {{< glossary_tooltip term_id="slam" text="SLAM" >}} map is oriented in the expected direction relative to the Rover, with the top of the generated map corresponding to the direction the RPlidar is facing when you initiate mapping.
-
-If you need a mount plate for your RPlidar A1 model, you can 3D print an adapter plate using the following:
-
-- [RPlidar A1 adapter STL](https://github.com/viamrobotics/Viam-Rover-2/blob/main/CAD/RPIidar_adapter_v2.STL)
diff --git a/docs/dev/reference/try-viam/rover-resources/rover-tutorial/jetson-rover-setup.md b/docs/dev/reference/try-viam/rover-resources/rover-tutorial/jetson-rover-setup.md
deleted file mode 100644
index c532a598ce..0000000000
--- a/docs/dev/reference/try-viam/rover-resources/rover-tutorial/jetson-rover-setup.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-title: "Set up your Rover 2 with a Jetson"
-linkTitle: "Set Up your Rover 2 with a Jetson"
-weight: 10
-type: "docs"
-tags: ["rover", "tutorial"]
-images: ["/appendix/try-viam/rover-resources/viam-rover-2/box-contents.png"]
-imageAlt: "A Viam Rover 2 in a box"
-description: "Instructions for setting up a Viam Rover 2 with a Jetson Nano or Jetson Orin Nano."
-aliases:
-  - /get-started/try-viam/rover-resources/rover-tutorial/jetson-rover-setup/
-  - /appendix/try-viam/rover-resources/rover-tutorial/jetson-rover-setup/
-date: "2022-01-01"
-# updated: ""  # When the content was last entirely checked
----
-
-The [Viam Rover 2](https://www.viam.com/resources/rover) arrives preassembled with two encoded motors with suspension, a webcam with a microphone unit, a 6 axis IMU, power management and more.
-It is primarily designed for use with a Raspberry Pi 4, but you can use it with a larger Jetson board with some additional setup.
-
-This guide provides supplemental instructions for setting up your rover with a Jetson Nano.
-
-{{< tabs >}}
-{{% tab name="Jetson Nano" %}}
-
-{{% alert title="Important" color="note" %}}
-You must purchase the following hardware separately:
-
-- Four 18650 batteries (with charger) or a RC type battery with dimensions no greater than 142mm x 47mm x 60mm (LxWxH) (with charger)
-- A MicroSD card and an adapter/reader
-- A longer 40 pin ribbon cable: female-female
-- 4 25 mm female-female standoffs
-- WiFi board: either [a board that directly interfaces with the Nano](https://www.amazon.com/Wireless-AC8265-Wireless-Developer-Support-Bluetooth/dp/B07V9B5C6M/) or [a USB based device](https://www.amazon.com/wireless-USB-WiFi-Adapter-PC/dp/B07P5PRK7J/)
-- Electrical tape
-
-The ribbon cable you purchase must meet these requirements:
-
-- Female-female
-- 2.54 mm spacing
-- Both connectors facing the same direction
-- Pin continuity order to be 12-12
-- Recommended length ~200 mm
-  {{% /alert %}}
-
-## Safety
-
-Read all instructions fully before using this product.
-
-This product is not a toy and is not suitable for children under 12.
-
-Switch the rover off when not in use.
-
-{{< alert title="Warning" color="warning" >}}
-Lithium-ion batteries may pose a flammable hazard.
-This product requires four 18650 lithium-ion batteries OR an RC-type battery.
-DO NOT connect multiple power sources simultaneously.
-Refer to the battery manufacturer’s operating instructions to ensure safe operation of the Viam Rover.
-Dispose of lithium-ion batteries per manufacturer instructions.
-{{< /alert >}}
-
-{{< alert title="Caution" color="caution" >}}
-Damage may occur to the board and/or Viam Rover if wired incorrectly.
-Refer to the manufacturer’s instructions for correct wiring.
-{{< /alert >}}
-
-Disclaimer: This product is preliminary and experimental in nature, and is provided "AS IS" without any representation or warranty of any kind.
-Viam does not make any promise or warranty that the product will meet your requirements or be error free.
-Some states do not allow the exclusion or disclaimer of implied warranties, so the above exclusions may not apply to you.
-
-## Setup
-
-1. Install the WiFi board/device on the Nano. Follow the manufacturer's instructions to do so.
-2. Power the Jetson Nano with a power supply and [prepare the device and install `viam-server`](/operate/reference/prepare/jetson-nano-setup/).
-3. Switch back to the main guide and complete these two steps:
-   [Add the power supply](/dev/reference/try-viam/rover-resources/rover-tutorial/#add-the-power-supply) and [Configure the low-voltage cutoff circuit](/dev/reference/try-viam/rover-resources/rover-tutorial/#configure-the-low-voltage-cutoff-circuit).
-4. Unscrew the top of the rover with the biggest Allen key.
-5. Take the [height extenders](/dev/reference/try-viam/rover-resources/rover-tutorial/#whats-inside-the-kit) provided in your kit.
-   Apply them to the rover chassis posts.
-6. Unscrew the standoffs in the motherboard and relocate them to the Jetson board hole pattern:
-   {{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/hole-patterning.png" resize="400x" declaredimensions=true alt="Viam rover 2 motherboard hole patterns" >}}
-7. Connect the ribbon cable to the motherboard and Jetson Nano.
-   The ribbon cable needs to be routed towards the front of the rover and flip back to the pins on the Jetson Nano, as pictured:
-   {{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/jetson-ribbon.png" resize="400x" declaredimensions=true alt="The Jetson ribbon cable" >}}
-8. Use the smallest Allen key and the provided M2.5 screws to attach your board to your rover through these standoffs. The USB ports should be facing the left-hand side of the rover, when viewed from above:
-   {{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/jetson-motherboard.png" resize="400x" declaredimensions=true alt="The underside of a rover with the Jetson mounted" >}}
-9. Connect the webcam's USB lead to any USB port on your board.
-10. Flip the power switch to turn your rover on.
-
-{{% /tab %}}
-{{% tab name="Jetson Orin Nano" %}}
-
-{{% alert title="Important" color="note" %}}
-You must purchase the following hardware separately:
-
-- A 4S RC type battery with dimensions no greater than 142mm x 47mm x 60mm (LxWxH) (with charger)
-- A MicroSD card and an adapter/reader
-- A longer ribbon cable: female-female (ensure that the contacts are correct)
-- 4 25 mm female-female standoffs
-- WiFi board: either [a board that directly interfaces with the Nano](https://www.amazon.com/Wireless-AC8265-Wireless-Developer-Support-Bluetooth/dp/B07V9B5C6M/) or [a USB based device](https://www.amazon.com/wireless-USB-WiFi-Adapter-PC/dp/B07P5PRK7J/)
-- A wired DC jack connector with the same polarity as the Jetson Orin Nano power input
-- Electrical tape
-
-The ribbon cable you purchase must meet these requirements:
-
-- Female-female
-- 2.54 mm spacing
-- Both connectors facing the same direction
-- Pin continuity order to be 12-12
-- Recommended length ~200 mm
-  {{% /alert %}}
-
-## Safety
-
-Read all instructions fully before using this product.
-
-This product is not a toy and is not suitable for children under 12.
-
-Switch the rover off when not in use.
-
-{{< alert title="Warning" color="warning" >}}
-Lithium-ion batteries may pose a flammable hazard.
-This product requires four 18650 lithium-ion batteries OR an RC-type battery.
-DO NOT connect multiple power sources simultaneously.
-Refer to the battery manufacturer’s operating instructions to ensure safe operation of the Viam Rover.
-Dispose of lithium-ion batteries per manufacturer instructions.
-{{< /alert >}}
-
-{{< alert title="Caution" color="caution" >}}
-Damage may occur to the Jetson Orin Nano and/or Viam Rover if wired incorrectly.
-Refer to the manufacturer’s instructions for correct wiring.
-{{< /alert >}}
-
-Disclaimer: This product is preliminary and experimental in nature, and is provided "AS IS" without any representation or warranty of any kind.
-Viam does not make any promise or warranty that the product will meet your requirements or be error free.
-Some states do not allow the exclusion or disclaimer of implied warranties, so the above exclusions may not apply to you.
-
-## Setup
-
-1. Power the Jetson Orin Nano with a power supply and [prepare the device and install `viam-server`](/operate/reference/prepare/jetson-nano-setup/).
-2. Switch back to the main guide and complete these two steps:
-   [Add the power supply](/dev/reference/try-viam/rover-resources/rover-tutorial/#add-the-power-supply) and [Configure the low-voltage cutoff circuit](/dev/reference/try-viam/rover-resources/rover-tutorial/#configure-the-low-voltage-cutoff-circuit).
-3. Unscrew the top of the rover with the biggest Allen key.
-4. Take the [height extenders](/dev/reference/try-viam/rover-resources/rover-tutorial/#whats-inside-the-kit) provided in your kit.
-   Apply them to the rover chassis posts.
-5. Unscrew the standoffs in the motherboard and relocate them to the Jetson board hole pattern:
-   {{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/hole-patterning.png" resize="400x" declaredimensions=true alt="Viam rover 2 motherboard hole patterns" >}}
-6. **IMPORTANT:** Disconnect the 5V buck converter. Unlike other boards, the Jetson Orin Nano requires a 7-20V input, which means that the board must be powered directly from the battery.
-   **Before commencing, ensure that everything is powered off.**
-   It is recommended that you clip the buck converter wires completely and place electrical tape over the exposed contacts, as pictured:
-   {{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/clip-wires.png" resize="250x" declaredimensions=true alt="Clipping the buck converter wires" >}}
-   {{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/tape.png" resize="250x" declaredimensions=true alt="Placing electrical tape over the exposed contacts" >}}
-7. Connect the ribbon cable to the motherboard and Jetson Orin Nano.
-8. Use the smallest Allen key and the provided M2.5 screws to attach your board to your rover through these standoffs. The USB ports should be facing the left-hand side of the rover, when viewed from above: {{<imgproc src="appendix/try-viam/rover-resources/viam-rover-2/jetson-orin-motherboard.png" resize="400x" declaredimensions=true alt="The underside of a rover with the Jetson Orin Nano mounted" >}}
-9. Connect a WiFi adapter or a board that directly interfaces to the underside of the Jetson Orin Nano.
-10. Connect the webcam's USB lead to any USB port on your board.
-11. Flip the power switch to turn your rover on.
-
-{{% /tab %}}
-{{< /tabs >}}
-
-### Control your rover on Viam
-
-If you followed the instructions in the [Jetson installation guide](/operate/reference/prepare/jetson-nano-setup/), you should have already made a Viam account, installed `viam-server` on the board, and added a new machine.
-
-To configure your rover so you can start driving it, [add a Viam Rover 2 fragment to your machine](/dev/reference/try-viam/rover-resources/rover-tutorial-fragments/).
-
-## Next steps
-
-After adding the appropriate fragment, follow one of these tutorials with your borrowed or owned rover:
-
-{{< cards >}}
-{{% card link="/tutorials/control/drive-rover/" %}}
-{{< /cards >}}
diff --git a/docs/dev/reference/try-viam/try-viam-tutorial.md b/docs/dev/reference/try-viam/try-viam-tutorial.md
deleted file mode 100644
index c768de9aa4..0000000000
--- a/docs/dev/reference/try-viam/try-viam-tutorial.md
+++ /dev/null
@@ -1,234 +0,0 @@
----
-title: "Control A Rented Viam Rover"
-linkTitle: "Control A Rented Viam Rover"
-weight: 39
-type: "docs"
-description: "Remotely control a Viam Rover located on-site at Viam in New York."
-images: ["/appendix/try-viam/rover-resources/viam-rover/rover-front.jpg"]
-imageAlt: "The front of the assembled Viam Rover"
-tags: ["try viam", "app"]
-no_list: true
-draft: true
-aliases:
-  - "/try-viam/try-viam-tutorial/"
-  - "/get-started/try-viam/try-viam-tutorial/"
-date: "2022-01-01"
-# updated: ""  # When the content was last entirely checked
----
-
-_Try Viam_ is a way to try out the Viam platform without setting up any hardware yourself.
-You can take over a Viam Rover in our robotics lab to play around!
-
-The rental rover is made up of a chassis with a Raspberry Pi 4B single-board computer, two motors, encoders, and a camera.
-The Try Viam area also has an overhead camera to provide a view of the rental rover, allowing you to view its movements in real time.
-
-Watch this tutorial video for a walkthrough of Try Viam, including [how to reserve a Viam Rover](/dev/reference/try-viam/reserve-a-rover/#using-the-reservation-system), [navigate the Viam platform](/operate/), and [drive the rover](#control-tab):
-
-{{<youtube embed_url="https://www.youtube-nocookie.com/embed/YYpZ9CVDwMU">}}
-
-## **CONTROL** tab
-
-Click on the rover name at the top to go to the rental rover's **CONTROL** tab where you can drive the machine and interact with each of the machine's components.
-
-At the top of the page you can see the randomly assigned name of the rover, the host, and the IP address.
-
-![The top banner of a Try Viam rover machine page. The randomly generated name for this rover is 'silent-forest'](appendix/try-viam/try-viam/bannerinfo.png)
-
-The **CONTROL** tab contains panels for each of the rover's components:
-
-- the base,
-- the left and right motors,
-- the web game pad,
-- the board, and
-- two cameras.
-
-The order of these components may vary.
-
-{{<imgproc src="/appendix/try-viam/try-viam/control-panel-list.png" resize="700x" declaredimensions=true alt="The component panels on the CONTROL tab of the Try Viam rover. None of them are expanded yet so they display as thin rectangles with component names and types shown.">}}
-
-### Base control
-
-The [base component](/operate/reference/components/base/) is the platform that the other parts of a mobile machine attach to.
-
-Click the `viam_base` component to expand the base control pane to reveal the camera feed and driving interfaces.
-
-![The viam_base component panel on the CONTROL tab. The Keyboard Disabled toggle is grey and not yet enabled.](appendix/try-viam/try-viam/initial-base-control.png)
-
-#### Camera views
-
-In the `viam_base` component panel, select the `cam` for the front-facing camera and the `overhead-cam:overheadcam` for an overhead view of your rover.
-We recommend enabling both cameras so you can have a better sense of what's happening in the space.
-
-![The viam_base component panel showing both the 'cam' and 'overheadcam' camera feeds enabled.](appendix/try-viam/try-viam/enable-both-cameras.png)
-
-You can also view and control the camera streams from the individual camera components on the [**CONTROL** page](/manage/troubleshoot/teleoperate/default-interface/#web-ui).
-
-#### Movement control
-
-To move your rover, click on **viam_base**.
-You can use the **W**, **A**, **S**, and **D** buttons to move forward, turn left, move backwards, and turn right.
-
-If you enable the keyboard toggle, you can also control the rover's movement with the **W**, **A**, **S**, and **D** keys and the arrow keys on your keyboard.
-
-{{% alert title="Tip" color="tip" %}}
-
-Each time you show or hide a camera, **Keyboard Enabled** automatically toggles to **Keyboard Disabled**.
-
-If you change your camera configurations, you must re-enable your keyboard control to control your rover again.
-This behavior is for safety purposes.
-
-{{% /alert %}}
-
-##### Discrete movement control
-
-If you go from the from **Keyboard** to the **Discrete** tab, you can choose between:
-
-- Different movement modes: `Straight` or `Spin`
-- Different movement types: `Continuous` or `Discrete`
-
-  In _continuous_ movement mode you can set a speed at which the rover will move indefinitely in the specified direction.
-  In _discrete_ movement mode you can set a speed at which to move and a distance to cover before stopping.
-
-- Directions: `Forwards` and `Backwards`.
-
-![The DISCRETE tab of the viam_base component panel. Movement mode, movement type, and direction mode toggles are shown as well as a speed (mm/sec) field and a distance field (the latter of which is greyed out because the movement type toggle is set to continuous instead of discrete movement).](appendix/try-viam/try-viam/discrete.png)
-
-### Camera control
-
-While you can view the camera streams [from the base component panel](#camera-views), you can access more features on each individual [camera component](/operate/reference/components/camera/) panel. In these panels, you can:
-
-- Set the refresh frequency
-- Export screenshots
-- View point cloud data (for machines with depth cameras)
-
-**cam Stream**:
-
-![The front-facing camera panel (for the component named 'cam').](appendix/try-viam/try-viam/cam-panel.png)
-
-**overhead-cam:overheadcam Stream**:
-
-![The overhead camera panel (for the component named 'overhead-cam').](appendix/try-viam/try-viam/overhead-cam-panel.png)
-
-### Motor control
-
-The [motor components](/operate/reference/components/motor/) enable you to move the base.
-The motors are named `left` and `right`, corresponding to their location on the rover base.
-Their initial state is **Idle**.
-You can click on each motor panel and make the motor **RUN** or **STOP**.
-
-![The left and right motor panels on the CONTROL tab.](appendix/try-viam/try-viam/left-right-panels.png)
-
-Run each motor at a different power level to go faster or slower, and toggle rotation directions to go forwards or backwards.
-You can also see their current positions (based on encoder readings) in real time:
-
-![The left motor running at 20% power and forwards and right motor running at 80% power and backwards.](appendix/try-viam/try-viam/motors-running.png)
-
-{{<gif webm_src="/appendix/try-viam/rotating.webm" mp4_src="/appendix/try-viam/rotating.mp4" alt="The robot rotating with the left motor running at 20% power and forwards and right motor running at 80% power and backwards." max-width="400px" class="aligncenter">}}
-
-#### Board control
-
-The [board component](/operate/reference/components/board/) is the signal wire hub of a machine which allows you to control the states of individual GPIO pins on the board.
-
-For the Viam Rover, the board component is named `local` and controls a Raspberry Pi on the Viam Rover.
-With it, you can control the states of individual GPIO pins on the board.
-
-![The board panel in the CONTROL tab, including fields to get and set GPIO pin states.](appendix/try-viam/try-viam/board-panel.png)
-
-#### Web gamepad control
-
-The [web gamepad component](/components/input-controller/webgamepad/) is disabled by default, but if you have a compatible gamepad, you can enable the **Enabled** toggle.
-
-## Learn about machine configuration
-
-On your machine's page, navigate to the **CONFIGURE** tab.
-There you can view the configuration for each component in the machine: attributes, component dependencies, pin assignments, and more.
-
-![The CONFIG tab in Builder mode (as opposed to Raw JSON). The board component panel and right motor panel are visible.](appendix/try-viam/try-viam/config-builder.png)
-
-### Board configuration
-
-The [board component](/operate/reference/components/board/) is the signal wire hub of a machine.
-Configuring a board component allows you to control the states of individual GPIO pins to command the electrical signals sent through and received by the board.
-For the Viam Rover, the board component is a Raspberry Pi with **Name** `local`, **Type** `board`, and **Model** `viam:raspberry-pi:rpi`.
-
-### Encoder configuration
-
-An [encoder](/operate/reference/components/encoder/) is a device that is used to sense angular position, direction and/or speed of rotation.
-In this case, the encoders on the left and right motors are `Lenc` and `Renc` and configure the pins to `le` and `re`.
-
-{{< alert title="Important" color="note" >}}
-When configuring encoded motors for your own robot, you must configure the encoders before the motors because the motors depend on the encoders.
-{{< /alert >}}
-
-![The right encoder config panel with the board attribute set to 'local' and the pins struct containing 'i' set to 're'.](appendix/try-viam/try-viam/right-encoder.png)
-
-### Motor configuration
-
-Both [motors](/operate/reference/components/motor/) on this rover use the model `gpio` which is the model for basic DC motors that are connected to and controlled by the configured board.
-
-The attributes section lists the board the motor is wired to, and since the rover's motors are encoded the user interface also shows the encoded motor attributes: the encoder name, motor ramp rate limit, encoder ticks per rotation, and max RPM limit.
-
-You can click **{}** (Switch to Advanced) on the top right of the component's card to view the attributes field in raw JSON format.
-The attributes pane contains the current JSON configuration for this component.
-Click **Switch to Builder** to return to the default graphical user interface.
-
-### Base configuration
-
-The [base component](/operate/reference/components/base/) is the platform that the other parts of a mobile robot attach to.
-By configuring a base component, the individual components are organized to produce coordinated movement and you gain an interface to control the movement of the whole physical base of the robot without needing to send separate commands to individual motors.
-The base's type is `base` and its model is `wheeled` which configures a robot with wheels on its base, like the Viam Rover.
-The **left** and **right** attributes configure the motors on the left and right side of the rover, which are named `left` and `right`, respectively.
-
-The **Wheel Circumference** (in millimeters) is 217.
-The **Width** is the distance between wheel centerlines, 260mm in this case.
-The **Spin Slip Factor** of 1.76 is used in steering calculations to account for slippage of the wheels against the ground while turning.
-
-![The base configuration panel, showing right and left motors, wheel circumference set to 217, width set to 260mm, and spin slip factor set to 1.76.](appendix/try-viam/try-viam/base-config.png)
-
-### Camera configuration
-
-The [camera component](/operate/reference/components/camera/) configures the webcam that is plugged into the Raspberry Pi of the rover.
-The camera component has the **Type** `camera`, the **Model** `webcam`, and the **Video Path** is `video0`.
-
-For more information on choosing the correct video path, refer to our [webcam documentation](/operate/reference/components/camera/webcam/).
-
-![The video path in the webcam configuration panel is set to 'video0'.](appendix/try-viam/try-viam/camera-config.png)
-
-### Gamepad configuration
-
-The [web gamepad](/components/input-controller/webgamepad/) component has the **Type** `input_controller` and the **Model** `webgamepad`.
-
-![The gamepad configuration panel. No attributes are configured.](appendix/try-viam/try-viam/gamepad-config.png)
-
-If you connect a generic gamepad controller to your computer, you can use it to control your machine.
-
-If you are configuring your own machine, be aware that using the gamepad requires a service.
-To see how the service is configured, navigate to the **Services** section under the **CONFIGURE** tab.
-The **Services** subtab contains the "Base Remote Control" service which uses three attributes:
-
-- **base**: `viam_base`
-- **control_mode**: `joystickControl`
-- **input_controller**: `WebGamepad`
-
-The names for **base** and **input_controller** correspond to the naming scheme from the **Components** tab.
-
-![The base remote control service named 'base_rc' on the Services subtab of the CONFIG tab.](appendix/try-viam/try-viam/base-rc.png)
-
-### Raw JSON
-
-The 'Builder' configuration mode provides a user-friendly, guided experience for you.
-In the background, Viam translates the Viam machine configuration into JSON.
-You can view the complete JSON for your rover by clicking on **Raw JSON** at the top left of the **CONFIGURE** tab.
-
-![The CONFIG tab with the mode toggled to Raw JSON. A section of the full raw JSON config is displayed but one would have to scroll to see all of it.](appendix/try-viam/try-viam/raw-json.png)
-
-You can [copy this `JSON` config between rental rovers](/dev/reference/try-viam/reserve-a-rover/#how-can-i-reuse-my-borrowed-rover).
-
-## Next steps
-
-If you have questions, check out our [FAQ](/dev/reference/try-viam/reserve-a-rover/#faq/) or join our [Discord Community](https://discord.gg/viam), where you can ask questions and meet other people working on robots.
-
-{{< cards >}}
-{{% card link="/tutorials/control/drive-rover/" %}}
-{{% card link="/dev/reference/try-viam/rover-resources/" %}}
-{{< /cards >}}
diff --git a/docs/dev/tools/_index.md b/docs/dev/tools/_index.md
deleted file mode 100644
index ab966c4f30..0000000000
--- a/docs/dev/tools/_index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-linkTitle: "Tools"
-weight: 100
-layout: "empty"
-type: "docs"
-empty_node: true
-open_on_desktop: true
-header_only: true
-canonical: "/dev/tools/cli/"
----
diff --git a/docs/dev/tools/common-errors.md b/docs/dev/tools/common-errors.md
deleted file mode 100644
index ce3de2f88a..0000000000
--- a/docs/dev/tools/common-errors.md
+++ /dev/null
@@ -1,396 +0,0 @@
----
-title: "Common Errors & Known Issues"
-linkTitle: "Common Errors"
-weight: 50
-type: "docs"
-description: "A guide to troubleshooting a Viam-based machine or system of machines with fixes to common problems."
-date: "2022-01-01"
-no_list: true
-# updated: ""  # When the content was last entirely checked
----
-
-This document lists common errors encountered when working with Viam, and provides steps to resolve them.
-While many common issues and their possible resolutions are presented here, this list is not comprehensive.
-
-To view logs or get a remote shell on a machine see [Troubleshoot](/manage/troubleshoot/troubleshoot/).
-
-If you have encountered an error that is not listed here, we'd love to hear from you on our [Community Discord](https://discord.gg/viam)!
-Please post the error message you received along with how you were able to trigger it and we'll see if we can help.
-
-## Status
-
-For information on the status of [app.viam.com](https://app.viam.com), visit [status.viam.com](https://status.viam.com/).
-
-## Common installation errors
-
-### The authenticity of host 'hostname.local' can't be established
-
-**Description:** When following our [installation guides](/operate/install/setup/), you will likely encounter this message the first time you try to make an `ssh` connection to your newly-imaged {{< glossary_tooltip term_id="board" text="board" >}}.
-This is expected: `ssh` is advising you that it has not yet connected to this address, and prompts you for how to proceed.
-
-**Solution:** The message will ask `Are you sure you want to continue connecting?`.
-Type `yes` and then press the return key to continue with the connection.
-You should receive a successful confirmation message similar to: `Warning: Permanently added 'hostname.local' to the list of known hosts.`
-This is only required for the first `ssh` connection you make to a newly-imaged board.
-
-### ssh: connect to host hostname.local port 22: Host is down
-
-**Description:** Your computer is not able to connect to the {{< glossary_tooltip term_id="board" text="board" >}} through `ssh`.
-
-**Solution:** Ensure that both your computer and the board itself are connected to the internet, and verify each of the following:
-
-- If you are on a Windows computer, be sure that you do not have an outgoing firewall rule preventing `ssh` connections over port `22`.
-- Your `ssh` connection string should resemble the following: `ssh username@hostname.local`.
-  Be sure that you match hostname, username, and password exactly to what you initially configured when imaging your board.
-- If you are still unable to connect, restart your board and try your `ssh` connection again after a few minutes.
-- If that fails, try re-imaging your board following the [installation guide](/operate/install/setup/) appropriate for your board.
-  - If using the [Raspberry Pi installation guide](/operate/reference/prepare/rpi-setup/), be sure to carefully enter the configuration details under the **Advanced Options** (gear icon) button on the [Raspberry Pi imager](https://www.raspberrypi.com/software/) before you re-image your board.
-  - If you re-imaged your board and provided a different hostname, you may need to accept the `ssh` host key again by typing `yes` when prompted.
-  - If you re-imaged your board and provided the same hostname, you may see an error message similar to `WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!`.
-    - If so, edit your `~/.ssh/known_hosts` file to delete any single lines that begin with the board hostname you specified (like `hostname.local` or similar).
-    - Afterwards, when you go to `ssh` to your board again, you will need to accept the `ssh` host key once more by typing `yes` when prompted.
-
-### ssh: connect to host hostname port 22: Connection timed out
-
-**Description:** Your computer is not able to connect to the {{< glossary_tooltip term_id="board" text="board" >}} through `ssh` before reaching a timeout.
-
-**Solution:** Depending on your local network and board, it may take a minute or two for your `ssh` connection to successfully reach the board.
-
-- If you have just powered on or restarted your board, wait a few minutes and then try your connection again.
-  Depending on your board, it may take a few minutes for the `ssh` service to be ready to receive connections.
-- If you encounter this error once or twice, try your `ssh` command again and wait until it completes.
-- If the error persists, try the solutions presented for the `Host is down` error message above.
-
-### Something went wrong trying to read the squashfs image
-
-**Full Error:** `Something went wrong trying to read the squashfs image. Open dir error: No such file or directory`
-
-**Description:** The `viam-server` [installation](/operate/install/setup/) or [update](/operate/reference/viam-server/manage-viam-server/#update-viam-server) process may have been interrupted partway, with some files either partially-written or missing.
-
-**Solution:** Reinstall `viam-server` following the [installation instructions](/operate/install/setup/).
-
-### AppImages require FUSE to run
-
-**Related Error:** `dlopen(): error loading libfuse.so.2`
-
-**Description:** `viam-server` is distributed for Linux as an [AppImage](https://appimage.org/), which requires FUSE (Filesystem-in-Userspace) version 2.
-FUSE version 2 is included in almost all modern Linux distributions by default, but some older Linux distros or minimal installs might not provide it out of the box, and some newer systems may ship with FUSE version 3 installed by default, which is not compatible with `viam-server`.
-For example, the latest Raspberry Pi OS (Debian GNU/Linux 12 bookworm) includes FUSE version 3 as its default FUSE installation, and requires FUSE version 2 to be installed as well to support `viam-server`.
-
-In addition, if you are installing `viam-server` within a Docker container, you may also experience this error due to its default security restrictions.
-FUSE is not required for macOS installations of `viam-server`.
-
-{{% alert title="Important" color="note" %}}
-`viam-server` requires FUSE version 2 (`libfuse2`), _not_ FUSE version 3 (`fuse3` or `libfuse3`) or versions of FUSE previous to FUSE version 2 (`fuse`).
-To support a `viam-server` installation, you must install `libfuse2`.
-{{% /alert %}}
-
-**Solution:** If you receive this error, install FUSE version 2 on your Linux system according to one of the following steps:
-
-- If installing `viam-server` on a Raspberry Pi running Raspberry Pi OS (Debian GNU/Linux 12 bookworm or later), install FUSE version 2 with the following command:
-
-  ```sh {class="command-line" data-prompt="$"}
-  sudo apt install libfuse2
-  ```
-
-- If installing `viam-server` on Ubuntu, install FUSE version 2 with the following command:
-
-  ```sh {class="command-line" data-prompt="$"}
-  sudo add-apt-repository universe
-  sudo apt install libfuse2
-  ```
-
-- If installing `viam-server` on a different Linux distribution, see the [AppImage FUSE troubleshooting article](https://github.com/AppImage/AppImageKit/wiki/FUSE) for more information.
-
-- If installing `viam-server` on a Docker image, see [I get some errors related to something called "FUSE" - AppImage documentation](https://docs.appimage.org/user-guide/troubleshooting/fuse.html) for Docker-specific troubleshooting steps.
-
-### PulseAudio: Unable to connect: Connection refused
-
-**Additional Error:** `jack server is not running or cannot be started`
-
-**Description**: When configuring a Linux {{< glossary_tooltip term_id="board" text="board" >}}, Linux installations with broken or misconfigured sound libraries may experience one or both of these errors, even if not using audio components in the machine configuration.
-
-**Solution:** Consult the documentation for your Linux OS and chosen sound library for guidance on installing any missing software dependencies.
-For example, if you are using `jackd` and `PulseAudio` on a Raspberry Pi, you can run the following to install any missing dependencies:
-
-```sh {class="command-line" data-prompt="$"}
-sudo apt install jackd qjackctl libpulse-dev pulseaudio
-```
-
-This error can be safely ignored if you do not intend to use audio on your machine.
-
-## Common connection errors
-
-### Failed to connect; retrying
-
-**Description:** Viam is unable to communicate with your machine, and will attempt to reconnect every few seconds until it is able to do so.
-When a machine is disconnected, it will continue to run with its locally-cached current configuration, but will not be accessible for remote control or configuration through the web UI.
-
-**Solution:** Check the following to ensure your machine is accessible to Viam:
-
-- Is the {{< glossary_tooltip term_id="board" text="board" >}} component connected to the internet?
-- Is the `ssh` service configured and running locally on the board?
-- Is the `viam-server` service running locally on the board?
-  You can check by running `sudo systemctl status viam-server` from within an `ssh` session to the board.
-  It should be listed as `active (running)`.
-
-  - If it is listed as `stopped` or `failed`, you can try restarting it with `sudo systemctl start viam-server`.
-  - If the command returns the message `Unit viam-server.service could not be found`, be sure you have followed the [installation instructions for your board](/operate/install/setup/), and then followed the {{< glossary_tooltip term_id="setup" text="setup instructions" >}}.
-  - If none of the above succeed in getting `viam-server` up and running, check the logs on your board for any pertinent error messages.
-    Depending on your board's specific Linux OS, you might use a command similar to the following to show the 50 most recent log messages from `viam-server`. Run this command from within an `ssh` session to the board:
-
-    ```sh {class="command-line" data-prompt="$"}
-    grep 'viam-server' /var/log/syslog | tail -50
-    ```
-
-### Error: error connecting to peer, error not connected
-
-**Full Error:** `error connecting to peer   error not connected`
-
-**Description:** This error indicates a networking or connection issue.
-
-**Solution:**
-
-1. Verify your machine's internet connection is stable and working properly.
-1. Ensure your machine is using the correct machine cloud credentials.
-   You can obtain your machine cloud credentials from the machine's status in the part status dropdown to the right of your machine’s name on the top of the page.
-1. If you are using API keys to connect, ensure you are using the correct credentials for the machine.
-1. If you have multiple tabs open with your machine's page, close all but one.
-   Having too many connections can cause instability on some machines.
-
-### Error: cannot parse config: JSON: cannot unmarshal string into Go struct
-
-**Full Error:** `Error: cannot parse config: JSON: cannot unmarshal string into Go struct field Component.components.frame of type float64.`
-
-**Description:** A [frame](/operate/reference/services/frame-system/) attribute may be malformed, and is preventing the parsing of the component's configuration.
-
-**Solution:** Check the **CONFIGURE** tab for your machine and look for a `frame` attribute, either in **Frame** or **JSON** mode.
-If you see a `frame` attribute that you didn't create yourself, delete the whole `frame` object from the JSON config.
-In **JSON** mode, it will resemble the following:
-
-```json
-"frame": {
-   "orientation": {
-      "value": {}
-   },
-   "parent": "",
-   "translation": {
-      "x": "",
-      "y": "",
-      "z": ""
-   }
-}
-```
-
-### Error: resource build error: unknown resource type
-
-**Full Error:**
-
-Generalized example::
-
-```sh {class="command-line" data-prompt="$" data-output="1-10"}
-resource build error: unknown resource type: API "<API-TRIPLET>" with model "<MODEL-TRIPLET>" not registered
-```
-
-Camera example:
-
-```sh {class="command-line" data-prompt="$" data-output="1-10"}
-resource build error: unknown resource type: API "rdk:component:camera" with model "viam:orbbec:astra2" not registered.
-```
-
-**Description:** This error occurs when your configuration requests a model with an associated API and the combination of model name and API triplet is not registered with viam-server.
-
-**Solution:**
-
-1. If you are using a registry-provided models, ensure that your machine's configuration includes the module that provides the model.
-   On your machine page, find the module and navigate to it's module page in the registry.
-   You can find the correct model triplet (for example `viam:camera:csi-pi`) in the **Components & services** section of the registry page.
-1. Check for typos in the model triplet.
-   It must exactly match the model registered with `viam-server`.
-1. Ensure the model supports the requested API.
-   You can find the requested APIs next to each model entry in the **Components & services** section of the registry page.
-1. Check for typos in the API triplet (for example `rdk:component:camera`).
-1. Check the logs for other errors.
-   It may be that the instantiation of the model is failing, for other reasons such as the hardware being disconnected.
-
-### Failed to connect to robot within time limit {#conn-time-out}
-
-**Full Error:** `failed to connect to machine within time limit. check network connection, whether the viam-server is running, and try again. see https://docs.viam.com/dev/tools/common-errors/#conn-time-out for troubleshooting steps`
-
-**Description:** This error occurs when the host fails to connect to the robot within the time limit.
-
-**Solution:** See [Network Troubleshooting](/dev/tools/common-errors/#network-troubleshooting) section.
-
-### Could not connect to machine part (context deadline exceeded)
-
-**Full Error:** `Error: Could not connect to machine part: context deadline exceeded; context deadline exceeded; mDNS query failed to find a candidate`
-
-**Description:** This error can occur connecting to a machine with the shell service indicating network issues.
-
-**Solution:** See [Network Troubleshooting](/dev/tools/common-errors/#network-troubleshooting) section.
-
-### Could not connect to machine part (ResourceExhausted)
-
-**Full Error:** `Could not connect to machine part: error updating resources: rpc error: code = ResourceExhausted desc = exceeded request limit 100 on resource viam.robot.v1.RobotService`
-
-**Description:** This error occurs when there are more than 100 concurrent requests to a resource.
-These connections can come from modules or other scripts and apps.
-
-**Solution:** Try to find bottlenecks in scripts or modules that are hitting APIs for the machine in loops.
-You can check operations and sessions for a machine on its **CONTROL** tab at the bottom of the screen.
-To adjust the per-resource limit for modules, you can set the `VIAM_RESOURCE_REQUESTS_LIMIT` [environment variable on your machine](/manage/reference/viam-agent/#environment-variables-for-viam-server) to a positive integer higher than the default, 100.
-
-### Error while dialing app
-
-**Full Error:** `error while dialing app. Could not establish global, unified connection`
-
-**Description:** This error occurs when a machine cannot establish a connection to Viam within the timeout window, by default 15 seconds.
-
-**Solution:** To adjust the initial app connection timeout, you can set the `VIAM_CONFIG_READ_TIMEOUT` [environment variable on your machine](/manage/reference/viam-agent/#environment-variables-for-viam-server) to a positive integer higher than the default, 15.
-
-### exceeded request limit on resource {#req-limit-exceeded}
-
-**Full Error:**
-
-```sh {class="command-line" data-prompt="$" data-output="1-10"}
-Error: exceeded request limit <LIMIT> on resource <RESOURCE>
-```
-
-**Description**:
-
-This error occurs when there are more than, by default, 100 concurrent requests to a resource on a machine.
-The limit applies to calls through both WebRTC and direct gRPC connection, that means requests can come from modules, the Viam web UI, or other resources.
-
-**Solution:**
-
-Try to find bottlenecks in scripts or modules that are hitting APIs for the machine in loops. You can check operations and sessions for a machine on its **CONTROL** tab at the bottom of the screen. To adjust the per-resource limit for modules, you can set the `VIAM_RESOURCE_REQUESTS_LIMIT` [environment variable on your machine](/manage/reference/viam-agent/#environment-variables-for-viam-server) to a positive integer higher than the default, 100.
-
-## Other common errors
-
-### Accidental deletion of machines, locations, organizations, or accounts
-
-If you delete your machine, location, organization, or account by mistake, contact [contact@viam.com](mailto:contact@viam.com) immediately.
-They will try to help but cannot guarantee recovery or restoration.
-
-## Common module errors
-
-### Timed out waiting for module
-
-**Full Error:** `Error adding module - Module X - Error while starting module X: Timed out waiting for module X to start listening.` or `Resource X timed out during reconfigure`
-
-**Description:** This error occurs when a module fails to start up or reconfigure within the default timeout period (5 minutes to start up, 1 minute to reconfigure).
-This can happen when there is a slow internet connection, when the module is trying to download a large number of dependencies, or when the module is running on a device with limited compute resources.
-
-**Solution:**
-
-- Try using a faster internet connection.
-- If you are the module author, consider packaging the module with required dependencies so they don't need to be downloaded on startup.
-  For Python modules, you can package your module with dependencies by using the PyInstaller steps when [uploading your module](/operate/modules/deploy-a-module/#3-deploy-with-cloud-build-recommended).
-- If the problem persists, try setting the `VIAM_MODULE_STARTUP_TIMEOUT` or `VIAM_RESOURCE_CONFIGURATION_TIMEOUT` environment variables on your machine to a higher value.
-  You can set these environment variables when you start `viam-server`, for instance `VIAM_MODULE_STARTUP_TIMEOUT=6m30 VIAM_RESOURCE_CONFIGURATION_TIMEOUT=3m0s viam-server -config example-machine.json`.
-  Pass a sequence of numbers and time units, for example "6m30s50ms" for a timeout of 6 minutes, 30 seconds, and 50 milliseconds, or "5m" for a timeout of 5 minutes.
-
-## Common Micro-RDK errors
-
-### Unable to properly process stun response IceStunEncodingError
-
-**Full Error:** `unable to properly process stun response IceStunEncodingError`
-
-**Description:** Occurs when a client sends a STUN message to a server and receives one of the following problematic responses:
-
-- the response cannot be parsed properly
-- the response indicates a server state that conflicts with the client's understanding of the session state
-
-**Solution:** This error may resolve on its own.
-If not, look for other related errors in your logs.
-
-## Common warnings
-
-### Connection establishment failed
-
-**Full Warning:** `warn rdk.networking.signaler.external   rpc/wrtc_signaling_answerer.go:389   Connection establishment failed`
-
-**Description:** This error indicates a networking or connection issue.
-
-**Solution:** See [Network Troubleshooting](/dev/tools/common-errors/#network-troubleshooting) section.
-
-### Unable to create PeerConnection with module
-
-**Full Warning:** `Unable to create PeerConnection with module. Ignoring.`
-
-**Description:** Indicates that while the gRPC connection to the module is working as expected, the connection to the module does not support efficient video streaming over WebRTC.
-Only some Go-based camera modules support optimized video streaming over WebRTC.
-
-{{% hiddencontent %}}
-You can use any Viam SDK to implement a camera module, but only Go-based modules can access optimized video streaming over WebRTC.
-{{% /hiddencontent %}}
-
-**Solution:** This warning can be safely ignored.
-
-## Network Troubleshooting
-
-1. Check networking:
-
-   1. Check if your machine is showing as online on Viam and [check its logs](/manage/troubleshoot/troubleshoot/#check-logs).
-      When `viam-server` starts it runs a set of network checks which you can view in the logs.
-
-   ```sh {class="command-line" data-prompt="$"}
-   2025-07-16T16:50:57.727Z    INFO    rdk.network-checks    networkcheck/network-check.go:28    Starting network checks
-   2025-07-16T16:50:57.744Z    INFO    rdk    config/platform.go:181    platform tags    {"tags":"os_version:15"}
-   2025-07-16T16:50:58.239Z    INFO    rdk.network-checks.udp    networkcheck/network-check-types.go:110    7/7 udp STUN tests succeeded    {"udp_tests":"[{stun_server_url: global.stun.twilio.com:3478, stun_server_addr: 18.156.18.181:3478, ... }]","udp_source_address":"[::]:54092"}
-   ```
-
-   1. Verify your machine's internet connection is stable and working properly.
-   1. Install [`netcat`](https://nc110.sourceforge.io/) and check if you can access `turn.viam.com:443` and `global.turn.twilio.com:3478`:
-
-      ```sh {class="command-line" data-prompt="$" data-output="2,4"}
-      nc -zv turn.viam.com 443
-      Connection to turn.viam.com port 443 [tcp/https] succeeded!
-      nc -zv global.turn.twilio.com 3478
-      Connection to global.turn.twilio.com port 3478 [tcp/nat-stun-port] succeeded!
-      ```
-
-   1. Check if UDP traffic is restricted in any way.
-      You can do this by checking your router settings and talking to your IT department, if applicable.
-   1. Restart your machine.
-
-1. Check your SDK connection:
-
-   1. If you are using API keys to connect, ensure you are using the correct credentials for the machine.
-   1. Ensure network checks on `viam-server` succeed by using the Go SDK's [`client.WithNetworkStats()`](https://pkg.go.dev/go.viam.com/rdk/robot/client#WithNetworkStats) method when connecting and then checking the logs when executing the code:
-
-      ```go {class="line-numbers linkable-line-numbers" data-line="13"}
-      machine, err := client.New(
-        context.Background(),
-        "mac-main.vw3iu72d8n.viam.cloud",
-      logger,
-      client.WithDialOptions(rpc.WithEntityCredentials(
-          /* Replace "<API-KEY-ID>" (including brackets) with your machine's API key ID */
-        "<API-KEY-ID>",
-        rpc.Credentials{
-            Type:    rpc.CredentialsTypeAPIKey,
-            /* Replace "<API-KEY>" (including brackets) with your machine's API key */
-          Payload: "<API-KEY>",
-        })),
-          client.WithNetworkStats(),
-      )
-      ```
-
-   1. Try connecting with a different SDK to check whether the issue may be SDK-specific or a code issue.
-
-1. If you have multiple tabs open with your machine's page, close all but one.
-   Having too many connections can cause instability on some machines.
-
-## Known application and plugin conflicts
-
-### macOS applications
-
-None at this time.
-
-### Windows applications
-
-None at this time.
-
-### Linux applications
-
-None at this time.
diff --git a/docs/dev/tools/tutorials.md b/docs/dev/tools/tutorials.md
deleted file mode 100644
index 40b9ae36ad..0000000000
--- a/docs/dev/tools/tutorials.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: "Tutorials"
-linkTitle: "Tutorials"
-weight: 30
-type: docs
-layout: "tutorials"
-videos:
-  [
-    "/tutorials/videos/scuttle-gamepad-preview.webm",
-    "/tutorials/videos/scuttle-gamepad-preview.mp4",
-  ]
-videoAlt: "Drive a Scuttle robot with a Bluetooth gamepad."
-images:
-  [
-    "/tutorials/videos/scuttle-gamepad-preview.gif",
-    "/tutorials/try-viam-sdk/image1.gif",
-  ]
-description: "Build a machine yourself by following along with a tutorial."
-no_list: true
-hide_children: true
-sitemap:
-  priority: 1.0
-aliases:
-  - /build/
-  - /tutorials/
-  - /how-tos/
-  - /use-cases/
-outputs:
-  - rss
-  - html
-date: "2024-10-20"
-# updated: ""  # When the content was last entirely checked
----
diff --git a/docs/fleet/_index.md b/docs/fleet/_index.md
new file mode 100644
index 0000000000..66bf277238
--- /dev/null
+++ b/docs/fleet/_index.md
@@ -0,0 +1,13 @@
+---
+linkTitle: "Fleet deployment"
+title: "Fleet deployment"
+weight: 200
+layout: "docs"
+type: "docs"
+no_list: true
+manualLink: "/fleet/overview/"
+description: "Scale from one machine to a fleet: templatize configuration with fragments, provision devices, deploy software and ML models, and manage updates."
+aliases:
+  - /cloud/
+  - /product-overviews/fleet-management/
+---
diff --git a/docs/fleet/change-network.md b/docs/fleet/change-network.md
new file mode 100644
index 0000000000..d03f4440db
--- /dev/null
+++ b/docs/fleet/change-network.md
@@ -0,0 +1,52 @@
+---
+linkTitle: "Change network"
+title: "Change a machine's network"
+weight: 70
+layout: "docs"
+type: "docs"
+description: "Connect a deployed machine to a different WiFi network."
+---
+
+Change the WiFi network on a machine that has already been provisioned and deployed. There are three approaches depending on your situation.
+
+## Option 1: Move to a new WiFi network using provisioning mode
+
+If the machine's current network is no longer available (for example, you moved the machine to a new facility), force the machine back into provisioning mode:
+
+1. Connect to the machine with a shell (if possible):
+
+   ```sh {class="command-line" data-prompt="$"}
+   viam machines part shell --part=<part-id>
+   ```
+
+1. Create a file that forces provisioning mode on next boot:
+
+   ```sh {class="command-line" data-prompt="$"}
+   sudo touch /opt/viam/etc/force_provisioning_mode
+   ```
+
+1. Reboot the machine. On boot, `viam-agent` enters provisioning mode and creates a WiFi hotspot.
+
+1. Follow the [end-user device setup](/fleet/end-user-setup/) instructions to connect the machine to the new network.
+
+If you cannot shell into the machine, power cycle it. If the current network is truly unavailable, `viam-agent` enters provisioning mode automatically after the configured timeout (`retry_connection_timeout_minutes`, default 10 minutes).
+
+## Option 2: Add a new network while keeping the current one
+
+If the machine is still connected to its current network and you want to add a second network (for example, when moving between locations):
+
+1. Add the new network credentials in the machine's system settings. See [configure additional networks](/fleet/system-settings/#configure-additional-networks).
+1. Set the `priority` value higher than the current network if you want the machine to prefer the new one.
+1. Save the configuration. The machine picks up the new network on its next config sync.
+
+## Option 3: Pre-configure multiple networks during provisioning
+
+If you know the machine will need to connect to multiple networks, add them to the `additional_networks` section of the `viam-defaults.json` file before provisioning. See [provision additional networks](/fleet/provision-devices/#provision-additional-networks).
+
+## Verify the network change
+
+After changing the network:
+
+1. In the Viam app, navigate to the fleet dashboard or the machine's page.
+1. Confirm the machine shows as **Live**.
+1. If the machine does not come back online within a few minutes, it may not have connected to the new network. Power cycle the device to restart provisioning mode.
diff --git a/docs/fleet/deploy-ml-models.md b/docs/fleet/deploy-ml-models.md
new file mode 100644
index 0000000000..e31785bb7b
--- /dev/null
+++ b/docs/fleet/deploy-ml-models.md
@@ -0,0 +1,75 @@
+---
+linkTitle: "Deploy ML models"
+title: "Deploy ML models across your fleet"
+weight: 32
+layout: "docs"
+type: "docs"
+description: "Roll out trained ML models to machines using fragments and the Viam registry."
+---
+
+Deploy a trained ML model to one machine or your entire fleet using the same fragment workflow you use for modules. When you retrain and upload a new model version, machines configured to track that version update automatically.
+
+## When to use this
+
+Use this page when you have a trained model in the Viam registry and want to deploy it to multiple machines. If you are deploying to a single machine for the first time, start with [deploy a model to a machine](/train/deploy-a-model/).
+
+## Prerequisites
+
+- A trained ML model in the Viam registry. See [train a model](/train/train-a-model/).
+- At least one machine with a camera configured. See [add a camera](/hardware/common-components/add-a-camera/).
+- A [fragment](/fleet/reuse-configuration/) for your fleet. If you don't have one yet, [create one](/fleet/reuse-configuration/#create-a-fragment) first.
+
+## How model deployment works
+
+ML models are deployed as registry packages, the same way modules are. A machine needs two services to run a model:
+
+1. **ML model service**: loads the model file and runs inference.
+2. **Vision service**: connects the ML model service to a camera and returns detections or classifications.
+
+You configure both services in a fragment, apply the fragment to your machines, and every machine downloads the model and starts running inference.
+
+## 1. Add the model and vision service to a fragment
+
+1. Navigate to your fragment at [app.viam.com/fragments](https://app.viam.com/fragments).
+1. Click **+** and add an ML model service (for example, search for `tflite` and add **tflite_cpu**).
+1. In the ML model service card, under **Deployment**, select **Deploy model on machine**.
+1. Click **Select model** and choose your trained model from the registry.
+1. Click **+** again and add a vision service. Search for `mlmodel` and add the **mlmodel** vision service.
+1. Configure the vision service to use the ML model service you just added.
+1. Click **Save**.
+
+## 2. Choose a version strategy
+
+Each ML model package has a version field in the fragment configuration.
+
+- **Track latest**: leave the version at the default. When you upload a retrained model, machines update automatically on their next config sync.
+- **Pin to a specific version**: set the version string to prevent automatic updates until you are ready.
+- **Use fragment tags**: create `stable` and `development` tags on the fragment. Test new models on development machines before promoting to production. See [reuse configuration](/fleet/reuse-configuration/#version-and-tag-fragments-for-staged-rollouts) for the tag workflow.
+
+To control the timing of updates, configure a maintenance window so models are not swapped while a machine is actively processing. See [manage versions](/fleet/manage-versions/).
+
+## 3. Apply the fragment to machines
+
+Apply the fragment to your machines through the Viam app, provisioning, or CLI. See [deploy software](/fleet/deploy-software/#3-apply-the-fragment-to-machines) for the steps.
+
+## 4. Verify the deployment
+
+1. Navigate to a machine's **CONTROL** tab.
+1. Find the vision service card and test it with a live camera feed to confirm detections or classifications appear.
+1. Check the **LOGS** tab for errors from the ML model service or vision service.
+
+## Update a model across the fleet
+
+When you retrain and upload a new model version:
+
+- **Tracking latest**: machines update on their next config sync (or within the maintenance window).
+- **Using fragment tags**: update the fragment configuration with the new model version, save to create a new revision, then move the `stable` tag to the new revision.
+- **Pinned to a version**: update the version string in the fragment and save.
+
+## Related pages
+
+- [Train a model](/train/train-a-model/) for creating ML models
+- [Deploy a model to a machine](/train/deploy-a-model/) for single-machine deployment
+- [Configure computer vision](/vision/configure/) for vision pipeline details
+- [Reuse configuration](/fleet/reuse-configuration/) for fragment management
+- [Manage versions](/fleet/manage-versions/) for version pinning and maintenance windows
diff --git a/docs/fleet/deploy-software.md b/docs/fleet/deploy-software.md
new file mode 100644
index 0000000000..222c1be8e0
--- /dev/null
+++ b/docs/fleet/deploy-software.md
@@ -0,0 +1,74 @@
+---
+linkTitle: "Deploy software"
+title: "Deploy software to machines"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "Deploy modules and control logic to your fleet using fragments and the Viam registry."
+---
+
+Deploy modules (hardware drivers, control logic, or other custom code) to one machine or an entire fleet. You configure the module in a fragment, apply the fragment to your machines, and the machines download the module from the Viam registry automatically.
+
+## Prerequisites
+
+- A module uploaded to the Viam registry. See [deploy a module](/build-modules/deploy-a-module/) for how to upload.
+- A [fragment](/fleet/reuse-configuration/) for your fleet configuration. If you don't have one yet, [create one](/fleet/reuse-configuration/#create-a-fragment) first.
+
+## 1. Add the module to a fragment
+
+1. Navigate to your fragment's page at [app.viam.com/fragments](https://app.viam.com/fragments).
+1. Click **+** and select **Configuration block**.
+1. Search for your module in the registry and add it.
+1. Configure the module's attributes as needed.
+1. Click **Save**.
+
+## 2. Set the version strategy
+
+Each module in the fragment has a version field. On the fragment card for the module, find the **Update version** section:
+
+- **Latest version**: the machine downloads the newest version when it syncs. This is the default.
+- **Pin to version**: the machine stays on a specific version and does not update automatically.
+- **Pin to tag**: the machine uses whichever version the fragment tag points to. This option appears only when the fragment has tags. See [reuse configuration](/fleet/reuse-configuration/#create-a-tag) for how to create tags.
+
+{{% alert title="Caution" color="caution" %}}
+For any version type other than pinning to a specific version, the module updates as soon as a matching version is available, which restarts the module. If the module cannot be safely interrupted, pin to a specific version and update manually.
+{{% /alert %}}
+
+To control when updates are applied, configure a maintenance window. See [manage versions](/fleet/manage-versions/) for details.
+
+## 3. Apply the fragment to machines
+
+**Through the Viam app:**
+
+1. Navigate to each machine's **CONFIGURE** tab.
+1. Click **+** and select **Configuration block**.
+1. Search for your fragment and select it.
+1. Click **Add fragment**.
+1. Click **Add fragment** again to confirm, then **Save**.
+
+**Through provisioning:**
+
+Include the fragment ID in your `viam-defaults.json` file. New machines apply the fragment automatically on first boot. See [provision devices](/fleet/provision-devices/).
+
+**Through the CLI:**
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part fragments add --part=<part-id> --fragment=<fragment-id>
+```
+
+To find your part ID, run `viam machines part list --machine=<machine-id>`. To find the fragment ID, copy it from the fragment's page in the Viam app or run `viam organizations list` and check your fragments.
+
+## 4. Verify the deployment
+
+1. Navigate to a machine's **CONFIGURE** tab and confirm the module appears in the resource list.
+1. Go to the **CONTROL** tab and test the deployed components or services.
+1. Check the **LOGS** tab for any errors from the module.
+
+On the fleet dashboard at [app.viam.com/fleet/machines](https://app.viam.com/fleet/machines), confirm your machines are online and showing the expected viam-server version.
+
+## Related pages
+
+- [Reuse configuration](/fleet/reuse-configuration/) for creating and managing fragments
+- [Deploy ML models](/fleet/deploy-ml-models/) for deploying trained ML models
+- [Manage versions](/fleet/manage-versions/) for version pinning and maintenance windows
+- [Build and deploy modules](/build-modules/) for writing and uploading modules
diff --git a/docs/fleet/end-user-setup.md b/docs/fleet/end-user-setup.md
new file mode 100644
index 0000000000..aaca3c99e1
--- /dev/null
+++ b/docs/fleet/end-user-setup.md
@@ -0,0 +1,80 @@
+---
+linkTitle: "End-user device setup"
+title: "End-user device setup"
+weight: 25
+layout: "docs"
+type: "docs"
+description: "Connect a Viam-powered device to your WiFi network using the mobile app or captive portal."
+---
+
+If you received a device with Viam pre-installed, follow these instructions to connect it to your WiFi network and complete setup. The method you use depends on how the device manufacturer configured provisioning.
+
+## Prerequisites
+
+- A Viam-powered device (powered off)
+- A WiFi network with internet access
+- A mobile device or laptop
+
+## Set up with the Viam mobile app
+
+Use this method if the device manufacturer configured Bluetooth provisioning.
+
+1. Install the Viam mobile app from the [App Store](https://apps.apple.com/vn/app/viam-robotics/id6451424162) or [Google Play](https://play.google.com/store/apps/details?id=com.viam.viammobile&hl=en&gl=US).
+1. Open the app and sign in. Select an organization and location for your machine.
+1. Create a new machine or select an existing machine that has not been set up.
+1. Power on the device. Wait for it to boot and enable Bluetooth (this may take 1-2 minutes).
+1. Follow the app's instructions to connect to the device's Bluetooth signal. The device name begins with `viam-setup-` by default.
+1. Provide your WiFi network name and password when prompted.
+1. Wait for the device to connect to WiFi and complete setup. The machine appears as **Live** in the app when setup is complete.
+
+If the device cannot connect to the provided network, it re-enables Bluetooth and prompts you to try again.
+
+## Set up with the captive portal
+
+Use this method if the device manufacturer configured WiFi hotspot provisioning.
+
+1. Power on the device. Wait for it to boot and create a WiFi hotspot (this may take 1-2 minutes).
+1. On your laptop or mobile device, open WiFi settings and connect to the device's hotspot. The hotspot name begins with `viam-setup-` by default. The password is `viamsetup` unless the manufacturer changed it.
+1. A captive portal opens automatically. If it does not, open [http://viam.setup/](http://viam.setup/) in a browser.
+1. Enter your WiFi network name and password.
+1. If the captive portal asks for machine cloud credentials, this means the device was not pre-configured with a fragment during provisioning. You need a Viam account to complete this step:
+   - Log into [app.viam.com](https://app.viam.com) and create a new machine (or use an existing one).
+   - On the machine's page, click the part status dropdown next to the machine name.
+   - Click the copy icon next to **Machine cloud credentials**.
+   - Paste the credentials into the captive portal.
+     Most devices provisioned by a manufacturer skip this step automatically.
+1. Wait for the device to connect to WiFi and complete setup.
+
+If the device cannot connect, it recreates the hotspot so you can try again.
+
+## Verify the device is online
+
+After setup, the device should appear as **Live** in the Viam app:
+
+- **Mobile app**: check the machine's status in the app.
+- **Web app**: navigate to [app.viam.com/fleet/machines](https://app.viam.com/fleet/machines) and confirm the machine shows as online.
+
+## Troubleshooting
+
+### Bluetooth connection issues
+
+- Ensure Bluetooth is enabled on your mobile device and the Viam app has Bluetooth permissions.
+- If you previously connected to this device, remove it from your device's Bluetooth settings and try again.
+- Power cycle the device to restart Bluetooth advertising.
+
+### WiFi hotspot not visible
+
+- Wait at least 2 minutes after powering on. The device needs time to boot and create the hotspot.
+- Confirm the hotspot password. The default is `viamsetup` unless the manufacturer changed it.
+- Move closer to the device. The hotspot has limited range.
+
+### Device does not come online after providing WiFi credentials
+
+- Verify the WiFi network name and password are correct.
+- Confirm the WiFi network has internet access. Some networks require a captive portal login (hotel WiFi, corporate guest networks) that the device cannot complete.
+- Check WiFi band compatibility. Some devices only support 2.4 GHz networks.
+- Power cycle the device to restart the provisioning process and try a different network.
+
+## Next steps
+
+Once the device is online, it operates according to its configured fragment. If the device needs access to additional WiFi networks, you can add them through the machine's system settings. See [system settings](/fleet/system-settings/) for details.
diff --git a/docs/fleet/manage-versions.md b/docs/fleet/manage-versions.md
new file mode 100644
index 0000000000..f763882fc3
--- /dev/null
+++ b/docs/fleet/manage-versions.md
@@ -0,0 +1,73 @@
+---
+linkTitle: "Manage versions"
+title: "Manage software versions"
+weight: 35
+layout: "docs"
+type: "docs"
+description: "Control when and how software updates reach your machines with version pinning, fragment tags, and maintenance windows."
+---
+
+Control which software versions your machines run and when updates are applied. By default, machines track the latest version of every module and model. Use version pinning, fragment tags, and maintenance windows to control rollouts more precisely.
+
+## Version pinning options
+
+Each module and ML model package on a machine (configured directly or through a fragment) has a version field with three options:
+
+- **Latest version** (default): the machine downloads the newest version on its next config sync. Updates happen as soon as a new version is available.
+- **Pin to version**: the machine stays on a specific version string and never updates automatically.
+- **Pin to tag**: the machine uses whichever version the fragment tag currently points to. See [fragment tags](/fleet/reuse-configuration/#version-and-tag-fragments-for-staged-rollouts).
+
+{{% alert title="Caution" color="caution" %}}
+When a module updates, it restarts. If the module is performing work that cannot be safely interrupted, pin to a specific version and update manually during planned maintenance.
+{{% /alert %}}
+
+To change the version strategy, navigate to the machine's **CONFIGURE** tab, find the module or fragment card, and update the version setting.
+
+## Maintenance windows
+
+A maintenance window tells `viam-server` when it is safe to apply configuration updates. Without a maintenance window, configuration changes (including module version updates) take effect immediately on sync. With a maintenance window, changes are held until the window opens.
+
+Maintenance windows use a sensor-based approach: you configure a sensor that returns a boolean value indicating whether maintenance is allowed. When the sensor returns `true`, `viam-server` applies pending configuration changes. When it returns `false`, changes are deferred.
+
+### Configure a maintenance window
+
+1. Create a sensor (or use an existing one) that returns a boolean reading indicating whether maintenance is allowed. For example, a sensor that returns `true` during off-hours and `false` during production.
+1. On the machine's **CONFIGURE** tab, click **+**, open the **Advanced** submenu, and select **Maintenance window**.
+1. In the maintenance card, set:
+   - `sensor_name`: the name of the sensor to read.
+   - `maintenance_allowed_key`: the key in the sensor's readings that contains the boolean value.
+1. Click **Save**.
+
+While the maintenance window is closed (sensor returns `false`), `viam-server` continues running with its current configuration. When the window opens, all pending changes are applied at once.
+
+## Staged rollouts with fragment tags
+
+For fleets where you want to test changes before deploying to all machines, use the fragment tag workflow:
+
+1. Create `stable` and `development` tags on your fragment. See [fragment tags](/fleet/reuse-configuration/#create-a-tag).
+2. Pin production machines to the `stable` tag.
+3. Pin test machines to the `development` tag.
+4. Make changes to the fragment and save.
+5. Move the `development` tag to the new revision.
+6. Verify the changes on test machines.
+7. Move the `stable` tag to the new revision. All production machines update.
+
+This gives you a manual gate between development and production without maintaining separate fragments.
+
+## Check what versions your machines are running
+
+The fleet dashboard at [app.viam.com/fleet/machines](https://app.viam.com/fleet/machines) shows the `viam-server` version and `viam-agent` version for each machine part.
+
+To check programmatically, iterate over your machines using the fleet management API, connect to each machine, and use `GetMachineStatus` to retrieve the current configuration and version information.
+
+## Limitations
+
+- Maintenance windows require a sensor that produces a boolean reading. There is no built-in time-based scheduling for maintenance windows; you need a sensor module or logic module that returns `true` during your desired maintenance period.
+- There is no built-in canary or percentage-based rollout. Use fragment tags to control which machines receive updates.
+- Rollback is manual: revert the fragment to a previous revision or pin machines to an older version.
+
+## Related pages
+
+- [Reuse configuration](/fleet/reuse-configuration/) for fragment creation and tag management
+- [Deploy software](/fleet/deploy-software/) for deploying modules through fragments
+- [Deploy ML models](/fleet/deploy-ml-models/) for deploying models through fragments
diff --git a/docs/fleet/metadata.md b/docs/fleet/metadata.md
new file mode 100644
index 0000000000..370fe1fca7
--- /dev/null
+++ b/docs/fleet/metadata.md
@@ -0,0 +1,72 @@
+---
+linkTitle: "Add custom metadata"
+title: "Add custom metadata"
+weight: 50
+layout: "docs"
+type: "docs"
+description: "Attach custom key-value data to machine parts, machines, locations, and organizations."
+---
+
+Attach custom metadata as a JSON object to any level of your fleet hierarchy: machine parts, machines, locations, or organizations. Use metadata to store deployment details, maintenance notes, device serial numbers, or any other data you need to track alongside your machines.
+
+## Add metadata in the Viam app
+
+1. Navigate to the machine part, machine, or location you want to add metadata to.
+1. Click the **...** (actions) menu.
+1. Select **Custom part metadata**, **Custom machine metadata**, or **Custom location metadata** depending on the level.
+1. Edit the JSON object in the editor that appears.
+1. Click **Save**.
+
+Organization-level metadata is available through the SDK and CLI but not through the Viam app UI.
+
+Metadata is stored as an arbitrary JSON object with no required schema. You define the structure.
+
+Example:
+
+```json
+{
+  "serial_number": "SN-2026-0042",
+  "deployment_date": "2026-03-15",
+  "facility": "Building A, Line 3",
+  "firmware_batch": "v2.1.0-rc3"
+}
+```
+
+## Add metadata with the SDK
+
+Use the fleet management API to read and update metadata programmatically at each level:
+
+| Level        | Get method                | Update method                |
+| ------------ | ------------------------- | ---------------------------- |
+| Machine part | `GetRobotPartMetadata`    | `UpdateRobotPartMetadata`    |
+| Machine      | `GetRobotMetadata`        | `UpdateRobotMetadata`        |
+| Location     | `GetLocationMetadata`     | `UpdateLocationMetadata`     |
+| Organization | `GetOrganizationMetadata` | `UpdateOrganizationMetadata` |
+
+## Add metadata with the CLI
+
+Read metadata for a machine and its parts:
+
+```sh {class="command-line" data-prompt="$"}
+viam metadata read --machine-id=<machine-id>
+```
+
+The CLI `metadata read` command aggregates metadata across levels. Pass `--org-id`, `--location-id`, `--machine-id`, or `--part-id` to read specific levels.
+
+## Verify metadata
+
+After adding metadata:
+
+- **Viam app**: click the **...** menu and select the custom metadata option. The JSON object should show your data.
+- **CLI**: run `viam metadata read --machine-id=<machine-id>`.
+- **SDK**: call the corresponding `Get` method to retrieve and confirm the metadata.
+
+## Limitations
+
+- Metadata cannot be deployed through fragments. Each machine's metadata must be set individually through the UI, SDK, or CLI.
+- To set metadata on many machines at once, use the SDK in a script that iterates over your machines.
+
+## Related pages
+
+- [Manage your fleet with the CLI](/cli/manage-your-fleet/) for CLI fleet operations
+- [Automate with scripts](/cli/automate-with-scripts/) for scripting fleet operations
diff --git a/docs/fleet/overview.md b/docs/fleet/overview.md
new file mode 100644
index 0000000000..82c6e03652
--- /dev/null
+++ b/docs/fleet/overview.md
@@ -0,0 +1,51 @@
+---
+linkTitle: "Overview"
+title: "Fleet deployment"
+weight: 1
+layout: "docs"
+type: "docs"
+description: "Scale from one machine to a fleet: templatize configuration with fragments, provision devices, deploy software and ML models, and manage updates."
+---
+
+You have a single machine working. Now you need 10, or 100, or 1,000 machines running the same software with the same configuration. Fleet deployment is how you get there without configuring each machine by hand.
+
+## Three core mechanisms
+
+Viam's fleet deployment is built on three mechanisms that work together:
+
+### Fragments: configuration templates
+
+A fragment is a reusable block of configuration. You define the components, services, modules, and settings a machine needs in a fragment, then apply that fragment to every machine in your fleet. When you update the fragment, every machine that uses it receives the change.
+
+Fragments support **variables** for per-machine customization (different sensor names, different thresholds), **version tags** for controlled rollouts (test on a few machines before deploying to the full fleet), and **overrides** for device-specific adjustments that differ from the template.
+
+### Provisioning: automated first-boot setup
+
+For machines you ship to customers or deploy in the field, provisioning automates the first-boot experience. You install `viam-agent` on a device during manufacturing with a defaults file that specifies which fragment to use. When someone powers on the device, `viam-agent` creates a WiFi hotspot or Bluetooth connection, the user provides network credentials through a mobile app or captive portal, and the machine configures itself from the fragment automatically.
+
+### The module registry: versioned software delivery
+
+Modules and ML models are stored as versioned packages in the Viam registry. When you configure a module or model on a machine (directly or through a fragment), the machine downloads the correct version for its platform. When you upload a new version, machines configured to track that version update automatically. Maintenance windows let you control when updates happen so machines are not interrupted during operation.
+
+## What you can do
+
+| Task                                                 | Guide                                                             |
+| ---------------------------------------------------- | ----------------------------------------------------------------- |
+| Create reusable configuration templates              | [Reuse configuration with fragments](/fleet/reuse-configuration/) |
+| Set up automated device provisioning                 | [Provision devices](/fleet/provision-devices/)                    |
+| Help end users connect new devices to WiFi           | [End-user device setup](/fleet/end-user-setup/)                   |
+| Deploy modules to machines over the air              | [Deploy software](/fleet/deploy-software/)                        |
+| Deploy ML models across your fleet                   | [Deploy ML models](/fleet/deploy-ml-models/)                      |
+| Control when and how software updates reach machines | [Manage versions](/fleet/manage-versions/)                        |
+| Schedule automated tasks on machines                 | [Schedule jobs](/fleet/schedule-jobs/)                            |
+| Tag machines with custom key-value data              | [Add custom metadata](/fleet/metadata/)                           |
+| Configure network, tunneling, and system settings    | [System settings](/fleet/system-settings/)                        |
+| Change a deployed machine's WiFi network             | [Change network](/fleet/change-network/)                          |
+
+## How fleet deployment fits with other sections
+
+- **[Get started](/foundation/)** covers setting up a single machine. Start there if you haven't created your first machine yet.
+- **[Configure hardware](/hardware/)** covers adding components and services to a machine. Use fragments to templatize those configurations for your fleet.
+- **[Build and deploy modules](/build-modules/)** covers writing and uploading modules. This section covers deploying those modules to machines.
+- **[Train ML models](/train/)** covers training models. This section covers deploying trained models fleet-wide.
+- **[Viam CLI](/cli/manage-your-fleet/)** covers fleet operations from the command line: checking machine status, viewing logs, shell access, and file transfer.
diff --git a/docs/fleet/provision-devices.md b/docs/fleet/provision-devices.md
new file mode 100644
index 0000000000..b645c38820
--- /dev/null
+++ b/docs/fleet/provision-devices.md
@@ -0,0 +1,173 @@
+---
+linkTitle: "Provision devices"
+title: "Provision devices"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "Set up automated provisioning so machines configure themselves when they first come online."
+---
+
+Set up zero-touch provisioning so machines you ship or deploy automatically configure themselves on first boot. You install `viam-agent` on the device during manufacturing, define a configuration in a defaults file, and when someone powers on the device and provides network credentials, the machine downloads and applies its configuration from a fragment.
+
+## When to use provisioning
+
+Use provisioning when you are manufacturing or deploying multiple devices that need to come online with a predefined configuration without manual setup per device. Provisioning is designed for:
+
+- Shipping devices to customers who will connect them to their own networks
+- Deploying devices in facilities where IT staff will connect them
+- Setting up field devices that need WiFi or Bluetooth onboarding
+
+If you are setting up a small number of machines manually, you can skip provisioning and configure each machine directly in the Viam app.
+
+## How provisioning works
+
+1. During manufacturing, you flash an OS image with `viam-agent` pre-installed and a defaults file (`viam-defaults.json`) that specifies a fragment and provisioning options.
+2. On first boot, `viam-agent` checks for network connectivity. If no known network is available, it enters provisioning mode.
+3. In provisioning mode, `viam-agent` creates a WiFi hotspot (or advertises a Bluetooth service) so the end user can provide network credentials.
+4. The end user connects to the hotspot or Bluetooth and provides WiFi credentials through a mobile app or captive portal.
+5. `viam-agent` connects to the provided network, registers the machine with Viam (using the fragment from the defaults file), and downloads `viam-server` and the configured software.
+6. The machine is now online and running.
+
+## Prerequisites
+
+- A [fragment](/fleet/reuse-configuration/) with the configuration your machines should use. Note the fragment ID.
+- A device with a supported Linux OS. See the [platform requirements](/foundation/) for supported platforms.
+
+## 1. Create the defaults file
+
+Create a file called `viam-defaults.json` that defines the provisioning behavior. At minimum, specify a `fragment_id`.
+
+```json
+{
+  "network_configuration": {
+    "manufacturer": "your-company",
+    "model": "your-product",
+    "fragment_id": "your-fragment-id",
+    "hotspot_prefix": "your-product-setup",
+    "hotspot_password": "viamsetup"
+  }
+}
+```
+
+### Defaults file fields
+
+All fields are optional except where noted.
+
+| Field                                     | Type    | Default             | Description                                                                                                                                                         |
+| ----------------------------------------- | ------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `manufacturer`                            | string  | `"viam"`            | Displayed on the captive portal or mobile app during setup.                                                                                                         |
+| `model`                                   | string  | `"custom"`          | Displayed on the captive portal or mobile app during setup.                                                                                                         |
+| `fragment_id`                             | string  | —                   | The fragment to apply to machines provisioned with this defaults file. Required when using the mobile app for provisioning.                                         |
+| `hotspot_interface`                       | string  | First 802.11 device | The network interface to use for the provisioning hotspot.                                                                                                          |
+| `hotspot_prefix`                          | string  | `"viam-setup"`      | Prepended to the device hostname to create the hotspot SSID: `{prefix}-{hostname}`.                                                                                 |
+| `hotspot_password`                        | string  | `"viamsetup"`       | Password for the WiFi hotspot or Bluetooth connection. When using the mobile app, must be `"viamsetup"`.                                                            |
+| `disable_captive_portal_redirect`         | boolean | `false`             | When `true`, only `*.setup` domains redirect to the portal, preventing mobile devices from auto-opening it. Set to `true` when using a mobile app for provisioning. |
+| `disable_bt_provisioning`                 | boolean | `false`             | When `true`, disables Bluetooth provisioning. The machine will not advertise Bluetooth services.                                                                    |
+| `disable_wifi_provisioning`               | boolean | `false`             | When `true`, disables WiFi hotspot provisioning.                                                                                                                    |
+| `bluetooth_trust_all`                     | boolean | `false`             | When `true`, accepts all Bluetooth pairing requests without requiring an unlock from a mobile app. Only needed for Bluetooth tethering.                             |
+| `turn_on_hotspot_if_wifi_has_no_internet` | boolean | `false`             | When `true`, the device re-enters provisioning mode if the connected WiFi network has no internet access.                                                           |
+| `offline_before_starting_hotspot_minutes` | integer | `2`                 | Minutes to wait for a known network before entering provisioning mode. Increase for environments where the WiFi router boots slowly.                                |
+| `user_idle_minutes`                       | integer | `5`                 | Minutes before considering a provisioning user idle and resuming normal connection attempts.                                                                        |
+| `retry_connection_timeout_minutes`        | integer | `10`                | Minutes before exiting provisioning mode to try other connection methods. Provisioning mode restarts if connectivity does not improve.                              |
+| `wifi_power_save`                         | boolean | —                   | When set, explicitly enables or disables WiFi power save for all connections managed by NetworkManager. If not set, the system default applies.                     |
+| `device_reboot_after_offline_minutes`     | integer | `0`                 | When set to a positive number, reboots the device after this many minutes offline in hotspot mode. `0` disables.                                                    |
+
+## 2. Run the preinstall script
+
+Download and run the preinstall script to install `viam-agent` and the defaults file onto your device or OS image.
+
+{{< tabs >}}
+{{% tab name="wget" %}}
+
+```sh {class="command-line" data-prompt="$"}
+wget https://storage.googleapis.com/packages.viam.com/apps/viam-agent/preinstall.sh
+chmod 755 preinstall.sh
+```
+
+{{% /tab %}}
+{{% tab name="curl" %}}
+
+```sh {class="command-line" data-prompt="$"}
+curl -O https://storage.googleapis.com/packages.viam.com/apps/viam-agent/preinstall.sh
+chmod 755 preinstall.sh
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Run the script from the same directory that contains your `viam-defaults.json` file:
+
+```sh {class="command-line" data-prompt="$"}
+sudo ./preinstall.sh
+```
+
+The script picks up `viam-defaults.json` from the current directory and copies it along with `viam-agent` to the appropriate locations on the device. For Raspberry Pi, it modifies the first-run script to start `viam-agent` on boot.
+
+To install onto an external rootfs (for example, a mounted SD card image):
+
+```sh {class="command-line" data-prompt="$"}
+sudo ./preinstall.sh /path/to/rootfs
+```
+
+## 3. Boot the device
+
+Power on the device. `viam-agent` starts automatically and:
+
+1. Checks for a known WiFi network.
+2. If none is found after `offline_before_starting_hotspot_minutes` (default: 2 minutes), creates a WiFi hotspot named `{hotspot_prefix}-{hostname}`.
+3. Waits for a user to connect and provide network credentials.
+
+The end user completes setup by following the [end-user device setup](/fleet/end-user-setup/) instructions.
+
+## 4. Verify provisioning
+
+After the end user provides network credentials:
+
+1. The machine connects to the provided network.
+2. `viam-agent` registers the machine with Viam and applies the fragment.
+3. `viam-server` is downloaded and started.
+4. The machine appears in the Viam app fleet dashboard as **Live**.
+
+Check the fleet dashboard at [app.viam.com/fleet/machines](https://app.viam.com/fleet/machines) to confirm the machine is online.
+
+## Provision additional networks
+
+To configure fallback WiFi networks that the device can connect to without going through provisioning mode, add an `additional_networks` section to the defaults file:
+
+```json
+{
+  "network_configuration": {
+    "fragment_id": "your-fragment-id",
+    "hotspot_prefix": "your-product-setup"
+  },
+  "additional_networks": {
+    "office-wifi": {
+      "type": "wifi",
+      "ssid": "OfficeNetwork",
+      "psk": "office-password",
+      "priority": 30
+    },
+    "factory-wifi": {
+      "type": "wifi",
+      "ssid": "FactoryNetwork",
+      "psk": "factory-password",
+      "priority": 20
+    }
+  }
+}
+```
+
+Networks with higher `priority` values are preferred. See [system settings](/fleet/system-settings/) for the full network configuration reference.
+
+## Limitations
+
+- The preinstall script cannot be run twice on the same device. To re-provision, delete `/etc/viam.json` and reboot.
+- Provisioning requires `viam-agent`, which runs on Linux systems with NetworkManager. It is not available for microcontrollers.
+- When using the Viam mobile app for provisioning, the `hotspot_password` must be `"viamsetup"`.
+
+## Related pages
+
+- [End-user device setup](/fleet/end-user-setup/) for the end-user side of the provisioning flow
+- [Reuse configuration](/fleet/reuse-configuration/) for creating the fragment your provisioned machines will use
+- [System settings](/fleet/system-settings/) for configuring additional networks and agent behavior
+- [Build apps](/build-apps/) for building custom provisioning apps using the Flutter or TypeScript SDK's provisioning client
diff --git a/docs/fleet/reuse-configuration.md b/docs/fleet/reuse-configuration.md
new file mode 100644
index 0000000000..8ef3fd469a
--- /dev/null
+++ b/docs/fleet/reuse-configuration.md
@@ -0,0 +1,233 @@
+---
+linkTitle: "Reuse configuration"
+title: "Reuse configuration with fragments"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Create reusable configuration templates and apply them across multiple machines."
+---
+
+Create a fragment (a reusable configuration template), add the components, services, and modules your machines need, then apply that fragment to every machine in your fleet. When you update the fragment, every machine that uses it picks up the change.
+
+## Prerequisites
+
+- A Viam account with an organization. See [get started](/foundation/) if you have not set up your first machine yet.
+- At least one machine connected to Viam.
+
+## When to use fragments
+
+Use fragments when you have multiple machines that share the same configuration, either entirely or with small per-machine differences. Common examples:
+
+- A fleet of identical robots that all need the same camera, motor, and control logic
+- Machines in different locations that share most configuration but have different WiFi credentials or sensor thresholds
+- A standard module deployment that you want to roll out to all machines in an organization
+
+If every machine has a unique configuration with nothing in common, direct per-machine configuration may be simpler.
+
+## Create a fragment
+
+1. Navigate to [app.viam.com/fragments](https://app.viam.com/fragments) and click **Create fragment**.
+1. Enter a name for the fragment.
+1. Set the visibility:
+   - **Private**: only your organization can see and use this fragment.
+   - **Public**: any Viam user can see and use this fragment. Requires a public namespace for your organization.
+   - **Unlisted**: anyone with a direct link can see and use it, but it does not appear in search results.
+1. Click **Save**.
+
+The fragment editor works just like the machine configuration editor. You can use the visual **Builder** to add resources, or switch to the **JSON** view to edit the configuration directly.
+
+### Add resources to the fragment
+
+In the fragment editor sidebar, click **+** to add:
+
+- Components and services (cameras, motors, sensors, vision services, etc.)
+- Control code modules
+- Nested fragments (fragments can include other fragments, up to 5 levels deep)
+- Maintenance windows
+- Jobs
+- Triggers
+
+Click **Save** after adding and configuring your resources.
+
+## Apply a fragment to a machine
+
+1. Navigate to your machine's **CONFIGURE** tab.
+1. Click **+** and select **Configuration block**.
+1. Search for your fragment by name and select it.
+1. Click **Add fragment**.
+1. Click **Add fragment** again to confirm.
+1. Click **Save** in the upper right corner.
+
+The fragment's resources now appear on the machine's configuration page. The machine downloads and applies the configuration on its next sync.
+
+To apply a fragment to many machines, use the CLI in a loop or script:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part fragments add --part=<part-id> --fragment=<fragment-id>
+```
+
+See [automate with scripts](/cli/automate-with-scripts/) for examples of scripting fleet operations.
+
+### Avoid resource name conflicts with a prefix
+
+If a machine already has a resource with the same name as one in the fragment, or if you apply the same fragment twice, you need a prefix to avoid name collisions.
+
+When you insert a fragment that would cause a conflict, the UI prompts you for a prefix. The prefix is prepended to every resource name from the fragment. For example, a component named `camera-1` in a fragment with prefix `front` becomes `front-camera-1`.
+
+## Customize fragments with variables
+
+Fragments support variable substitution for values that differ between machines. Define a variable in the fragment's JSON configuration using the `$variable` syntax, then set the value when applying the fragment to each machine.
+
+In the fragment's JSON editor, replace a value with a variable object:
+
+```json
+{
+  "components": [
+    {
+      "name": {
+        "$variable": {
+          "name": "sensor-name"
+        }
+      },
+      "model": "viam:sensor:ultrasonic",
+      "type": "sensor",
+      "attributes": {
+        "trigger_pin": {
+          "$variable": {
+            "name": "trigger-pin"
+          }
+        },
+        "echo_int_pin": {
+          "$variable": {
+            "name": "echo-pin"
+          }
+        }
+      }
+    }
+  ]
+}
+```
+
+When you apply this fragment to a machine, set the variable values in the fragment card's **Variables** section. Any variables you don't set use the placeholder value as a default.
+
+## Override specific settings
+
+Sometimes you need to change a single value from a fragment without creating a new fragment. Use fragment overrides (called "fragment mods" in JSON) to modify, add, or remove specific fields.
+
+In the machine's **CONFIGURE** tab, find the fragment card and click the field you want to change. Modified fields are highlighted to show they differ from the fragment's default.
+
+In JSON mode, overrides use [MongoDB update operator syntax](https://www.mongodb.com/docs/manual/reference/operator/update/) in the `fragment_mods` array:
+
+```json
+{
+  "fragment_mods": [
+    {
+      "fragment_id": "abcd1234-5678-efgh-ijkl-mnopqrstuvwx",
+      "mods": [
+        {
+          "$set": {
+            "components.motor1.attributes.max_rpm": 200
+          }
+        }
+      ]
+    }
+  ]
+}
+```
+
+Supported operators: `$set` (change or add a value), `$unset` (remove a value).
+
+## Version and tag fragments for staged rollouts
+
+Every time you save a fragment, Viam creates a new revision. You can pin machines to a specific revision or use tags to control rollouts.
+
+### Create a tag
+
+1. Navigate to your fragment's page.
+1. Click **Versions** in the navigation bar.
+1. Click **Add Tag**.
+1. Enter a tag name (lowercase alphanumeric, hyphens, and underscores; cannot start with a digit or "v"; maximum 60 characters).
+1. Select the revision to assign the tag to.
+1. Click **Add tag**.
+
+### Pin a machine to a tag or revision
+
+On the machine's **CONFIGURE** tab, find the fragment card and look for the **Update version** section:
+
+- **Latest version**: the machine always uses the newest fragment revision. This is the default.
+- **Pin to version**: the machine stays on a specific revision number and never updates automatically.
+- **Pin to tag**: the machine uses whichever revision the tag currently points to. When you move the tag to a new revision, the machine updates.
+
+### Staged rollout workflow
+
+1. Create two tags on your fragment: `stable` and `development`.
+2. Point `stable` at your current production revision.
+3. Pin your production machines to the `stable` tag.
+4. Make changes to the fragment. The new revision is created automatically on save.
+5. Point `development` at the new revision.
+6. Pin a few test machines to `development` and verify the changes work.
+7. When validated, move `stable` to the new revision. All production machines update.
+
+## Set default fragments for an organization
+
+You can configure default fragments at the organization level so that every new machine in the organization automatically uses them. Default fragments are applied when a machine is created, whether manually or through provisioning.
+
+To configure default fragments:
+
+- **In the Viam app**: go to your organization's **Settings** page and configure default fragments there.
+- **Through the API**: use the fleet management API's `UpdateOrganization` method with the `default_fragments` field.
+
+## JSON reference: fragment imports
+
+In JSON mode on a machine's **CONFIGURE** tab, fragments are listed in the `fragments` array. Each entry supports:
+
+| Field       | Type   | Description                                                                                |
+| ----------- | ------ | ------------------------------------------------------------------------------------------ |
+| `id`        | string | The fragment ID. Required.                                                                 |
+| `version`   | string | Pin to a specific revision number or tag name. Omit to track the latest revision.          |
+| `prefix`    | string | A string prepended to all resource names from this fragment. Use to avoid name collisions. |
+| `variables` | object | A map of variable names to values, overriding the defaults defined in the fragment.        |
+
+Example:
+
+```json
+{
+  "fragments": [
+    {
+      "id": "abcd1234-5678-efgh-ijkl-mnopqrstuvwx",
+      "version": "stable",
+      "prefix": "front",
+      "variables": {
+        "sensor_name": "front-ultrasonic",
+        "trigger_pin": "15",
+        "echo_pin": "16"
+      }
+    }
+  ]
+}
+```
+
+## Verify the configuration
+
+After applying a fragment to a machine:
+
+1. On the machine's **CONFIGURE** tab, confirm the fragment's resources appear in the resource list.
+1. Click **Save** if you haven't already.
+1. Go to the **CONTROL** tab and verify the fragment's components respond (for example, test a camera feed or read sensor values).
+1. Check the **LOGS** tab for any configuration errors.
+
+To see the fully resolved configuration with all fragments expanded, click **...** (actions menu) on the machine page and select **View debug configuration**.
+
+## Limitations
+
+- Fragments can be nested up to 5 levels deep. Deeper nesting produces an error.
+- Circular fragment references (fragment A includes fragment B which includes fragment A) are detected and rejected.
+- You cannot add the same fragment to a machine twice without using a prefix.
+- Fragment overrides use MongoDB update operator syntax, which may be unfamiliar. The visual editor handles common overrides without requiring JSON.
+
+## Related pages
+
+- [Deploy software](/fleet/deploy-software/) for deploying modules through fragments
+- [Deploy ML models](/fleet/deploy-ml-models/) for deploying trained models through fragments
+- [Manage versions](/fleet/manage-versions/) for version pinning and maintenance windows
+- [Provision devices](/fleet/provision-devices/) for applying fragments to new devices automatically
diff --git a/docs/fleet/schedule-jobs.md b/docs/fleet/schedule-jobs.md
new file mode 100644
index 0000000000..13147ac9d4
--- /dev/null
+++ b/docs/fleet/schedule-jobs.md
@@ -0,0 +1,146 @@
+---
+linkTitle: "Schedule jobs"
+title: "Schedule automated jobs"
+weight: 40
+layout: "docs"
+type: "docs"
+description: "Configure automated jobs that call component and service methods on a schedule."
+---
+
+Schedule automated jobs that call methods on your machine's components and services at specified intervals. Use jobs to automate routine tasks like reading sensors, capturing images, running calibration routines, or syncing data.
+
+## When to use jobs
+
+Jobs are a good fit when you need to:
+
+- Call a component or service method at regular intervals (every 30 seconds, hourly, daily)
+- Run a `DoCommand` routine with specific parameters on a schedule
+- Automate operations that don't require complex logic between calls
+
+If you need conditional logic, coordination between multiple resources, or responses to events, write a [logic module](/build-modules/write-a-logic-module/) instead.
+
+## Add a job
+
+You can add a job to a single machine or to a fragment. Adding a job to a fragment deploys it to every machine that uses that fragment, which is the recommended approach for fleet-wide scheduling.
+
+1. Navigate to your machine's **CONFIGURE** tab, or navigate to your fragment's page at [app.viam.com/fragments](https://app.viam.com/fragments).
+1. Click **+** and select **Job**.
+1. Enter a name for the job and click **Create**.
+
+## Configure the schedule
+
+The job card has a **Schedule** section with three options:
+
+**Interval**: run the job every N units of time. Select a number and a unit (milliseconds, seconds, minutes, hours, or days). For example, "every 5 minutes."
+
+**Cron**: run the job on a cron schedule. Enter a 5-field or 6-field cron expression. The UI shows a human-readable description of the schedule. Examples:
+
+- `0 * * * *` — every hour at the top of the hour
+- `0 9 * * 1-5` — every weekday at 9 AM
+- `*/5 * * * * *` — every 5 seconds (6-field cron with seconds)
+
+Cron schedules are evaluated in the machine's local timezone.
+
+**Continuous**: run the job in an infinite loop. Each invocation starts immediately after the previous one completes. Use this for tasks that should always be running.
+
+## Configure the action
+
+In the **Job** section:
+
+1. Select a **Resource** from the dropdown. This lists all components and services on the machine.
+1. Enter the **Method** to call on that resource. For custom actions, use `DoCommand`.
+1. If the method is `DoCommand`, a **Command** editor appears. Enter the JSON command to send:
+
+```json
+{
+  "action": "calibrate",
+  "mode": "full"
+}
+```
+
+## Configure logging
+
+In the **Log threshold** section, set the minimum log level for this job's output:
+
+- **Error**: only errors
+- **Warn**: errors and warnings
+- **Info**: errors, warnings, and info (default)
+- **Debug**: all messages, including debug output from job execution
+
+Job execution logs appear under `rdk.job_manager.{job-name}` in the machine's logs. At the default Info level, "Job triggered" and "Job succeeded" messages are at debug level and will not appear. Set the log threshold to Debug to see them.
+
+## JSON configuration reference
+
+In JSON mode, jobs are defined in the `jobs` array at the top level of the machine configuration:
+
+```json
+{
+  "jobs": [
+    {
+      "name": "hourly-reading",
+      "schedule": "0 * * * *",
+      "resource": "my-sensor",
+      "method": "GetReadings"
+    },
+    {
+      "name": "calibration",
+      "schedule": "0 2 * * 0",
+      "resource": "my-sensor",
+      "method": "DoCommand",
+      "command": {
+        "action": "calibrate"
+      },
+      "log_configuration": {
+        "level": "debug"
+      }
+    }
+  ]
+}
+```
+
+| Field               | Type   | Required | Description                                                                                                    |
+| ------------------- | ------ | -------- | -------------------------------------------------------------------------------------------------------------- |
+| `name`              | string | Yes      | Unique name for the job.                                                                                       |
+| `schedule`          | string | Yes      | Cron expression (5 or 6 fields), Go duration string (for example, `"30s"`, `"5m"`, `"1h"`), or `"continuous"`. |
+| `resource`          | string | Yes      | Name of the component or service to call.                                                                      |
+| `method`            | string | Yes      | The API method to invoke on the resource.                                                                      |
+| `command`           | object | No       | Arguments for `DoCommand`. Ignored for other methods.                                                          |
+| `log_configuration` | object | No       | Set `"level"` to `"debug"`, `"info"`, `"warn"`, or `"error"`.                                                  |
+
+## Verify a job is running
+
+Check the machine's **LOGS** tab and filter for `job_manager`. Successful execution produces:
+
+```sh {class="command-line" data-prompt="$" data-output="1-2"}
+debug rdk.job_manager.hourly-reading  Job triggered
+debug rdk.job_manager.hourly-reading  Job succeeded  response map[...]
+```
+
+If the resource is not found:
+
+```sh {class="command-line" data-prompt="$" data-output="1"}
+warn rdk.job_manager.hourly-reading  Could not get resource  error could not find the resource for name my-sensor
+```
+
+## Scheduling behavior
+
+**Interval and cron jobs** are singleton: only one instance runs at a time.
+
+- **Cron**: if a job is still running when the next cron trigger fires, the next run is skipped entirely. It runs again at the following scheduled time.
+- **Interval**: if a job is still running when the next interval elapses, the next run queues and starts immediately after the current run finishes.
+
+**Continuous jobs** restart immediately after each invocation. If the job function exits unexpectedly, it restarts after a 5-second delay.
+
+## Limitations
+
+- Jobs only run when `viam-server` is running. They do not persist across restarts (missed runs are not retried).
+- `DoCommand` is the only method that supports arguments. All other methods are called without arguments (only the resource name is passed).
+- There is no timeout on individual job invocations. A stuck job blocks that job's schedule indefinitely.
+- Jobs run locally on each machine. There is no cross-machine job coordination.
+- Failed jobs do not retry automatically. The failure is logged and the job runs again at the next scheduled time.
+- Duplicate job names in the same configuration produce undefined behavior.
+
+## Related pages
+
+- [Reuse configuration](/fleet/reuse-configuration/) for deploying job configurations across a fleet through fragments
+- [Write a logic module](/build-modules/write-a-logic-module/) for more complex automation that goes beyond scheduled method calls
diff --git a/docs/fleet/system-settings.md b/docs/fleet/system-settings.md
new file mode 100644
index 0000000000..bcaa7986c1
--- /dev/null
+++ b/docs/fleet/system-settings.md
@@ -0,0 +1,152 @@
+---
+linkTitle: "System settings"
+title: "System settings"
+weight: 60
+layout: "docs"
+type: "docs"
+description: "Configure network connections, OS updates, tunneling, TLS, and log forwarding for deployed machines."
+---
+
+Configure system-level settings for deployed machines. These settings are managed by `viam-agent` and configured in your machine's JSON configuration under the agent config section. You can configure them directly on a machine or deploy them fleet-wide through a fragment.
+
+## Agent version control
+
+Control which versions of `viam-agent` and `viam-server` run on the machine.
+
+In the machine settings card, open **Settings** and expand **Software Updates**:
+
+| Field         | Type   | Default    | Description                                                                                            |
+| ------------- | ------ | ---------- | ------------------------------------------------------------------------------------------------------ |
+| `agent`       | string | `"stable"` | Version of viam-agent. Options: a semver string (`"5.6.77"`), `"stable"`, or a URL to a custom binary. |
+| `viam-server` | string | `"stable"` | Version of viam-server. Same options as agent.                                                         |
+
+## Agent advanced settings
+
+In the machine settings card, open **Settings** and expand **Advanced**:
+
+| Field                               | Type    | Default | Description                                                                 |
+| ----------------------------------- | ------- | ------- | --------------------------------------------------------------------------- |
+| `debug`                             | boolean | `false` | Enable debug logging for viam-agent.                                        |
+| `disable_network_configuration`     | boolean | `false` | Disable viam-agent's network and hotspot management.                        |
+| `disable_system_configuration`      | boolean | `false` | Disable viam-agent's system configuration management.                       |
+| `disable_viam_server`               | boolean | `false` | Prevent viam-agent from starting viam-server. For development use.          |
+| `viam_server_env`                   | object  | `{}`    | Environment variables passed to viam-server and all modules.                |
+| `viam_server_start_timeout_minutes` | integer | `10`    | Minutes to wait before restarting an unresponsive viam-server.              |
+| `wait_for_update_check`             | boolean | `false` | Wait for a network connection and update check before starting viam-server. |
+
+## Configure additional networks
+
+Add WiFi or wired networks that the machine can connect to. Each network is a named entry with connection parameters.
+
+In the machine settings card, open **Settings** and expand **Known Networks**. Click **Add another network** and configure:
+
+| Field               | Type    | Default  | Description                                                                                |
+| ------------------- | ------- | -------- | ------------------------------------------------------------------------------------------ |
+| `type`              | string  | —        | **Required.** `"wifi"` or `"wired"`.                                                       |
+| `ssid`              | string  | —        | WiFi network name. Only for WiFi networks.                                                 |
+| `psk`               | string  | —        | Network password or pre-shared key.                                                        |
+| `priority`          | integer | `0`      | Network selection priority. Higher values are preferred. Range: -999 to 999.               |
+| `interface`         | string  | —        | Network interface name (for example, `"wlan0"`, `"eth0"`).                                 |
+| `ipv4_address`      | string  | `"auto"` | Static IPv4 address in CIDR notation (for example, `"192.168.0.10/24"`).                   |
+| `ipv4_dns`          | array   | `[]`     | DNS server addresses.                                                                      |
+| `ipv4_gateway`      | string  | —        | IPv4 gateway address.                                                                      |
+| `ipv4_route_metric` | integer | `0`      | Route metric. Lower values are preferred. `0` defaults to 100 for wired, 600 for wireless. |
+
+## Configure tunneling
+
+Allow secure port forwarding from a local machine to a remote machine through Viam's cloud connection. You must list allowed ports in the machine configuration.
+
+```json
+{
+  "network": {
+    "traffic_tunnel_endpoints": [
+      {
+        "port": 8080,
+        "connection_timeout": "30s"
+      }
+    ]
+  }
+}
+```
+
+| Field                | Type    | Description                                                                           |
+| -------------------- | ------- | ------------------------------------------------------------------------------------- |
+| `port`               | integer | The port on the machine to expose for tunneling.                                      |
+| `connection_timeout` | string  | Timeout for establishing the tunnel connection. Go duration format. Default: `"10s"`. |
+
+To connect through the tunnel, use the CLI:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part tunnel --part=<part-id> --local-port=8080 --destination-port=8080
+```
+
+## Disable TLS
+
+By default, `viam-server` uses TLS for all connections. To disable TLS (for development or isolated networks only):
+
+```json
+{
+  "network": {
+    "no_tls": true
+  }
+}
+```
+
+## Configure bind address and port
+
+By default, `viam-server` listens on `localhost:8080`. To change the bind address:
+
+```json
+{
+  "network": {
+    "bind_address": "0.0.0.0:8081"
+  }
+}
+```
+
+## Configure OS package updates
+
+Control automatic operating system package updates on the machine.
+
+In the machine settings card, open **Settings** and expand **System**. Set `os_auto_upgrade_type`:
+
+| Value        | Description                                                              |
+| ------------ | ------------------------------------------------------------------------ |
+| `"all"`      | Install all available OS package updates.                                |
+| `"security"` | Install security updates only.                                           |
+| `"disable"`  | Disable automatic OS updates.                                            |
+| `""` (empty) | Do not change the system's current update settings. This is the default. |
+
+## Configure OS log forwarding
+
+Forward operating system logs from the machine to Viam's cloud log viewer.
+
+In the machine settings card, open **Settings** and expand **System**:
+
+| Field                                        | Type    | Default | Description                                                             |
+| -------------------------------------------- | ------- | ------- | ----------------------------------------------------------------------- |
+| `forward_system_logs`                        | string  | `""`    | Which system logs to forward. Empty string disables forwarding.         |
+| `logging_journald_runtime_max_use_megabytes` | integer | `512`   | Maximum temporary log storage in MB. Set to `-1` to disable the limit.  |
+| `logging_journald_system_max_use_megabytes`  | integer | `512`   | Maximum persistent log storage in MB. Set to `-1` to disable the limit. |
+
+### Log forwarding filter syntax
+
+The `forward_system_logs` field accepts:
+
+- `"all"`: forward all system logs
+- A comma-separated list of service identifiers: forward only those services (for example, `"kernel,NetworkManager,tailscaled"`)
+- Prefix a service with `-` to exclude it: `"all,-gdm,-tailscaled"` forwards everything except gdm and tailscaled
+
+## Verify settings changes
+
+After updating system settings:
+
+1. Click **Save** on the **CONFIGURE** tab.
+1. Wait for the machine to sync the new configuration (up to one minute).
+1. Check the **LOGS** tab for any errors related to the changed settings.
+1. For network changes, verify the machine remains online in the fleet dashboard.
+
+## Related pages
+
+- [Change network](/fleet/change-network/) for changing a machine's WiFi after deployment
+- [Provision devices](/fleet/provision-devices/) for configuring initial network settings during provisioning
diff --git a/docs/foundation/_index.md b/docs/foundation/_index.md
new file mode 100644
index 0000000000..1e7010b533
--- /dev/null
+++ b/docs/foundation/_index.md
@@ -0,0 +1,134 @@
+---
+linkTitle: "Set up a machine"
+title: "Set up a machine"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "Create a machine in the Viam app and install Viam on your compute machine."
+date: "2025-01-30"
+aliases:
+  - /build/foundation/
+  - /foundation/
+  - /foundation/initialize-a-viam-machine/
+  - /build/foundation/initialize-a-viam-machine/
+  - /operate/install/
+  - /operate/reference/prepare/
+  - /installation/viam-server-setup/
+  - /how-tos/configure/
+  - /installation/prepare/
+  - /installation/macos-install/
+  - /installation/linux-install/
+  - /installation/install/
+  - /installation/install/linux-install/
+  - /installation/install/macos-install
+  - /getting-started/installation/
+  - /getting-started/macos-install/
+  - /getting-started/linux-install/
+  - /installation/
+  - /get-started/installation/
+  - /operate/get-started/setup/
+---
+
+Connect a machine to the Viam platform so you can configure, control, and monitor it from anywhere.
+You'll create a machine in the Viam app, install Viam on your machine, and confirm it's online.
+
+## 1. Create a machine in the Viam app
+
+1. Go to [app.viam.com](https://app.viam.com) and log in (or create an
+   account).
+2. Create or select an organization, then create or select a location.
+3. Click **Add machine**.
+4. Give your machine a name (for example, `my-first-machine`). Click **Add machine**.
+
+The app creates a machine entry and opens the **CONFIGURE** tab.
+A banner prompts you to set up the machine part.
+
+## 2. Open the setup page
+
+1. Click **View setup instructions** in the banner.
+2. In the wizard dialog that opens, click **Go to Advanced setup**.
+
+## 3. Select your platform
+
+Use the **Platform you want to run on** dropdown to select the operating system and architecture of the compute machine for your robot, the computer to which you've attached cameras, sensors, arms, or other components.
+
+Options include Linux / Aarch64, Linux / x86, Mac, Windows native, Windows (WSL), Linux / Armv7l, and ESP32.
+
+{{< alert title="Tip" color="tip" >}}
+
+If you're using a single-board computer like a Raspberry Pi or NVIDIA Jetson, make sure it's running a compatible Linux OS before continuing.
+The setup page links to an [installation guide](/reference/device-setup/) for supported single-board computers.
+
+{{< /alert >}}
+
+## 4. Select your installation method
+
+If your platform supports multiple installation methods, a second dropdown appears.
+
+- **viam-agent**: Choose this unless you have a reason not to.
+- **manual**: Installs `viam-server` directly.
+
+## 5. Run the install command
+
+The setup page displays platform-specific install instructions.
+Follow the steps shown on your compute machine.
+
+## 6. Wait for confirmation
+
+After the install command finishes, the setup page polls for your machine's connection status.
+When the banner changes to **"Your machine is connected!"**, your machine is online and ready to configure.
+
+This should happen within 30 seconds.
+
+{{< alert title="Tip" color="tip" >}}
+
+To return to the setup page later, click the **...** menu next to any part name in the **CONFIGURE** tab and select **View setup instructions**.
+
+{{< /alert >}}
+
+## Troubleshooting
+
+{{< expand "Machine shows offline in the Viam app" >}}
+
+- **Is `viam-agent` running?** On Linux, check with
+  `sudo systemctl status viam-agent`. If it's not running, start it with
+  `sudo systemctl start viam-agent`. This will also start `viam-server`.
+- **Does the machine have network access?** Verify with `ping google.com`.
+- **Is the config correct?** Inspect `/etc/viam.json` and confirm it contains
+  valid credentials. If in doubt, re-run the install command from the Viam app.
+
+{{< /expand >}}
+
+{{< expand "\"Permission denied\" during install" >}}
+
+- The install script requires `sudo`. Run the `curl` command exactly as shown on
+  the setup page.
+- On some systems, your user may not be in the `sudo` group. Consult your
+  device's documentation for how to grant sudo access.
+
+{{< /expand >}}
+
+{{< expand "viam-server starts but immediately exits" >}}
+
+- Check the logs: `sudo journalctl -u viam-server -n 50`.
+- Common causes: invalid JSON in `/etc/viam.json`, port conflicts (another
+  service on port 8080), or missing system libraries.
+
+{{< /expand >}}
+
+## 7. Connect with code
+
+Your machine is online. Now connect to it programmatically.
+
+1. Go to your machine's page in the Viam app.
+2. Click the **CONNECT** tab.
+3. Select **API keys** and copy your **API key** and **API key ID**.
+4. Copy the **machine address** from the same tab.
+5. Choose your language (Python, TypeScript, Golang, C++, or Flutter).
+6. Copy the code sample, install the SDK, paste in your credentials, and run it.
+
+If the connection succeeds, the script prints your machine's available resources.
+
+## What's next
+
+- [Configure hardware](/hardware/) — Add cameras, motors, sensors, and other components to your machine.
diff --git a/docs/foundation/setup-micro/_index.md b/docs/foundation/setup-micro/_index.md
new file mode 100644
index 0000000000..deae3fe66b
--- /dev/null
+++ b/docs/foundation/setup-micro/_index.md
@@ -0,0 +1,14 @@
+---
+linkTitle: "Set up an ESP32"
+title: "Set up micro-controller"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "Set up micro-controller."
+aliases:
+  - /operate/install/setup-micro/
+_build:
+  list: never
+---
+
+Set up an ESP32 microcontroller with viam-micro-server.
diff --git a/docs/foundation/setup-micro/micro-module.md b/docs/foundation/setup-micro/micro-module.md
new file mode 100644
index 0000000000..2c109e0f2b
--- /dev/null
+++ b/docs/foundation/setup-micro/micro-module.md
@@ -0,0 +1,12 @@
+---
+title: "Create modules for ESP32 microcontrollers"
+linkTitle: "Modules for ESP32"
+type: "docs"
+weight: 50
+description: "Create your own modules for use with an Espressif ESP32 microcontroller."
+date: "2024-12-11"
+_build:
+  list: never
+---
+
+Create your own modules for use with an Espressif ESP32 microcontroller.
diff --git a/docs/foundation/setup-micro/micro-troubleshooting.md b/docs/foundation/setup-micro/micro-troubleshooting.md
new file mode 100644
index 0000000000..a578806687
--- /dev/null
+++ b/docs/foundation/setup-micro/micro-troubleshooting.md
@@ -0,0 +1,11 @@
+---
+title: "Micro-RDK Troubleshooting"
+linkTitle: "Micro-RDK troubleshooting"
+weight: 100
+type: docs
+description: "Troubleshooting tips and best practices for installing and using viam-micro-server or other Micro-RDK-based firmware on a microcontroller."
+_build:
+  list: never
+---
+
+Troubleshooting tips and best practices for installing and using viam-micro-server.
diff --git a/docs/hardware/_index.md b/docs/hardware/_index.md
new file mode 100644
index 0000000000..ad7b4c4288
--- /dev/null
+++ b/docs/hardware/_index.md
@@ -0,0 +1,36 @@
+---
+linkTitle: "Configure hardware"
+title: "Configure hardware"
+weight: 35
+layout: "docs"
+type: "docs"
+no_list: true
+description: "Understand how Viam represents hardware, add components to your machine, and configure them."
+manualLink: "/hardware/configure-hardware/"
+aliases:
+  - /hardware-components/
+  - /hardware/
+---
+
+Viam represents every piece of hardware on your machine as a **component**
+with a standardized API. A camera is a camera whether it connects over USB,
+Ethernet, or CSI. A motor is a motor whether it's a brushed DC motor on
+GPIO pins or a stepper on a CAN bus. Your application code calls the same
+methods regardless of the underlying hardware.
+
+This means you can swap hardware without rewriting code, reuse
+configurations across a fleet of identical machines, and test your
+application logic against fake components before the physical hardware
+arrives.
+
+This section covers how to add hardware to your machine, configure it, and
+verify it works.
+
+{{< cards >}}
+{{% card link="/hardware/configure-hardware/" %}}
+{{% card link="/hardware/common-components/" %}}
+{{% card link="/hardware/component-types/" %}}
+{{% card link="/hardware/machine-configuration/" %}}
+{{% card link="/hardware/fragments/" %}}
+{{% card link="/build-modules/overview/" %}}
+{{< /cards >}}
diff --git a/docs/hardware/common-components/_index.md b/docs/hardware/common-components/_index.md
new file mode 100644
index 0000000000..6f98dc8ac6
--- /dev/null
+++ b/docs/hardware/common-components/_index.md
@@ -0,0 +1,71 @@
+---
+linkTitle: "Add a component"
+title: "Add a component"
+weight: 20
+layout: "docs"
+type: "docs"
+no_list: true
+description: "Step-by-step guides for adding and configuring each component type."
+aliases:
+  - /hardware-components/components/
+  - /hardware/components/
+  - /hardware/common-components/
+---
+
+Each guide walks you through adding a specific component type to your machine:
+choosing a model, configuring attributes, and verifying it works.
+The general process is the same for every component -- [How components work](/hardware/configure-hardware/) covers the universal steps.
+The guides below add component-specific details: tested attribute examples, working code, and troubleshooting.
+
+If you're not sure which component type you need, start with
+[Component types](/hardware/component-types/).
+
+## Control an arm, gripper, or gantry
+
+| Component                                             | Description                                                                                                |
+| ----------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
+| [Arm](/hardware/common-components/add-an-arm/)        | Control a multi-joint robotic arm: move joints, position the end effector, integrate with motion planning. |
+| [Gripper](/hardware/common-components/add-a-gripper/) | Open, close, and grasp objects with a gripper mounted on an arm or gantry.                                 |
+| [Gantry](/hardware/common-components/add-a-gantry/)   | Move a tool head, camera, or sensor to precise coordinates along one or more linear axes.                  |
+
+## Sensing
+
+Components that read data from the physical world.
+
+| Component                                                             | Description                                                                                  |
+| --------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
+| [Camera](/hardware/common-components/add-a-camera/)                   | Capture images or video from a USB webcam, IP camera, or depth sensor.                       |
+| [Sensor](/hardware/common-components/add-a-sensor/)                   | Read environmental data: temperature, humidity, distance, air quality, and more.             |
+| [Movement sensor](/hardware/common-components/add-a-movement-sensor/) | Get position, velocity, orientation, or compass heading from a GPS, IMU, or odometry source. |
+| [Power sensor](/hardware/common-components/add-a-power-sensor/)       | Monitor voltage, current, and power consumption.                                             |
+| [Encoder](/hardware/common-components/add-an-encoder/)                | Track how far a motor has turned and how fast it's spinning.                                 |
+
+## Drive a mobile robot
+
+| Component                                       | Description                                                                                                                                         |
+| ----------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [Base](/hardware/common-components/add-a-base/) | Drive a mobile robot with movement commands like "move forward 300mm" or "spin 90 degrees." A base wraps your drive system into a single interface. |
+
+## Control motors and servos
+
+| Component                                         | Description                                                         |
+| ------------------------------------------------- | ------------------------------------------------------------------- |
+| [Motor](/hardware/common-components/add-a-motor/) | Control a DC or stepper motor through a motor driver and GPIO pins. |
+| [Servo](/hardware/common-components/add-a-servo/) | Set the angular position of a hobby servo with a PWM pin.           |
+
+## Control
+
+Components for physical I/O and user interaction.
+
+| Component                                                                | Description                                                                                                                     |
+| ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------- |
+| [Board](/hardware/common-components/add-a-board/)                        | Expose GPIO pins, analog readers, and digital interrupts from a single-board computer. Many other components depend on a board. |
+| [Button](/hardware/common-components/add-a-button/)                      | Detect presses from a physical button to trigger actions.                                                                       |
+| [Switch](/hardware/common-components/add-a-switch/)                      | Read or set the position of a toggle or selector switch.                                                                        |
+| [Input controller](/hardware/common-components/add-an-input-controller/) | Use a gamepad, joystick, or other input device for manual machine control.                                                      |
+
+## Other
+
+| Component                                             | Description                                                           |
+| ----------------------------------------------------- | --------------------------------------------------------------------- |
+| [Generic](/hardware/common-components/add-a-generic/) | Interface with hardware that doesn't fit any standard component type. |
diff --git a/docs/hardware/common-components/add-a-base.md b/docs/hardware/common-components/add-a-base.md
new file mode 100644
index 0000000000..468bfdd531
--- /dev/null
+++ b/docs/hardware/common-components/add-a-base.md
@@ -0,0 +1,266 @@
+---
+linkTitle: "Base"
+title: "Add a base"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Add and configure a base to drive a mobile robot with movement commands."
+date: "2025-03-07"
+aliases:
+  - /hardware-components/add-a-base/
+---
+
+Add a base to your machine's configuration to drive a mobile robot with movement commands like "move forward 300mm" or "spin 90 degrees." A base wraps your robot's drive system, whatever the motor layout, into a single interface that handles steering and speed for you.
+
+## Concepts
+
+A base component gives you a movement API (`MoveStraight`, `Spin`, `SetVelocity`, `Stop`) regardless of the underlying drive system. The most common model is `wheeled`, which handles differential steering for robots with left and right motors. Other models exist for different platforms, including `sensor-controlled` (adds IMU feedback to improve accuracy) and module-based models for specific hardware.
+
+Browse all available base models in the [Viam registry](https://app.viam.com/registry?type=component&subtype=base).
+
+This page covers the `wheeled` model. You configure your motors first, then the base references them.
+
+For accurate distance and angle calculations, the `wheeled` model needs two physical measurements:
+
+- **Wheel circumference**: how far the robot travels per wheel revolution.
+- **Width**: the distance between the left and right wheel centers.
+
+## Steps
+
+### 1. Prerequisites
+
+- Your machine is online in the Viam app.
+- Left and right [motor components](/hardware/common-components/add-a-motor/) are
+  configured and tested.
+- You've measured your wheel circumference and track width in millimeters.
+
+### 2. Add a base component
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for the base model that matches your hardware. For a
+   differential-drive robot with left and right motors, search for
+   **wheeled**.
+4. Name your base (for example, `my-base`) and click **Create**.
+
+### 3. Configure base attributes
+
+```json
+{
+  "left": ["left-motor"],
+  "right": ["right-motor"],
+  "wheel_circumference_mm": 220,
+  "width_mm": 300
+}
+```
+
+| Attribute                | Type            | Required | Description                                                                                                            |
+| ------------------------ | --------------- | -------- | ---------------------------------------------------------------------------------------------------------------------- |
+| `left`                   | list of strings | Yes      | Names of the motors on the left side.                                                                                  |
+| `right`                  | list of strings | Yes      | Names of the motors on the right side.                                                                                 |
+| `wheel_circumference_mm` | int             | Yes      | Outer circumference of a drive wheel in mm.                                                                            |
+| `width_mm`               | int             | Yes      | Distance between left and right wheel centers in mm.                                                                   |
+| `spin_slip_factor`       | float           | No       | Correction factor for turning accuracy. Increase if the robot over-rotates during spins; decrease if it under-rotates. |
+
+For robots with multiple motors per side (for example, six-wheel drive), list all
+motor names for that side:
+
+```json
+{
+  "left": ["front-left-motor", "rear-left-motor"],
+  "right": ["front-right-motor", "rear-right-motor"],
+  "wheel_circumference_mm": 220,
+  "width_mm": 300
+}
+```
+
+### 4. Save and test
+
+Click **Save**, then expand the **Test** section.
+
+- Use the directional controls to drive the base forward, backward, left,
+  and right.
+- Test `MoveStraight` with a specific distance to verify distance accuracy.
+- Test `Spin` with a specific angle to verify turning accuracy.
+
+{{< alert title="Safety" color="caution" >}}
+
+Ensure the robot has room to move and is either on a test stand or in a clear
+area. Start with low speeds.
+
+{{< /alert >}}
+
+## Try it
+
+Drive the base forward, spin it, and stop.
+
+To get the credentials for the code below, go to your machine's page in the Viam app, click the **CONNECT** tab, and select **API keys**.
+Copy the **API key** and **API key ID**.
+Copy the **machine address** from the same tab.
+If you're using real hardware, you'll see the robot drive forward and spin when you run the code below.
+With a fake base, the commands complete without physical motion.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```bash
+pip install viam-sdk
+```
+
+Save this as `base_test.py`:
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.components.base import Base
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    base = Base.from_robot(robot, "my-base")
+
+    # Drive forward 300mm at 200mm/s
+    print("Driving forward 300mm...")
+    await base.move_straight(distance=300, velocity=200)
+
+    # Spin 90 degrees at 45 degrees/s
+    print("Spinning 90 degrees...")
+    await base.spin(angle=90, velocity=45)
+
+    # Stop
+    await base.stop()
+    print("Done")
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```bash
+python base_test.py
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```bash
+mkdir base-test && cd base-test
+go mod init base-test
+go get go.viam.com/rdk
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/components/base"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("base-test")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    b, err := base.FromProvider(robot, "my-base")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    // Drive forward 300mm at 200mm/s
+    fmt.Println("Driving forward 300mm...")
+    if err := b.MoveStraight(ctx, 300, 200, nil); err != nil {
+        logger.Fatal(err)
+    }
+
+    // Spin 90 degrees at 45 degrees/s
+    fmt.Println("Spinning 90 degrees...")
+    if err := b.Spin(ctx, 90, 45, nil); err != nil {
+        logger.Fatal(err)
+    }
+
+    // Stop
+    if err := b.Stop(ctx, nil); err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Println("Done")
+}
+```
+
+Run it:
+
+```bash
+go run main.go
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "Robot drives in the wrong direction" >}}
+
+- Swap the `left` and `right` motor lists.
+- Or set `dir_flip` to `true` on the individual motors that are reversed.
+
+{{< /expand >}}
+
+{{< expand "Robot curves instead of driving straight" >}}
+
+- Verify that both motors spin at similar speeds. Different motors or uneven
+  friction can cause drift.
+- Adding encoders to both motors improves straight-line accuracy.
+
+{{< /expand >}}
+
+{{< expand "Turns are inaccurate" >}}
+
+- Measure `width_mm` carefully. It's the distance between the wheel contact
+  points, not the outside edges of the wheels.
+- Adjust `spin_slip_factor` up or down until spins land on the correct angle.
+  This compensates for tire grip and surface friction.
+
+{{< /expand >}}
+
+{{< expand "Robot doesn't move at all" >}}
+
+- Test each motor individually from its own test panel. If the motors work
+  alone but the base doesn't, check that the motor names in the base config
+  match exactly (names are case-sensitive).
+
+{{< /expand >}}
+
+## What's next
+
+- [Base API reference](/reference/apis/components/base/): full method documentation.
+- [Add a Movement Sensor](/hardware/common-components/add-a-movement-sensor/): add
+  GPS or odometry to track where the base is.
+- [Add an Encoder](/hardware/common-components/add-an-encoder/): add encoders to
+  your motors for better accuracy.
+- [What is a module?](/build-modules/overview/): write a module that
+  drives the base based on sensor input.
diff --git a/docs/hardware/common-components/add-a-board.md b/docs/hardware/common-components/add-a-board.md
new file mode 100644
index 0000000000..ddcb76e0f3
--- /dev/null
+++ b/docs/hardware/common-components/add-a-board.md
@@ -0,0 +1,269 @@
+---
+linkTitle: "Board"
+title: "Add a board"
+weight: 15
+layout: "docs"
+type: "docs"
+description: "Add and configure a board component to expose GPIO pins, analog readers, and digital interrupts."
+date: "2025-03-07"
+aliases:
+  - /hardware-components/add-a-board/
+---
+
+Add a board to your machine's configuration so other components can use your single-board computer's GPIO pins, analog readers, and digital interrupts.
+
+## Concepts
+
+A board component exposes the low-level I/O on your single-board computer:
+
+- **GPIO pins**: digital output (high/low) and PWM.
+- **Analog readers**: read analog voltage values from ADC-capable pins.
+- **Digital interrupts**: react to signal changes on a pin.
+
+The board doesn't represent external hardware. It represents the I/O
+capabilities of the computer itself. Motors, encoders, and servos reference
+the board by name to access the pins they're wired to. Browse all available board models in the [Viam registry](https://app.viam.com/registry?type=component&subtype=board).
+
+## Steps
+
+### 1. Open your machine in the Viam app
+
+Go to [app.viam.com](https://app.viam.com) and navigate to your machine.
+Confirm it shows as **Live** in the upper left.
+
+### 2. Add a board component
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for the model that matches your single-board computer:
+   - For a Raspberry Pi (any model), search for **pi**.
+   - For an NVIDIA Jetson, search for **jetson**.
+   - For an Orange Pi, search for **orangepi**.
+4. Name your board (for example, `my-board`) and click **Create**.
+
+### 3. Configure board attributes
+
+For most single-board computers, the board works with **no additional
+configuration**. The model auto-detects available pins.
+
+If you need analog readers or digital interrupts, add them in the attributes:
+
+**Analog readers:**
+
+```json
+{
+  "analogs": [
+    {
+      "name": "my-analog",
+      "pin": "32",
+      "spi_bus": "main",
+      "chip_select": "0",
+      "channel": 0
+    }
+  ]
+}
+```
+
+**Digital interrupts:**
+
+```json
+{
+  "digital_interrupts": [
+    {
+      "name": "my-interrupt",
+      "pin": "37"
+    }
+  ]
+}
+```
+
+### 4. Save the configuration
+
+Click **Save** in the upper right. `viam-server` initializes the board
+immediately. No restart needed.
+
+### 5. Test the board
+
+1. Find your board in the configuration view.
+2. Expand the **Test** section.
+3. Try setting a GPIO pin high or low, or read an analog value.
+
+If you have an LED wired to a GPIO pin, setting the pin high should light
+it up.
+
+## Try it
+
+Toggle a GPIO pin and read its state programmatically.
+
+To get the credentials for the code below, go to your machine's page in the Viam app, click the **CONNECT** tab, and select **API keys**.
+Copy the **API key** and **API key ID**.
+Copy the **machine address** from the same tab.
+If you have an LED wired to pin 11, you'll see it turn on and off when you run the code below.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```bash
+pip install viam-sdk
+```
+
+Save this as `board_test.py`:
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.components.board import Board
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    board = Board.from_robot(robot, "my-board")
+    pin = await board.gpio_pin_by_name("11")
+
+    await pin.set(True)
+    state = await pin.get()
+    print(f"Pin 11 is {'high' if state else 'low'}")
+
+    await pin.set(False)
+    state = await pin.get()
+    print(f"Pin 11 is {'high' if state else 'low'}")
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```bash
+python board_test.py
+```
+
+You should see:
+
+```text
+Pin 11 is high
+Pin 11 is low
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```bash
+mkdir board-test && cd board-test
+go mod init board-test
+go get go.viam.com/rdk
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/components/board"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("board-test")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    myBoard, err := board.FromProvider(robot, "my-board")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    pin, err := myBoard.GPIOPinByName("11")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    if err := pin.Set(ctx, true, nil); err != nil {
+        logger.Fatal(err)
+    }
+    state, err := pin.Get(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Pin 11 is high: %v\n", state)
+
+    if err := pin.Set(ctx, false, nil); err != nil {
+        logger.Fatal(err)
+    }
+    state, err = pin.Get(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Pin 11 is high: %v\n", state)
+}
+```
+
+Run it:
+
+```bash
+go run main.go
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "Board model not available" >}}
+
+- Linux boards are detected at runtime. If your SBC isn't recognized, check
+  that `viam-server` is running on the SBC itself (not on a different machine).
+- Confirm you're using a supported OS.
+  See [device setup](/reference/device-setup/) for supported platforms.
+
+{{< /expand >}}
+
+{{< expand "GPIO pin doesn't respond" >}}
+
+- Verify the pin number matches your board's pinout diagram. Viam uses the
+  **board pin number** (the physical pin on the header), not the GPIO/BCM
+  number.
+- Check that nothing else on the system is using the pin (another process,
+  a kernel driver).
+
+{{< /expand >}}
+
+{{< expand "Analog reader returns unexpected values" >}}
+
+- Most SBCs don't have built-in ADCs. You may need an external ADC connected
+  through SPI or I2C. Check the model's reference page for ADC configuration.
+
+{{< /expand >}}
+
+## What's next
+
+- [Board API reference](/reference/apis/components/board/): full method documentation.
+- [Add a Motor](/hardware/common-components/add-a-motor/): wire a motor to your
+  board's GPIO pins.
+- [Add an Encoder](/hardware/common-components/add-an-encoder/): wire an encoder to
+  your board's interrupt pins.
+- [Add a Servo](/hardware/common-components/add-a-servo/): control a servo from a
+  PWM-capable pin.
diff --git a/docs/hardware/common-components/add-a-button.md b/docs/hardware/common-components/add-a-button.md
new file mode 100644
index 0000000000..1bbb53e859
--- /dev/null
+++ b/docs/hardware/common-components/add-a-button.md
@@ -0,0 +1,196 @@
+---
+linkTitle: "Button"
+title: "Add a button"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "Add and configure a button component to detect presses from a physical button."
+date: "2025-03-07"
+aliases:
+  - /hardware-components/add-a-button/
+---
+
+Add a button to your machine's configuration so you can detect and respond to button presses from the Viam app and from code.
+
+## Concepts
+
+A button component represents a momentary push button. The API is intentionally
+simple. It exposes a single `Push` method that triggers the button. Physical button
+hardware typically comes from a module in the [Viam registry](https://app.viam.com/registry?type=component&subtype=button) that reads a GPIO pin
+and exposes it as a button component.
+
+The `fake` built-in model is useful for testing code without physical hardware.
+
+## Steps
+
+### 1. Add a button component
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for the model that matches your button hardware. Search by
+   manufacturer name, chip, or device type.
+4. Name your button (for example, `my-button`) and click **Create**.
+
+### 2. Configure button attributes
+
+Attributes vary by module. For the `fake` model, no attributes are needed:
+
+```json
+{}
+```
+
+For a GPIO-connected button with a registry module, you'll typically configure
+the board and pin:
+
+```json
+{
+  "board": "my-board",
+  "pin": "22"
+}
+```
+
+Check your module's documentation in the registry for the full list of
+attributes.
+
+### 3. Save and test
+
+Click **Save**, then expand the **Test** section.
+
+- Click **Push** to simulate pressing the button.
+
+## Try it
+
+Push the button programmatically.
+
+To get the credentials for the code below, go to your machine's page in the Viam app, click the **CONNECT** tab, and select **API keys**.
+Copy the **API key** and **API key ID**.
+Copy the **machine address** from the same tab.
+When you run the code below, the button's Push method fires. With a physical button connected with a module, this triggers whatever action the module defines.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```bash
+pip install viam-sdk
+```
+
+Save this as `button_test.py`:
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.components.button import Button
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    button = Button.from_robot(robot, "my-button")
+
+    # Push the button
+    print("Pushing button...")
+    await button.push()
+    print("Button pushed")
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```bash
+python button_test.py
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```bash
+mkdir button-test && cd button-test
+go mod init button-test
+go get go.viam.com/rdk
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/components/button"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("button-test")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    b, err := button.FromProvider(robot, "my-button")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    // Push the button
+    fmt.Println("Pushing button...")
+    if err := b.Push(ctx, nil); err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Println("Button pushed")
+}
+```
+
+Run it:
+
+```bash
+go run main.go
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "Button push doesn't trigger anything" >}}
+
+- Verify the button component shows as connected in the Viam app.
+- If using a GPIO-connected button, check the wiring and pin number.
+- Test the button from the Viam app's test panel first.
+
+{{< /expand >}}
+
+{{< expand "Button module not found" >}}
+
+- Confirm you've added the module to your machine's configuration.
+- Check that the module is running. Look for it in the machine's logs.
+
+{{< /expand >}}
+
+## What's next
+
+- [Button API reference](/reference/apis/components/button/): full method documentation.
+- [What is a module?](/build-modules/overview/): write a module that
+  responds to button presses.
+- [Component types](/hardware/component-types/): find the right type for
+  your hardware.
diff --git a/docs/hardware/common-components/add-a-camera.md b/docs/hardware/common-components/add-a-camera.md
new file mode 100644
index 0000000000..ebd0318ae3
--- /dev/null
+++ b/docs/hardware/common-components/add-a-camera.md
@@ -0,0 +1,284 @@
+---
+linkTitle: "Camera"
+title: "Add a camera"
+weight: 25
+layout: "docs"
+type: "docs"
+description: "Add and configure a camera component, verify the feed, and capture an image programmatically."
+date: "2025-01-30"
+aliases:
+  - /build/foundation/add-a-camera/
+  - /foundation/add-a-camera/
+  - /hardware-components/add-a-camera/
+  - /hardware/add-a-camera/
+  - /hardware/components/add-a-camera/
+---
+
+Add a camera to your machine's configuration so you can capture images and video from the Viam app and from code.
+
+## Concepts
+
+The camera API gives you `GetImages` (capture frames), `GetPointCloud` (depth data), and stream access regardless of the underlying hardware. Common models include:
+
+- **webcam** (built-in): USB cameras and built-in laptop cameras. Auto-detects available devices.
+- **ffmpeg** (built-in): IP cameras and RTSP streams.
+- **realsense**: Intel RealSense depth cameras (module).
+- **transform**: Applies transformations (crop, resize, overlay) to another camera's output.
+
+Browse all available camera models in the [Viam registry](https://app.viam.com/registry?type=component&subtype=camera).
+
+## Steps
+
+### 1. Open your machine in the Viam app
+
+Go to [app.viam.com](https://app.viam.com) and navigate to your machine.
+Confirm it shows as **Live** in the upper left.
+If it shows as offline, verify that `viam-server` is running on your machine.
+
+### 2. Add a camera component
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for the model that matches your camera:
+   - For a USB webcam or built-in laptop camera, search for **webcam**.
+   - For an IP camera that supports RTSP, search for **ffmpeg**.
+   - For an Intel RealSense depth camera, search for **realsense**.
+4. Name your camera (this guide uses `my-camera`) and click **Create**.
+
+### 3. Configure camera attributes
+
+After creating the component, you'll see its configuration panel.
+
+**For a USB webcam (`webcam` model):**
+
+Most USB webcams work with no additional configuration.
+If you have multiple cameras connected, specify which one to use:
+
+```json
+{
+  "video_path": "video0"
+}
+```
+
+To find available video devices on Linux:
+
+```bash
+ls /dev/video*
+```
+
+You can also set resolution and frame rate:
+
+```json
+{
+  "width_px": 640,
+  "height_px": 480,
+  "frame_rate": 30
+}
+```
+
+### 4. Save the configuration
+
+Click **Save** in the upper right of the configuration panel.
+
+When you save, `viam-server` automatically reloads the configuration and initializes the new component.
+You do not need to restart anything.
+
+### 5. Test the camera
+
+Every component in Viam has a built-in **test panel** in the Configure tab.
+The test panel uses the exact same APIs your code will use, so if the camera works here, it will work in your programs.
+
+1. Find your camera component in the configuration view.
+2. Expand the **Test** section at the bottom of the component panel.
+3. Click **Toggle stream** to see a live video feed from the camera.
+4. Click **Get image** to capture a single frame.
+
+You should see a live feed from the camera.
+
+## Try it
+
+Capture an image from your camera programmatically.
+
+To get the credentials for the code below, go to your machine's page in the Viam app, click the **CONNECT** tab, and select **API keys**.
+Copy the **API key** and **API key ID**.
+Copy the **machine address** from the same tab.
+
+When you run the code below, it saves an image file to your current directory. Check that the image shows what the camera sees.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+Install the SDK if you haven't already:
+
+```bash
+pip install viam-sdk
+```
+
+Save this as `camera_test.py`:
+
+```python
+import asyncio
+from io import BytesIO
+from PIL import Image as PILImage
+from viam.robot.client import RobotClient
+from viam.components.camera import Camera
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    camera = Camera.from_robot(robot, "my-camera")
+    images, metadata = await camera.get_images()
+    image = PILImage.open(BytesIO(images[0].data))
+    image.save("test-capture.png")
+    print(f"Captured {image.size[0]}x{image.size[1]} image")
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```bash
+python camera_test.py
+```
+
+You should see output like:
+
+```text
+Captured 640x480 image
+```
+
+And a file called `test-capture.png` in your current directory.
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+Initialize a Go module and install the SDK if you haven't already:
+
+```bash
+mkdir camera-test && cd camera-test
+go mod init camera-test
+go get go.viam.com/rdk
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "image/png"
+    "os"
+
+    "go.viam.com/rdk/components/camera"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("camera-test")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    cam, err := camera.FromProvider(robot, "my-camera")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    img, _, err := cam.Images(ctx, nil, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    f, err := os.Create("test-capture.png")
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer f.Close()
+
+    image, err := img[0].Image(ctx)
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    if err := png.Encode(f, image); err != nil {
+        logger.Fatal(err)
+    }
+
+    fmt.Printf("Captured image and saved to test-capture.png\n")
+}
+```
+
+Run it:
+
+```bash
+go run main.go
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "Camera not appearing as a component option" >}}
+
+- Confirm your machine is **Live** in the Viam app.
+- Refresh the page and try again.
+
+{{< /expand >}}
+
+{{< expand "Test panel shows no image or a black frame" >}}
+
+- **USB webcam:** Check the physical connection. Unplug and replug the camera. On Linux, verify the device exists with `ls /dev/video*`.
+- **Raspberry Pi camera module:** Ensure the ribbon cable is fully seated and the camera is enabled in `raspi-config`.
+- **`video_path` wrong:** If you have multiple cameras, the default device may not be the one you expect. Try different `video_path` values (`video0`, `video1`, etc.).
+
+{{< /expand >}}
+
+{{< expand "\"Failed to find the best driver\" or driver errors" >}}
+
+- On Linux, install required video drivers: `sudo apt install v4l-utils`.
+- On macOS, grant camera permissions to the terminal application running `viam-server`.
+
+{{< /expand >}}
+
+{{< expand "Code connects but get_image fails" >}}
+
+- Verify the camera name in your code matches the name in the Viam app exactly (names are case-sensitive).
+- Check that the camera test panel works in the Viam app first. If it doesn't work there, the issue is with the camera configuration, not your code.
+- Ensure `viam-server` is still running and the machine is online.
+
+{{< /expand >}}
+
+{{< expand "Image is very dark or overexposed" >}}
+
+- Some cameras need a few seconds to adjust exposure after starting. Try adding a short delay before capturing, or capture and discard a few frames first.
+- Check if the camera has a physical lens cap or privacy shutter.
+
+{{< /expand >}}
+
+## What's next
+
+- [Camera API reference](/reference/apis/components/camera/): full method documentation.
+- [Capture and Sync Data](/data/capture-sync/capture-and-sync-data/): configure your camera to automatically capture images and sync them to the cloud.
+- [Add Computer Vision](/vision/configure/): run ML models on your camera feed to detect or classify objects.
diff --git a/docs/hardware/common-components/add-a-gantry.md b/docs/hardware/common-components/add-a-gantry.md
new file mode 100644
index 0000000000..791d522636
--- /dev/null
+++ b/docs/hardware/common-components/add-a-gantry.md
@@ -0,0 +1,285 @@
+---
+linkTitle: "Gantry"
+title: "Add a gantry"
+weight: 35
+layout: "docs"
+type: "docs"
+description: "Add and configure a gantry component for precise linear positioning along one or more axes."
+date: "2025-03-07"
+aliases:
+  - /hardware-components/add-a-gantry/
+---
+
+Add a gantry to your machine's configuration so you can control linear positioning along one or more axes from the Viam app and from code.
+
+## Concepts
+
+A gantry component controls linear motion along one or more axes. The API
+provides:
+
+- **Position reading**: get the current position on each axis.
+- **Move to position**: command movement to a target position at a specified
+  speed.
+- **Axis lengths**: query the travel range of each axis.
+- **Homing**: run a homing sequence to establish a reference position.
+
+Viam includes two built-in gantry models:
+
+| Model         | What it does                                                      |
+| ------------- | ----------------------------------------------------------------- |
+| `single-axis` | Controls one linear rail driven by a motor.                       |
+| `multi-axis`  | Composes multiple single-axis gantries into a coordinated system. |
+
+The `fake` built-in model is useful for testing without hardware. Browse all available gantry models in the [Viam registry](https://app.viam.com/registry?type=component&subtype=gantry).
+
+## Steps
+
+### 1. Prerequisites
+
+- Your machine is online in the Viam app.
+- For the `single-axis` model: a [motor](/hardware/common-components/add-a-motor/)
+  is configured and tested.
+- You know the travel length of your axis in millimeters and the distance per
+  motor revolution.
+
+### 2. Add a gantry component
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for the gantry model that matches your setup:
+   - For a single linear rail driven by a motor, search for
+     **single-axis**.
+   - For a multi-axis system composed of multiple single-axis gantries,
+     search for **multi-axis**.
+4. Name your gantry (for example, `my-gantry`) and click **Create**.
+
+### 3. Configure gantry attributes
+
+**Single-axis gantry:**
+
+```json
+{
+  "motor": "my-motor",
+  "length_mm": 500,
+  "mm_per_rev": 8
+}
+```
+
+| Attribute           | Type   | Required | Description                                                                   |
+| ------------------- | ------ | -------- | ----------------------------------------------------------------------------- |
+| `motor`             | string | Yes      | Name of the motor that drives this axis.                                      |
+| `length_mm`         | int    | Yes      | Total travel length of the axis in mm.                                        |
+| `mm_per_rev`        | int    | Yes      | Distance traveled per motor revolution in mm (for example, lead screw pitch). |
+| `board`             | string | No       | Board with limit switches, if using them.                                     |
+| `limit_pins`        | object | No       | Pin names for limit switches at each end of travel.                           |
+| `gantry_mm_per_sec` | int    | No       | Default speed in mm/s. Defaults to 100.                                       |
+
+**Multi-axis gantry:**
+
+First configure each axis as a separate `single-axis` gantry, then compose
+them:
+
+```json
+{
+  "subaxes_list": ["x-axis", "y-axis", "z-axis"],
+  "move_simultaneously": true
+}
+```
+
+| Attribute             | Type            | Required | Description                                                     |
+| --------------------- | --------------- | -------- | --------------------------------------------------------------- |
+| `subaxes_list`        | list of strings | Yes      | Names of the single-axis gantry components.                     |
+| `move_simultaneously` | bool            | No       | Whether to move all axes at the same time. Defaults to `false`. |
+
+### 4. Save and test
+
+Click **Save**, then expand the **Test** section.
+
+- Read the current position.
+- Command a short move and verify the axis travels the correct distance.
+- If using limit switches, verify homing works correctly.
+
+## Try it
+
+Read the gantry's position and move it along the axis.
+
+To get the credentials for the code below, go to your machine's page in the Viam app, click the **CONNECT** tab, and select **API keys**.
+Copy the **API key** and **API key ID**.
+Copy the **machine address** from the same tab.
+If you're using real hardware, you'll see the gantry move along its axis when you run the code below.
+With a fake gantry, position values update without physical motion.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```bash
+pip install viam-sdk
+```
+
+Save this as `gantry_test.py`:
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.components.gantry import Gantry
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    gantry = Gantry.from_robot(robot, "my-gantry")
+
+    # Get axis lengths
+    lengths = await gantry.get_lengths()
+    print(f"Axis lengths (mm): {lengths}")
+
+    # Get current position
+    position = await gantry.get_position()
+    print(f"Current position (mm): {position}")
+
+    # Move to 100mm at 50mm/s
+    print("Moving to 100mm...")
+    await gantry.move_to_position(
+        positions=[100.0],
+        speeds=[50.0]
+    )
+
+    # Verify new position
+    position = await gantry.get_position()
+    print(f"New position (mm): {position}")
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```bash
+python gantry_test.py
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```bash
+mkdir gantry-test && cd gantry-test
+go mod init gantry-test
+go get go.viam.com/rdk
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/components/gantry"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("gantry-test")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    g, err := gantry.FromProvider(robot, "my-gantry")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    // Get axis lengths
+    lengths, err := g.Lengths(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Axis lengths (mm): %v\n", lengths)
+
+    // Get current position
+    position, err := g.Position(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Current position (mm): %v\n", position)
+
+    // Move to 100mm at 50mm/s
+    fmt.Println("Moving to 100mm...")
+    if err := g.MoveToPosition(ctx, []float64{100.0}, []float64{50.0}, nil); err != nil {
+        logger.Fatal(err)
+    }
+
+    // Verify new position
+    position, err = g.Position(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("New position (mm): %v\n", position)
+}
+```
+
+Run it:
+
+```bash
+go run main.go
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "Gantry doesn't move" >}}
+
+- Test the underlying motor from its own test panel. If the motor works alone
+  but the gantry doesn't, check that the motor name in the gantry config
+  matches exactly.
+- Verify `mm_per_rev` is correct for your lead screw or belt drive.
+
+{{< /expand >}}
+
+{{< expand "Position readings are inaccurate" >}}
+
+- Measure the actual distance traveled per revolution and update `mm_per_rev`.
+- If using a stepper motor without an encoder, missed steps will cause drift.
+  Add an encoder for closed-loop control.
+
+{{< /expand >}}
+
+{{< expand "Homing fails or limit switches don't trigger" >}}
+
+- Verify the limit switch wiring and pin numbers in the `limit_pins` config.
+- Check `limit_pin_enabled_high`. Set to `true` if your switches are active
+  high, `false` for active low.
+- Test the switch by reading the GPIO pin directly from the board's test panel.
+
+{{< /expand >}}
+
+## What's next
+
+- [Gantry API reference](/reference/apis/components/gantry/): full method documentation.
+- [Add a motor](/hardware/common-components/add-a-motor/): configure the motor
+  that drives the gantry axis.
+- [Fragments](/hardware/fragments/): save and reuse working
+  hardware configurations.
+- [What is a module?](/build-modules/overview/): write a module that
+  coordinates gantry motion with sensors.
diff --git a/docs/hardware/common-components/add-a-generic.md b/docs/hardware/common-components/add-a-generic.md
new file mode 100644
index 0000000000..5b5f7a9cc6
--- /dev/null
+++ b/docs/hardware/common-components/add-a-generic.md
@@ -0,0 +1,209 @@
+---
+linkTitle: "Generic"
+title: "Add a generic component"
+weight: 40
+layout: "docs"
+type: "docs"
+description: "Add and configure a generic component for hardware that doesn't fit any other component type."
+date: "2025-03-07"
+aliases:
+  - /hardware-components/add-a-generic/
+---
+
+Add a generic component to your machine's configuration for hardware that doesn't fit any standard component type.
+
+## Concepts
+
+A generic component is a catch-all for hardware with non-standard interfaces.
+The API provides a single method:
+
+- **DoCommand**: send arbitrary key-value commands to the component and
+  receive key-value responses.
+
+Because the API is entirely model-defined, generic components almost always
+come from **modules in the registry** (or modules you write yourself). The
+module author defines what commands are supported and what they do.
+
+Use generic when no other component type fits. If your hardware produces
+images, use [camera](/hardware/common-components/add-a-camera/). If it produces
+readings, use [sensor](/hardware/common-components/add-a-sensor/). Standard
+types give you data capture, test panels, and SDK support automatically. Browse available generic models in the [Viam registry](https://app.viam.com/registry?type=component&subtype=generic).
+
+The `fake` built-in model echoes commands back for testing.
+
+## Steps
+
+### 1. Add a generic component
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for the model that matches your hardware. Search by
+   manufacturer name, chip, or device type.
+4. Name your component (for example, `my-device`) and click **Create**.
+
+If no model exists for your hardware, you can
+[write a driver module](/build-modules/write-a-driver-module/) that implements
+the generic component API.
+
+### 2. Configure attributes
+
+Attributes are entirely model-defined. For the `fake` model, no attributes
+are needed:
+
+```json
+{}
+```
+
+For a registry module, check the module's documentation for required
+attributes.
+
+### 3. Save and test
+
+Click **Save**. Generic components can be tested using `DoCommand` from code
+or the Viam app's test panel.
+
+## Try it
+
+Send a command to the generic component and read the response.
+
+To get the credentials for the code below, go to your machine's page in the Viam app, click the **CONNECT** tab, and select **API keys**.
+Copy the **API key** and **API key ID**.
+Copy the **machine address** from the same tab.
+With the fake model, you'll see your command echoed back. With a real module, the response depends on what commands the module supports.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```bash
+pip install viam-sdk
+```
+
+Save this as `generic_test.py`:
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.components.generic import Generic
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    device = Generic.from_robot(robot, "my-device")
+
+    # Send a command (the fake model echoes it back)
+    result = await device.do_command({"action": "status", "verbose": True})
+    print(f"Response: {result}")
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```bash
+python generic_test.py
+```
+
+With the `fake` model, you'll see your command echoed back:
+
+```text
+Response: {'action': 'status', 'verbose': True}
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```bash
+mkdir generic-test && cd generic-test
+go mod init generic-test
+go get go.viam.com/rdk
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/components/generic"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("generic-test")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    device, err := generic.FromProvider(robot, "my-device")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    // Send a command (the fake model echoes it back)
+    result, err := device.DoCommand(ctx, map[string]interface{}{
+        "action":  "status",
+        "verbose": true,
+    })
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Response: %v\n", result)
+}
+```
+
+Run it:
+
+```bash
+go run main.go
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "DoCommand returns an error" >}}
+
+- Verify the command format matches what the module expects. Check the module's
+  documentation for supported commands and their expected structure.
+- With the `fake` model, any valid map is accepted.
+
+{{< /expand >}}
+
+{{< expand "Module not found or not loading" >}}
+
+- Confirm you've added the module to your machine's configuration.
+- Check that the module is compatible with your machine's architecture.
+- Look at the machine's logs for module startup errors.
+
+{{< /expand >}}
+
+## What's next
+
+- [Generic API reference](/reference/apis/components/generic/): full method documentation.
+- [Write a driver module](/build-modules/write-a-driver-module/): create a
+  module for your custom hardware.
+- [Component types](/hardware/component-types/): check if a more specific
+  component type fits your hardware before using generic.
diff --git a/docs/hardware/common-components/add-a-gripper.md b/docs/hardware/common-components/add-a-gripper.md
new file mode 100644
index 0000000000..6120b2de1b
--- /dev/null
+++ b/docs/hardware/common-components/add-a-gripper.md
@@ -0,0 +1,265 @@
+---
+linkTitle: "Gripper"
+title: "Add a gripper"
+weight: 45
+layout: "docs"
+type: "docs"
+description: "Add and configure a gripper component to open, close, and grasp objects."
+date: "2025-03-07"
+aliases:
+  - /hardware-components/add-a-gripper/
+---
+
+Add a gripper to your machine's configuration so you can open, close, and grasp objects from the Viam app and from code.
+
+## Concepts
+
+A gripper component controls a grasping device. The API provides:
+
+- **Open**: opens the gripper fully.
+- **Grab**: closes the gripper and reports whether it grabbed something.
+- **IsHoldingSomething**: checks whether the gripper currently holds an object.
+- **Stop**: stops any in-progress motion.
+
+Gripper models almost always come from modules in the [Viam registry](https://app.viam.com/registry?type=component&subtype=gripper) because each
+gripper has its own communication protocol and control logic. For example, the
+[UFactory module](https://app.viam.com/module/viam/ufactory) includes gripper
+models for xArm parallel-jaw and vacuum grippers.
+
+The `fake` built-in model is useful for testing code without physical hardware.
+
+## Steps
+
+### 1. Add a gripper component
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for the model that matches your gripper hardware. Search by
+   manufacturer name or gripper type (for example, "parallel jaw", "vacuum").
+4. Name your gripper (for example, `my-gripper`) and click **Create**.
+
+### 2. Configure gripper attributes
+
+Attributes vary by module. For the `fake` model, no attributes are needed:
+
+```json
+{}
+```
+
+For a physical gripper, you'll typically configure the connection to the
+gripper controller. Check your module's documentation for the full list of
+attributes.
+
+### 3. Configure a frame (recommended)
+
+If you're using the gripper with an arm and motion planning, add a frame to
+define the gripper's position relative to the arm:
+
+```json
+{
+  "frame": {
+    "parent": "my-arm",
+    "translation": { "x": 0, "y": 0, "z": 0 },
+    "orientation": {
+      "type": "ov_degrees",
+      "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+    }
+  }
+}
+```
+
+### 4. Save and test
+
+Click **Save**, then expand the **Test** section.
+
+- Click **Open** to open the gripper.
+- Click **Grab** to close the gripper and check if it grabbed something.
+
+{{< alert title="Safety" color="caution" >}}
+
+Keep fingers and loose items clear of the gripper jaws when testing. Start
+with no objects in the workspace until you're confident in the configuration.
+
+{{< /alert >}}
+
+## Try it
+
+Open the gripper, grab an object, and check if it's held.
+
+To get the credentials for the code below, go to your machine's page in the Viam app, click the **CONNECT** tab, and select **API keys**.
+Copy the **API key** and **API key ID**.
+Copy the **machine address** from the same tab.
+If you're using real hardware, you'll see the gripper open and close when you run the code below.
+With the fake model, Grab always returns true.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```bash
+pip install viam-sdk
+```
+
+Save this as `gripper_test.py`:
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.components.gripper import Gripper
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    gripper = Gripper.from_robot(robot, "my-gripper")
+
+    # Open the gripper
+    print("Opening gripper...")
+    await gripper.open()
+    print("Gripper opened")
+
+    # Grab (close and check if something is held)
+    print("Grabbing...")
+    grabbed = await gripper.grab()
+    print(f"Grabbed something: {grabbed}")
+
+    # Check holding status
+    status = await gripper.is_holding_something()
+    print(f"Currently holding: {status.is_holding_something}")
+
+    # Stop any motion
+    await gripper.stop()
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```bash
+python gripper_test.py
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```bash
+mkdir gripper-test && cd gripper-test
+go mod init gripper-test
+go get go.viam.com/rdk
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/components/gripper"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("gripper-test")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    g, err := gripper.FromProvider(robot, "my-gripper")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    // Open the gripper
+    fmt.Println("Opening gripper...")
+    if err := g.Open(ctx, nil); err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Println("Gripper opened")
+
+    // Grab (close and check if something is held)
+    fmt.Println("Grabbing...")
+    grabbed, err := g.Grab(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Grabbed something: %v\n", grabbed)
+
+    // Check holding status
+    status, err := g.IsHoldingSomething(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Currently holding: %v\n", status.IsHoldingSomething)
+
+    // Stop any motion
+    if err := g.Stop(ctx, nil); err != nil {
+        logger.Fatal(err)
+    }
+}
+```
+
+Run it:
+
+```bash
+go run main.go
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "Gripper doesn't open or close" >}}
+
+- Verify the gripper is powered and connected.
+- Check the module's logs for communication errors.
+- If the gripper uses a serial connection, verify the device path and baud
+  rate in the attributes.
+
+{{< /expand >}}
+
+{{< expand "Grab always returns false" >}}
+
+- Some gripper models detect a grab by measuring force or current. If the
+  gripper closes fully without resistance, it reports no grab.
+- With the `fake` model, `Grab` always returns `true`.
+
+{{< /expand >}}
+
+{{< expand "Gripper moves too fast or too slow" >}}
+
+- Check your module's documentation for speed or force configuration
+  attributes.
+- Some grippers support configurable open/close speed and grip force.
+
+{{< /expand >}}
+
+## What's next
+
+- [Gripper API reference](/reference/apis/components/gripper/): full method documentation.
+- [Add an arm](/hardware/common-components/add-an-arm/): configure the arm
+  the gripper is mounted on.
+- [Fragments](/hardware/fragments/): save and reuse working
+  hardware configurations.
+- [What is a module?](/build-modules/overview/): write a module that
+  coordinates the gripper with a camera for pick-and-place.
diff --git a/docs/hardware/common-components/add-a-motor.md b/docs/hardware/common-components/add-a-motor.md
new file mode 100644
index 0000000000..787f3c3401
--- /dev/null
+++ b/docs/hardware/common-components/add-a-motor.md
@@ -0,0 +1,277 @@
+---
+linkTitle: "Motor"
+title: "Add a motor"
+weight: 55
+layout: "docs"
+type: "docs"
+description: "Add and configure a motor component and test it from the Viam app."
+date: "2025-03-07"
+aliases:
+  - /hardware-components/add-a-motor/
+---
+
+Add a motor to your machine's configuration so you can control it from the Viam app and from code.
+
+## Concepts
+
+The motor API gives you `SetPower`, `GoFor` (rotate a number of revolutions at a given speed), `GoTo` (move to an absolute position), and `Stop`. Other models exist as modules for network-controlled motors and specific motor controllers. Browse available motor models in the [Viam registry](https://app.viam.com/registry?type=component&subtype=motor).
+
+This page covers the `gpio` model, which controls a motor through a motor driver wired to GPIO pins on a [board](/hardware/common-components/add-a-board/). You need to add a board first.
+
+GPIO motor drivers typically use one of two wiring schemes:
+
+- **A/B mode**: two direction pins (IN1, IN2) plus an optional enable pin.
+  Common with L298N and similar H-bridge drivers.
+- **PWM/DIR mode**: one PWM pin for speed and one direction pin.
+  Common with many motor driver breakout boards.
+
+## Steps
+
+### 1. Prerequisites
+
+- Your machine is online in the Viam app.
+- A [board component](/hardware/common-components/add-a-board/) is configured.
+- Your motor is wired to the board through a motor driver.
+
+### 2. Add a motor component
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for the motor model that matches your hardware:
+   - For a brushed DC motor controlled through a motor driver with GPIO
+     pins, search for **gpio motor**.
+   - For a stepper motor controlled through a stepper driver with GPIO
+     pins, search for **gpiostepper**.
+   - For other motor types, search by your motor driver or manufacturer
+     name.
+4. Name your motor (for example, `left-motor`) and click **Create**.
+
+### 3. Configure motor attributes
+
+The `gpio` model requires you to specify the board and pin mappings.
+
+**A/B mode (for example, L298N driver):**
+
+```json
+{
+  "board": "my-board",
+  "max_rpm": 200,
+  "pins": {
+    "a": "11",
+    "b": "13",
+    "pwm": "15"
+  }
+}
+```
+
+**PWM/DIR mode:**
+
+```json
+{
+  "board": "my-board",
+  "max_rpm": 200,
+  "pins": {
+    "dir": "11",
+    "pwm": "13"
+  }
+}
+```
+
+| Attribute       | Type   | Required | Description                                                           |
+| --------------- | ------ | -------- | --------------------------------------------------------------------- |
+| `board`         | string | Yes      | Name of the board component.                                          |
+| `max_rpm`       | int    | Yes      | Estimated max RPM under no load. Used to calculate speed for `GoFor`. |
+| `pins`          | object | Yes      | GPIO pin mappings (see wiring modes above).                           |
+| `dir_flip`      | bool   | No       | Reverse forward/backward direction. Default: `false`.                 |
+| `pwm_freq`      | int    | No       | PWM frequency in Hz. Default: `800`.                                  |
+| `min_power_pct` | float  | No       | Minimum power to spin the motor (0.0-1.0). Default: `0.0`.            |
+| `max_power_pct` | float  | No       | Maximum power cap (0.06-1.0). Default: `1.0`.                         |
+
+If you have an encoder attached, also set:
+
+| Attribute            | Type   | Description                                  |
+| -------------------- | ------ | -------------------------------------------- |
+| `encoder`            | string | Name of the encoder component.               |
+| `ticks_per_rotation` | int    | Encoder ticks per full motor shaft rotation. |
+
+### 4. Save and test
+
+Click **Save**, then expand the **Test** section for the motor.
+
+- Use the power slider to spin the motor at different speeds.
+- Toggle direction to verify forward and backward.
+- If you set `max_rpm` and have an encoder, try `GoFor` to rotate a
+  specific number of revolutions.
+
+## Try it
+
+Spin the motor forward for 2 revolutions, then check if it's still moving.
+
+To get the credentials for the code below, go to your machine's page in the Viam app, click the **CONNECT** tab, and select **API keys**.
+Copy the **API key** and **API key ID**.
+Copy the **machine address** from the same tab.
+If you're using real hardware, you'll see the motor spin when you run the code below.
+Without an encoder, position readings will be estimates based on time and max RPM.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```bash
+pip install viam-sdk
+```
+
+Save this as `motor_test.py`:
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.components.motor import Motor
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    motor = Motor.from_robot(robot, "left-motor")
+
+    # Spin at 60 RPM for 2 revolutions
+    await motor.go_for(rpm=60, revolutions=2)
+
+    moving = await motor.is_moving()
+    print(f"Motor is moving: {moving}")
+
+    position = await motor.get_position()
+    print(f"Motor position: {position} revolutions")
+
+    await motor.stop()
+    print("Motor stopped")
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```bash
+python motor_test.py
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```bash
+mkdir motor-test && cd motor-test
+go mod init motor-test
+go get go.viam.com/rdk
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/components/motor"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("motor-test")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    m, err := motor.FromProvider(robot, "left-motor")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    // Spin at 60 RPM for 2 revolutions
+    if err := m.GoFor(ctx, 60, 2, nil); err != nil {
+        logger.Fatal(err)
+    }
+
+    moving, err := m.IsMoving(ctx)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Motor is moving: %v\n", moving)
+
+    position, err := m.Position(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Motor position: %.2f revolutions\n", position)
+
+    if err := m.Stop(ctx, nil); err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Println("Motor stopped")
+}
+```
+
+Run it:
+
+```bash
+go run main.go
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "Motor doesn't spin" >}}
+
+- Check that the motor driver is powered (many drivers need a separate power
+  supply for the motor, not just the logic voltage).
+- Verify pin numbers match your wiring. Use the board test panel to set each
+  pin high/low individually and confirm the motor responds.
+- Try increasing `min_power_pct`. Some motors need a minimum threshold to
+  overcome static friction.
+
+{{< /expand >}}
+
+{{< expand "Motor spins the wrong direction" >}}
+
+- Set `dir_flip` to `true` in the attributes.
+- Or swap the `a` and `b` pins if using A/B mode.
+
+{{< /expand >}}
+
+{{< expand "GoFor doesn't stop at the right position" >}}
+
+- `GoFor` without an encoder estimates time from `max_rpm`. Set `max_rpm`
+  accurately for your motor.
+- For precise position control,
+  [add an encoder](/hardware/common-components/add-an-encoder/) and configure
+  `encoder` and `ticks_per_rotation` on the motor.
+
+{{< /expand >}}
+
+## What's next
+
+- [Motor API reference](/reference/apis/components/motor/): full method documentation.
+- [Add an Encoder](/hardware/common-components/add-an-encoder/): add position
+  feedback for precise motor control.
+- [Add a Base](/hardware/common-components/add-a-base/): combine two motors into a
+  driveable mobile base.
diff --git a/docs/hardware/common-components/add-a-movement-sensor.md b/docs/hardware/common-components/add-a-movement-sensor.md
new file mode 100644
index 0000000000..653ad1ab99
--- /dev/null
+++ b/docs/hardware/common-components/add-a-movement-sensor.md
@@ -0,0 +1,287 @@
+---
+linkTitle: "Movement sensor"
+title: "Add a movement sensor"
+weight: 60
+layout: "docs"
+type: "docs"
+description: "Add and configure a movement sensor like a GPS, IMU, or odometry source."
+date: "2025-03-07"
+aliases:
+  - /hardware-components/add-a-movement-sensor/
+---
+
+Add a movement sensor to your machine's configuration so you can track position, velocity, and orientation from the Viam app and from code.
+
+## Concepts
+
+Unlike a generic sensor (which returns arbitrary readings), a movement sensor
+has a structured API with specific methods for spatial data:
+
+- `GetPosition`: latitude, longitude, altitude.
+- `GetLinearVelocity`: speed in X, Y, Z.
+- `GetAngularVelocity`: rotation rate around each axis.
+- `GetCompassHeading`: heading in degrees.
+- `GetOrientation`: orientation as Euler angles or quaternion.
+
+Not every movement sensor supports every method. A GPS provides position and
+compass heading but not angular velocity. An IMU provides orientation and
+angular velocity but not GPS position. Use `GetProperties` to check which
+methods a particular sensor supports.
+
+### Built-in models
+
+| Model              | Use case                                                                                              |
+| ------------------ | ----------------------------------------------------------------------------------------------------- |
+| `wheeled-odometry` | Estimates position and velocity from motor encoders on a wheeled base. No additional hardware needed. |
+| `merged`           | Combines data from multiple movement sensors into one. For example, GPS position + IMU orientation.   |
+
+Hardware-specific models (GPS modules, IMUs, RTK receivers) are available as
+modules in the [Viam registry](https://app.viam.com/registry?type=component&subtype=movement_sensor).
+
+## Steps
+
+### Option A: Wheeled odometry (no extra hardware)
+
+If you have a wheeled base with encoders on the motors, you can get position
+and velocity estimates without any additional sensors.
+
+#### 1. Prerequisites
+
+- A [wheeled base](/hardware/common-components/add-a-base/) with motors that have
+  [encoders](/hardware/common-components/add-an-encoder/) configured.
+
+#### 2. Add the movement sensor
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for **wheeled-odometry**. This is the built-in model that
+   computes position from wheel encoder data.
+4. Name it (for example, `odometry`) and click **Create**.
+
+#### 3. Configure attributes
+
+```json
+{
+  "base": "my-base",
+  "left_motors": ["left-motor"],
+  "right_motors": ["right-motor"]
+}
+```
+
+| Attribute            | Type            | Required | Description                               |
+| -------------------- | --------------- | -------- | ----------------------------------------- |
+| `base`               | string          | Yes      | Name of the wheeled base component.       |
+| `left_motors`        | list of strings | Yes      | Left motor names (must have encoders).    |
+| `right_motors`       | list of strings | Yes      | Right motor names (must have encoders).   |
+| `time_interval_msec` | float           | No       | How often to recalculate. Default: `500`. |
+
+### Option B: Hardware sensor (GPS, IMU)
+
+#### 1. Add the component
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for the model that matches your sensor hardware. Search by
+   sensor name or chip (for example, **NMEA GPS**, **BNO055**, **MPU6050**).
+4. Name it and click **Create**.
+5. Configure attributes per the model's documentation (typically I2C
+   address or serial port).
+
+### Option C: Merged sensor
+
+Combine data from multiple movement sensors into one.
+
+```json
+{
+  "position": "gps-sensor",
+  "orientation": "imu-sensor",
+  "compass_heading": "gps-sensor",
+  "angular_velocity": "imu-sensor",
+  "linear_velocity": "odometry"
+}
+```
+
+Each field names the movement sensor to use for that type of data. This lets
+you build a complete spatial picture from multiple hardware sources.
+
+### Save and test
+
+Click **Save**, then expand the **Test** section.
+
+- The test panel shows all available data: position, velocity, orientation,
+  and heading.
+- Methods the sensor doesn't support will show as unavailable.
+
+## Try it
+
+Read position and velocity data from the movement sensor.
+
+To get the credentials for the code below, go to your machine's page in the Viam app, click the **CONNECT** tab, and select **API keys**.
+Copy the **API key** and **API key ID**.
+Copy the **machine address** from the same tab.
+When you run the code below, you'll see which methods your sensor supports and the current readings for each.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```bash
+pip install viam-sdk
+```
+
+Save this as `movement_sensor_test.py`:
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.components.movement_sensor import MovementSensor
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    sensor = MovementSensor.from_robot(robot, "odometry")
+
+    # Check which methods this sensor supports
+    properties = await sensor.get_properties()
+    print(f"Supports position: {properties.position_supported}")
+    print(f"Supports linear velocity: {properties.linear_velocity_supported}")
+    print(f"Supports angular velocity: {properties.angular_velocity_supported}")
+    print(f"Supports compass heading: {properties.compass_heading_supported}")
+
+    if properties.position_supported:
+        position = await sensor.get_position()
+        print(f"Position: {position}")
+
+    if properties.linear_velocity_supported:
+        velocity = await sensor.get_linear_velocity()
+        print(f"Linear velocity: {velocity}")
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```bash
+python movement_sensor_test.py
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```bash
+mkdir movement-sensor-test && cd movement-sensor-test
+go mod init movement-sensor-test
+go get go.viam.com/rdk
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/components/movementsensor"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("movement-sensor-test")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    sensor, err := movementsensor.FromProvider(robot, "odometry")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    // Check which methods this sensor supports
+    properties, err := sensor.Properties(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Supports position: %v\n", properties.PositionSupported)
+    fmt.Printf("Supports linear velocity: %v\n", properties.LinearVelocitySupported)
+    fmt.Printf("Supports angular velocity: %v\n", properties.AngularVelocitySupported)
+    fmt.Printf("Supports compass heading: %v\n", properties.CompassHeadingSupported)
+
+    if properties.PositionSupported {
+        pos, alt, err := sensor.Position(ctx, nil)
+        if err != nil {
+            logger.Fatal(err)
+        }
+        fmt.Printf("Position: %v, altitude: %.2f\n", pos, alt)
+    }
+
+    if properties.LinearVelocitySupported {
+        vel, err := sensor.LinearVelocity(ctx, nil)
+        if err != nil {
+            logger.Fatal(err)
+        }
+        fmt.Printf("Linear velocity: %v\n", vel)
+    }
+}
+```
+
+Run it:
+
+```bash
+go run main.go
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "Odometry position drifts over time" >}}
+
+- This is inherent to wheel odometry. Small errors accumulate. For better
+  accuracy, add a GPS or IMU and use the `merged` model.
+- Check that `ticks_per_rotation` is accurate on your encoders.
+- Verify `wheel_circumference_mm` and `width_mm` on your base.
+
+{{< /expand >}}
+
+{{< expand "GPS shows no fix" >}}
+
+- GPS modules need a clear view of the sky. They don't work indoors.
+- Initial fix can take 30-60 seconds (cold start) or longer in urban areas.
+
+{{< /expand >}}
+
+{{< expand "Some methods return errors" >}}
+
+- Not all movement sensors support all methods. This is expected. Call
+  `GetProperties` to see which methods your sensor supports.
+
+{{< /expand >}}
+
+## What's next
+
+- [Movement sensor API reference](/reference/apis/components/movement-sensor/): full method documentation.
+- [Add a Base](/hardware/common-components/add-a-base/): the movement sensor
+  typically pairs with a mobile base.
+- [Capture and Sync Data](/data/capture-sync/capture-and-sync-data/): capture position and
+  motion data over time.
diff --git a/docs/hardware/common-components/add-a-power-sensor.md b/docs/hardware/common-components/add-a-power-sensor.md
new file mode 100644
index 0000000000..9073aeb728
--- /dev/null
+++ b/docs/hardware/common-components/add-a-power-sensor.md
@@ -0,0 +1,247 @@
+---
+linkTitle: "Power sensor"
+title: "Add a power sensor"
+weight: 65
+layout: "docs"
+type: "docs"
+description: "Add and configure a power sensor to monitor voltage, current, and power consumption."
+date: "2025-03-07"
+aliases:
+  - /hardware-components/add-a-power-sensor/
+---
+
+Add a power sensor to your machine's configuration so you can monitor voltage, current, and power consumption from the Viam app and from code.
+
+## Concepts
+
+A power sensor component provides three methods:
+
+- `GetVoltage`: voltage in volts and whether it's AC or DC.
+- `GetCurrent`: current in amperes and whether it's AC or DC.
+- `GetPower`: power in watts.
+
+### Built-in models
+
+| Model          | Use case                                                                |
+| -------------- | ----------------------------------------------------------------------- |
+| `ina219`       | INA219 I2C current/voltage/power monitor. Common on breakout boards.    |
+| `ina226`       | INA226 I2C current/voltage/power monitor. Higher precision than INA219. |
+| `renogy-cc-ov` | Renogy solar charge controller.                                         |
+
+Additional models are available as modules in the
+[Viam registry](https://app.viam.com/registry).
+
+## Steps
+
+### 1. Prerequisites
+
+- Your machine is online in the Viam app.
+- A [board component](/hardware/common-components/add-a-board/) is configured (for I2C
+  communication).
+- Your power sensor is wired: I2C data and clock lines to the board, power
+  measurement lines in the circuit you want to monitor.
+
+### 2. Add a power sensor component
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for the power sensor model that matches your hardware. Search
+   by chip name (for example, **ina219**, **ina226**).
+4. Name it (for example, `battery-monitor`) and click **Create**.
+
+### 3. Configure attributes
+
+**INA219 example:**
+
+```json
+{
+  "board": "my-board",
+  "i2c_bus": "1",
+  "i2c_address": 64
+}
+```
+
+| Attribute     | Type   | Required | Description                                   |
+| ------------- | ------ | -------- | --------------------------------------------- |
+| `board`       | string | Yes      | Name of the board component.                  |
+| `i2c_bus`     | string | Yes      | I2C bus number (typically `"1"`).             |
+| `i2c_address` | int    | No       | I2C address. Default: `64` (0x40) for INA219. |
+
+### 4. Save and test
+
+Click **Save**, then expand the **Test** section.
+
+- The test panel shows voltage, current, and power readings.
+- Verify the voltage matches what you expect from your power supply or
+  battery.
+
+## Try it
+
+Read voltage, current, and power programmatically.
+
+To get the credentials for the code below, go to your machine's page in the Viam app, click the **CONNECT** tab, and select **API keys**.
+Copy the **API key** and **API key ID**.
+Copy the **machine address** from the same tab.
+When you run the code below, you'll see voltage, current, and power readings. Verify the voltage matches your power supply.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```bash
+pip install viam-sdk
+```
+
+Save this as `power_sensor_test.py`:
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.components.power_sensor import PowerSensor
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    sensor = PowerSensor.from_robot(robot, "battery-monitor")
+
+    voltage, is_ac = await sensor.get_voltage()
+    print(f"Voltage: {voltage:.2f}V ({'AC' if is_ac else 'DC'})")
+
+    current, is_ac = await sensor.get_current()
+    print(f"Current: {current:.3f}A ({'AC' if is_ac else 'DC'})")
+
+    power = await sensor.get_power()
+    print(f"Power: {power:.2f}W")
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```bash
+python power_sensor_test.py
+```
+
+You should see output like:
+
+```text
+Voltage: 12.34V (DC)
+Current: 0.567A (DC)
+Power: 6.99W
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```bash
+mkdir power-sensor-test && cd power-sensor-test
+go mod init power-sensor-test
+go get go.viam.com/rdk
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/components/powersensor"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("power-sensor-test")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    sensor, err := powersensor.FromProvider(robot, "battery-monitor")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    voltage, isAC, err := sensor.Voltage(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    acdc := "DC"
+    if isAC {
+        acdc = "AC"
+    }
+    fmt.Printf("Voltage: %.2fV (%s)\n", voltage, acdc)
+
+    current, isAC, err := sensor.Current(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    acdc = "DC"
+    if isAC {
+        acdc = "AC"
+    }
+    fmt.Printf("Current: %.3fA (%s)\n", current, acdc)
+
+    power, err := sensor.Power(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Power: %.2fW\n", power)
+}
+```
+
+Run it:
+
+```bash
+go run main.go
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "No readings or all zeros" >}}
+
+- Verify I2C wiring: SDA and SCL to the correct board pins.
+- Check the I2C address. Run `i2cdetect -y 1` to confirm the sensor is
+  visible on the bus.
+- Ensure the power sensor is wired in-line with the circuit you want to
+  measure (current sensing requires the sensor to be in the current path).
+
+{{< /expand >}}
+
+{{< expand "Current reads zero but voltage is correct" >}}
+
+- The shunt resistor may not be in the current path. INA219/INA226 measure
+  current by reading the voltage drop across a shunt resistor. The load
+  current must flow through it.
+
+{{< /expand >}}
+
+## What's next
+
+- [Power sensor API reference](/reference/apis/components/power-sensor/): full method documentation.
+- [Capture and Sync Data](/data/capture-sync/capture-and-sync-data/): log power
+  consumption over time.
+- [What is a module?](/build-modules/overview/): write a module that
+  alerts on low battery or high current draw.
diff --git a/docs/hardware/common-components/add-a-sensor.md b/docs/hardware/common-components/add-a-sensor.md
new file mode 100644
index 0000000000..ba76cbb361
--- /dev/null
+++ b/docs/hardware/common-components/add-a-sensor.md
@@ -0,0 +1,247 @@
+---
+linkTitle: "Sensor"
+title: "Add a sensor"
+weight: 70
+layout: "docs"
+type: "docs"
+description: "Add and configure a sensor to read environmental data like temperature, humidity, or distance."
+date: "2025-03-07"
+aliases:
+  - /hardware-components/add-a-sensor/
+---
+
+Add a sensor to your machine's configuration so you can read environmental data from the Viam app and from code.
+
+## Concepts
+
+The sensor component provides a single method: `GetReadings`, which returns a
+map of key-value pairs. This simple interface works for any sensor that
+produces named measurements.
+
+Most physical sensors in Viam come from modules in the [Viam registry](https://app.viam.com/registry?type=component&subtype=sensor) rather than
+built-in models. This is because the sensor ecosystem is enormous. Thousands
+of different devices with different communication protocols exist, and modules cover
+specific hardware while keeping the same `GetReadings` API.
+
+## Steps
+
+### 1. Add a sensor component
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for the model that matches your sensor hardware. Search by
+   sensor name or chip (for example, **DHT22**, **BME280**, **SHT31**). For I2C
+   or serial sensors, you can also search by protocol or manufacturer.
+4. Name your sensor (for example, `temperature-sensor`) and click **Create**.
+
+If no model exists for your sensor, you can
+[write a driver module](/build-modules/write-a-driver-module/) to add support.
+
+### 2. Configure sensor attributes
+
+Attributes vary by sensor module. Common patterns:
+
+**I2C sensor (for example, BME280, SHT31):**
+
+```json
+{
+  "board": "my-board",
+  "i2c_bus": "1",
+  "i2c_address": 119
+}
+```
+
+**Serial sensor (for example, air quality monitors):**
+
+```json
+{
+  "serial_path": "/dev/ttyUSB0",
+  "baud_rate": 9600
+}
+```
+
+**GPIO sensor (for example, ultrasonic distance):**
+
+```json
+{
+  "board": "my-board",
+  "trigger_pin": "11",
+  "echo_pin": "13"
+}
+```
+
+Check the module's documentation in the registry for the exact attributes your
+sensor needs.
+
+### 3. Save and test
+
+Click **Save**, then expand the **Test** section.
+
+- The test panel shows the output of `GetReadings`, a table of named values.
+- Verify the readings make sense (for example, room temperature should be roughly
+  20-25°C).
+
+## Try it
+
+Read sensor data programmatically and print it.
+
+To get the credentials for the code below, go to your machine's page in the Viam app, click the **CONNECT** tab, and select **API keys**.
+Copy the **API key** and **API key ID**.
+Copy the **machine address** from the same tab.
+When you run the code below, you'll see sensor readings printed once per second. Verify the values make sense for your environment.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```bash
+pip install viam-sdk
+```
+
+Save this as `sensor_test.py`:
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.components.sensor import Sensor
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    sensor = Sensor.from_robot(robot, "temperature-sensor")
+
+    # Get readings 5 times, once per second
+    for i in range(5):
+        readings = await sensor.get_readings()
+        print(f"Reading {i + 1}: {readings}")
+        await asyncio.sleep(1)
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```bash
+python sensor_test.py
+```
+
+You should see output like:
+
+```text
+Reading 1: {'temperature_celsius': 22.5, 'humidity_percent': 45.2}
+Reading 2: {'temperature_celsius': 22.5, 'humidity_percent': 45.3}
+...
+```
+
+The exact keys and values depend on your sensor.
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```bash
+mkdir sensor-test && cd sensor-test
+go mod init sensor-test
+go get go.viam.com/rdk
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "time"
+
+    "go.viam.com/rdk/components/sensor"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("sensor-test")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    s, err := sensor.FromProvider(robot, "temperature-sensor")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    // Get readings 5 times, once per second
+    for i := 0; i < 5; i++ {
+        readings, err := s.Readings(ctx, nil)
+        if err != nil {
+            logger.Fatal(err)
+        }
+        fmt.Printf("Reading %d: %v\n", i+1, readings)
+        time.Sleep(1 * time.Second)
+    }
+}
+```
+
+Run it:
+
+```bash
+go run main.go
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "No readings appear" >}}
+
+- Check physical connections: power, ground, and data lines.
+- For I2C sensors, verify the I2C address. Run `i2cdetect -y 1` on Linux to
+  scan the bus and confirm the device is visible.
+- For serial sensors, check the device path (`ls /dev/ttyUSB*` or
+  `ls /dev/ttyACM*`).
+
+{{< /expand >}}
+
+{{< expand "Readings are all zeros or nonsensical" >}}
+
+- The I2C address may be wrong. Some sensors use different addresses depending
+  on a jumper or pin configuration.
+- The sensor may need a warmup period. Some environmental sensors take
+  several seconds to produce valid readings after power-on.
+
+{{< /expand >}}
+
+{{< expand "Module not found in registry" >}}
+
+- Try broader search terms. Module names don't always match sensor model
+  numbers exactly.
+- If your sensor uses a common protocol (I2C, SPI, serial), there may be a
+  generic module that works. Check the registry for protocol-based modules.
+
+{{< /expand >}}
+
+## What's next
+
+- [Sensor API reference](/reference/apis/components/sensor/): full method documentation.
+- [Capture and Sync Data](/data/capture-sync/capture-and-sync-data/): automatically
+  capture sensor readings and sync them to the cloud.
+- [What is a module?](/build-modules/overview/): write a module that
+  takes action based on sensor readings.
diff --git a/docs/hardware/common-components/add-a-servo.md b/docs/hardware/common-components/add-a-servo.md
new file mode 100644
index 0000000000..c309ffac37
--- /dev/null
+++ b/docs/hardware/common-components/add-a-servo.md
@@ -0,0 +1,237 @@
+---
+linkTitle: "Servo"
+title: "Add a servo"
+weight: 75
+layout: "docs"
+type: "docs"
+description: "Add and configure a hobby servo controlled by a GPIO PWM pin."
+date: "2025-03-07"
+aliases:
+  - /hardware-components/add-a-servo/
+---
+
+Add a servo to your machine's configuration so you can control its angular position from the Viam app and from code.
+
+## Concepts
+
+A servo moves to a specific angle (typically 0-180 degrees) and holds that
+position. Unlike a motor, which spins continuously, a servo provides precise
+angular positioning through PWM control.
+
+The servo component uses a single PWM-capable pin on a
+[board component](/hardware/common-components/add-a-board/). Browse all available servo models in the [Viam registry](https://app.viam.com/registry?type=component&subtype=servo).
+
+## Steps
+
+### 1. Prerequisites
+
+- Your machine is online in the Viam app.
+- A [board component](/hardware/common-components/add-a-board/) is configured.
+- Your servo's signal wire is connected to a PWM-capable GPIO pin, with
+  power and ground wired appropriately.
+
+### 2. Add a servo component
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. For a standard hobby servo controlled by a PWM pin on your board,
+   search for **gpio servo**.
+4. Name your servo (for example, `pan-servo`) and click **Create**.
+
+### 3. Configure servo attributes
+
+```json
+{
+  "board": "my-board",
+  "pin": "12"
+}
+```
+
+| Attribute               | Type   | Required | Description                                                  |
+| ----------------------- | ------ | -------- | ------------------------------------------------------------ |
+| `board`                 | string | Yes      | Name of the board component.                                 |
+| `pin`                   | string | Yes      | GPIO pin for the servo signal wire.                          |
+| `min_angle_deg`         | float  | No       | Minimum angle. Default: `0`.                                 |
+| `max_angle_deg`         | float  | No       | Maximum angle. Default: `180`.                               |
+| `starting_position_deg` | float  | No       | Position on startup. Default: `0`.                           |
+| `frequency_hz`          | int    | No       | PWM frequency. Default: `300`. Most servos expect 50-330 Hz. |
+
+If your servo doesn't reach its full range or jitters at the extremes, adjust
+the pulse width:
+
+| Attribute      | Type | Description                                  |
+| -------------- | ---- | -------------------------------------------- |
+| `min_width_us` | int  | Minimum pulse width in microseconds (>450).  |
+| `max_width_us` | int  | Maximum pulse width in microseconds (<2500). |
+
+### 4. Save and test
+
+Click **Save**, then expand the **Test** section.
+
+- Use the angle slider to move the servo to different positions.
+- The servo should move smoothly and hold its position.
+
+## Try it
+
+Sweep the servo through a range of positions.
+
+To get the credentials for the code below, go to your machine's page in the Viam app, click the **CONNECT** tab, and select **API keys**.
+Copy the **API key** and **API key ID**.
+Copy the **machine address** from the same tab.
+If you're using real hardware, you'll see the servo sweep through positions when you run the code below.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```bash
+pip install viam-sdk
+```
+
+Save this as `servo_test.py`:
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.components.servo import Servo
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    servo = Servo.from_robot(robot, "pan-servo")
+
+    # Sweep through positions
+    for angle in [0, 45, 90, 135, 180]:
+        await servo.move(angle)
+        current = await servo.get_position()
+        print(f"Moved to {angle}°, position reads {current}°")
+        await asyncio.sleep(0.5)
+
+    # Return to center
+    await servo.move(90)
+    print("Returned to 90°")
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```bash
+python servo_test.py
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```bash
+mkdir servo-test && cd servo-test
+go mod init servo-test
+go get go.viam.com/rdk
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "time"
+
+    "go.viam.com/rdk/components/servo"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("servo-test")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    s, err := servo.FromProvider(robot, "pan-servo")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    // Sweep through positions
+    for _, angle := range []uint32{0, 45, 90, 135, 180} {
+        if err := s.Move(ctx, angle, nil); err != nil {
+            logger.Fatal(err)
+        }
+        position, err := s.Position(ctx, nil)
+        if err != nil {
+            logger.Fatal(err)
+        }
+        fmt.Printf("Moved to %d°, position reads %d°\n", angle, position)
+        time.Sleep(500 * time.Millisecond)
+    }
+
+    // Return to center
+    if err := s.Move(ctx, 90, nil); err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Println("Returned to 90°")
+}
+```
+
+Run it:
+
+```bash
+go run main.go
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "Servo jitters or buzzes" >}}
+
+- The servo may not be getting enough power. Servos draw significant current
+  when loaded. Use an external power supply rather than powering from the
+  SBC's GPIO header.
+- Adjust `frequency_hz`. Some servos work better at 50 Hz, others at 300 Hz.
+
+{{< /expand >}}
+
+{{< expand "Servo doesn't reach full range" >}}
+
+- Adjust `min_width_us` and `max_width_us` to match your servo's actual pulse
+  width range. Check the servo's datasheet for the correct values.
+
+{{< /expand >}}
+
+{{< expand "Servo doesn't respond" >}}
+
+- Verify the pin supports PWM output. Not all GPIO pins can generate PWM.
+- Check power and ground connections.
+- Confirm the pin number in your config matches the physical wiring.
+
+{{< /expand >}}
+
+## What's next
+
+- [Servo API reference](/reference/apis/components/servo/): full method documentation.
+- [Add a Motor](/hardware/common-components/add-a-motor/): for continuous rotation
+  instead of angular positioning.
+- [What is a module?](/build-modules/overview/): write code that
+  moves the servo based on sensor readings.
diff --git a/docs/hardware/common-components/add-a-switch.md b/docs/hardware/common-components/add-a-switch.md
new file mode 100644
index 0000000000..e06e2f0cd8
--- /dev/null
+++ b/docs/hardware/common-components/add-a-switch.md
@@ -0,0 +1,235 @@
+---
+linkTitle: "Switch"
+title: "Add a switch"
+weight: 80
+layout: "docs"
+type: "docs"
+description: "Add and configure a switch component to read and set the position of a multi-position switch."
+date: "2025-03-07"
+aliases:
+  - /hardware-components/add-a-switch/
+---
+
+Add a switch to your machine's configuration so you can read and set switch positions from the Viam app and from code.
+
+## Concepts
+
+A switch component represents a multi-position switch. The API provides:
+
+- **GetPosition**: read the current switch position (as a number).
+- **SetPosition**: set the switch to a specific position.
+- **GetNumberOfPositions**: query how many positions the switch has, along
+  with optional labels for each position.
+
+Physical switch hardware typically comes from a **module in the registry** that
+reads GPIO pins or communicates with a switch controller.
+
+The `fake` built-in model simulates a switch with configurable positions and
+is useful for testing. Browse available switch models in the [Viam registry](https://app.viam.com/registry?type=component&subtype=switch).
+
+## Steps
+
+### 1. Add a switch component
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for the model that matches your switch hardware. Search by
+   manufacturer name, chip, or device type.
+4. Name your switch (for example, `my-switch`) and click **Create**.
+
+### 2. Configure switch attributes
+
+**For the `fake` model:**
+
+```json
+{
+  "position_count": 3,
+  "labels": ["off", "low", "high"]
+}
+```
+
+| Attribute        | Type            | Required | Description                                                                       |
+| ---------------- | --------------- | -------- | --------------------------------------------------------------------------------- |
+| `position_count` | int             | No       | Number of positions. Defaults to 2.                                               |
+| `labels`         | list of strings | No       | Human-readable labels for each position. Must match `position_count` if provided. |
+
+For a physical switch with a registry module, check the module's documentation
+for required attributes.
+
+### 3. Save and test
+
+Click **Save**, then expand the **Test** section.
+
+- Read the current position.
+- Set the switch to different positions and verify it responds correctly.
+
+## Try it
+
+Read the switch position, cycle through positions, and read labels.
+
+To get the credentials for the code below, go to your machine's page in the Viam app, click the **CONNECT** tab, and select **API keys**.
+Copy the **API key** and **API key ID**.
+Copy the **machine address** from the same tab.
+When you run the code below, you'll see the switch cycle through all positions. With the fake model, positions update in memory. With real hardware, verify the switch physically changes state.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```bash
+pip install viam-sdk
+```
+
+Save this as `switch_test.py`:
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.components.switch import Switch
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    switch = Switch.from_robot(robot, "my-switch")
+
+    # Get number of positions and labels
+    num_positions, labels = await switch.get_number_of_positions()
+    print(f"Positions: {num_positions}, Labels: {labels}")
+
+    # Get current position
+    position = await switch.get_position()
+    print(f"Current position: {position}")
+
+    # Cycle through all positions
+    for pos in range(num_positions):
+        await switch.set_position(pos)
+        current = await switch.get_position()
+        label = labels[pos] if labels else str(pos)
+        print(f"Set to position {pos} ({label}), read back: {current}")
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```bash
+python switch_test.py
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```bash
+mkdir switch-test && cd switch-test
+go mod init switch-test
+go get go.viam.com/rdk
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    toggleswitch "go.viam.com/rdk/components/switch"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("switch-test")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    sw, err := toggleswitch.FromProvider(robot, "my-switch")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    // Get number of positions and labels
+    numPositions, labels, err := sw.GetNumberOfPositions(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Positions: %d, Labels: %v\n", numPositions, labels)
+
+    // Get current position
+    position, err := sw.GetPosition(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Current position: %d\n", position)
+
+    // Cycle through all positions
+    for pos := uint32(0); pos < numPositions; pos++ {
+        if err := sw.SetPosition(ctx, pos, nil); err != nil {
+            logger.Fatal(err)
+        }
+        current, err := sw.GetPosition(ctx, nil)
+        if err != nil {
+            logger.Fatal(err)
+        }
+        label := fmt.Sprintf("%d", pos)
+        if int(pos) < len(labels) {
+            label = labels[pos]
+        }
+        fmt.Printf("Set to position %d (%s), read back: %d\n", pos, label, current)
+    }
+}
+```
+
+Run it:
+
+```bash
+go run main.go
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "SetPosition returns an error" >}}
+
+- Verify the position value is within the valid range (0 to
+  `GetNumberOfPositions - 1`).
+- Check the module's documentation for any constraints on position changes.
+
+{{< /expand >}}
+
+{{< expand "GetPosition returns unexpected values" >}}
+
+- Some physical switches may bounce between positions. Check if your module
+  supports debouncing configuration.
+- Verify the wiring matches the expected position mapping.
+
+{{< /expand >}}
+
+## What's next
+
+- [Switch API reference](/reference/apis/components/switch/): full method documentation.
+- [What is a module?](/build-modules/overview/): write a module that
+  responds to switch position changes.
+- [Component types](/hardware/component-types/): find the right type for
+  your hardware.
diff --git a/docs/hardware/common-components/add-an-arm.md b/docs/hardware/common-components/add-an-arm.md
new file mode 100644
index 0000000000..a23391a812
--- /dev/null
+++ b/docs/hardware/common-components/add-an-arm.md
@@ -0,0 +1,304 @@
+---
+linkTitle: "Arm"
+title: "Add an arm"
+weight: 5
+layout: "docs"
+type: "docs"
+description: "Add and configure a robotic arm, verify joint motion, and test end-effector positioning."
+date: "2025-03-07"
+aliases:
+  - /hardware-components/add-an-arm/
+---
+
+Add a robotic arm to your machine's configuration so you can control it from the Viam app and from code.
+
+## Concepts
+
+An arm component controls a multi-jointed robotic arm. The API provides:
+
+- **Joint-level control**: move individual joints to specific angles.
+- **End-effector positioning**: move the end effector to a pose in 3D space
+  (Viam handles the inverse kinematics).
+- **Motion planning integration**: the motion service can plan
+  collision-free paths for the arm.
+
+Arm models almost always come from **modules in the registry** because each
+arm manufacturer has its own communication protocol. Common models include:
+
+| Module                                                                | Models                       |
+| --------------------------------------------------------------------- | ---------------------------- |
+| [UFactory](https://app.viam.com/module/viam/ufactory)                 | xArm6, xArm7, xArm850, lite6 |
+| [Universal Robots](https://app.viam.com/module/viam/universal-robots) | ur3e, ur5e, ur7e, ur20       |
+
+The `fake` built-in model is useful for testing code without physical hardware.
+It supports kinematics for several arm models (ur5e, ur20, xarm6, xarm7, lite6).
+
+## Steps
+
+### 1. Add an arm component
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for the model that matches your arm manufacturer and model:
+   - For a UFactory xArm, search for **xArm6** (or xArm5, xArm7, Lite6).
+   - For a Universal Robots arm, search for **ur5e** (or ur3e, ur10e, ur16e).
+4. Name your arm (for example, `my-arm`) and click **Create**.
+
+### 2. Configure arm attributes
+
+Attributes vary by arm module. Most network-connected arms need a host
+address:
+
+**UFactory xArm 6:**
+
+```json
+{
+  "host": "192.168.1.100",
+  "speed_degs_per_sec": 30,
+  "acceleration_degs_per_sec_per_sec": 100
+}
+```
+
+| Attribute                           | Type   | Required | Description                                                                                                                                                                                                                                                                                                      |
+| ----------------------------------- | ------ | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `host`                              | string | Yes      | IP address of the arm's control box. You can find this on a sticker on the control box or in the manufacturer's network settings.                                                                                                                                                                                |
+| `speed_degs_per_sec`                | float  | No       | How fast joints rotate, in degrees per second. Range: 3-180. Default: 60. Start low (15-30) when testing a new setup. Increase once you're confident in your configuration and collision boundaries.                                                                                                             |
+| `acceleration_degs_per_sec_per_sec` | float  | No       | How quickly joints ramp up to speed, in degrees per second squared. Range: 0-1145. Default: ~382. Lower values produce smoother, more predictable motion, which matters when the arm carries a payload or works near obstacles. Most users don't need to change this unless motion is too jerky or too sluggish. |
+
+These are common attributes for the [UFactory xArm module](https://app.viam.com/module/viam/ufactory-xarm).
+Check your module's documentation in the registry for the full list of attributes.
+For example, see the [Universal Robots module](https://app.viam.com/module/viam/universal-robots).
+
+### 3. Configure a frame (recommended)
+
+If you plan to use motion planning or coordinate with other components (like a
+camera or gripper), add a frame to define the arm's position in your workspace.
+
+This frame places the arm's base at the world origin, which is common for single-arm setups:
+
+```json
+{
+  "frame": {
+    "parent": "world",
+    "translation": { "x": 0, "y": 0, "z": 0 },
+    "orientation": {
+      "type": "ov_degrees",
+      "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+    }
+  }
+}
+```
+
+For two-arm setups, one arm is typically at the world origin and the other is offset by its distance from the first arm in the x and y directions using the `translation` field.
+
+See [Frame System](/motion-planning/frame-system/) for details on configuring frames.
+
+### 4. Save and test
+
+Click **Save**, then expand the **Test** section.
+
+- Use the joint position controls to move individual joints.
+- Verify each joint moves in the expected direction.
+- Start with slow speeds until you're confident in the configuration.
+
+## Try it with a fake arm
+
+To develop and test code without physical hardware, use the `fake` built-in
+model:
+
+```json
+{
+  "arm-model": "xarm6"
+}
+```
+
+The fake arm simulates kinematics for the specified model. Set `arm-model` to `ur5e`, `ur20`, `xarm6`, `xarm7`, or `lite6`. It responds to all API calls and reports joint positions, but doesn't move anything physical.
+
+## Control your arm from code
+
+Read the arm's current joint positions, move two joints, and confirm the positions changed.
+
+To get the credentials for the code below, go to your machine's page in the Viam app, click the **CONNECT** tab, and select **API keys**.
+Copy the **API key** and **API key ID**.
+Copy the **machine address** from the same tab.
+
+If you're using a real arm, you'll see it physically move when you run the code below.
+With a fake arm, the positions update in memory without physical motion, but you can watch the joint values update in real time by expanding the **test** section on the arm's component card in the **CONFIGURE** tab.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```bash
+pip install viam-sdk
+```
+
+Save this as `arm_test.py`:
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.components.arm import Arm
+from viam.proto.component.arm import JointPositions
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    arm = Arm.from_robot(robot, "my-arm")
+
+    # Read current joint positions
+    joints = await arm.get_joint_positions()
+    print(f"Joint positions before move: {joints.values}")
+
+    # Move joints 1 and 2
+    new_joints = JointPositions(values=[10, -10, 0, 0, 0, 0])
+    await arm.move_to_joint_positions(new_joints)
+
+    # Read joint positions again to confirm the move
+    joints = await arm.get_joint_positions()
+    print(f"Joint positions after move: {joints.values}")
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```bash
+python arm_test.py
+```
+
+You should see all zeros before the move, then joints 1 and 2 at 10 and -10 degrees:
+
+```text
+Joint positions before move: [0, 0, 0, 0, 0, 0]
+Joint positions after move: [10, -10, 0, 0, 0, 0]
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```bash
+mkdir arm-test && cd arm-test
+go mod init arm-test
+go get go.viam.com/rdk
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/components/arm"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/referenceframe"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("arm-test")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    a, err := arm.FromProvider(robot, "my-arm")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    // Read current joint positions
+    joints, err := a.JointPositions(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Joint positions before move: %v\n", joints)
+
+    // Move joints 1 and 2
+    newJoints := []referenceframe.Input{
+        {Value: 10}, {Value: -10}, {Value: 0},
+        {Value: 0}, {Value: 0}, {Value: 0},
+    }
+    err = a.MoveToJointPositions(ctx, newJoints, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    // Read joint positions again to confirm the move
+    joints, err = a.JointPositions(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Joint positions after move: %v\n", joints)
+}
+```
+
+Run it:
+
+```bash
+go run main.go
+```
+
+You should see all zeros before the move, then joints 1 and 2 at 10 and -10 degrees.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "Cannot connect to arm" >}}
+
+- Verify the arm is powered on and connected to the same network as your
+  machine.
+- Ping the arm's IP address from the machine to confirm network connectivity.
+- Check that no other software (manufacturer's own control software) has an
+  exclusive connection to the arm.
+
+{{< /expand >}}
+
+{{< expand "Arm moves but positions are wrong" >}}
+
+- Verify the frame configuration matches the arm's physical placement.
+- If using motion planning, check that the kinematics model matches your
+  arm. Using the wrong model causes incorrect inverse kinematics.
+
+{{< /expand >}}
+
+{{< expand "Motion planning fails" >}}
+
+- Ensure the arm has a frame configured with `parent: "world"`.
+- Check that the target pose is within the arm's reachable workspace.
+- See [Obstacles](/motion-planning/obstacles/) for configuring obstacles and
+  [Constraints](/motion-planning/constraints/) for motion constraints.
+
+{{< /expand >}}
+
+## What's next
+
+- [Arm API reference](/reference/apis/components/arm/): full method documentation.
+- [Fragments](/hardware/fragments/): save and reuse working
+  hardware configurations.
+- [Motion Planning](/motion-planning/): configure frames, kinematics, and
+  obstacles for motion planning.
+- [What is a module?](/build-modules/overview/): write a module that
+  coordinates the arm with sensors.
diff --git a/docs/hardware/common-components/add-an-encoder.md b/docs/hardware/common-components/add-an-encoder.md
new file mode 100644
index 0000000000..e66abf5f8a
--- /dev/null
+++ b/docs/hardware/common-components/add-an-encoder.md
@@ -0,0 +1,277 @@
+---
+linkTitle: "Encoder"
+title: "Add an encoder"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "Add and configure an encoder to track motor position and direction."
+date: "2025-03-07"
+aliases:
+  - /hardware-components/add-an-encoder/
+---
+
+Add an encoder to your machine's configuration so you can track motor position and direction from the Viam app and from code.
+
+## Concepts
+
+Encoders come in two main varieties:
+
+- **Incremental (quadrature)**: two signal channels (A and B) let Viam
+  determine both position and direction. This is the most common type.
+- **Single-channel**: one signal channel tracks position but can't determine
+  direction on its own.
+
+Both connect to a board's GPIO pins as digital interrupts. The encoder counts
+signal transitions ("ticks") that correspond to motor shaft rotation.
+
+Once you configure an encoder and reference it from a motor component, the
+motor gains accurate position control. `GoFor` and `GoTo` use actual encoder
+feedback instead of time-based estimates. Browse all available encoder models in the [Viam registry](https://app.viam.com/registry?type=component&subtype=encoder).
+
+## Steps
+
+### 1. Prerequisites
+
+- Your machine is online in the Viam app.
+- A [board component](/hardware/common-components/add-a-board/) is configured.
+- Your encoder is wired to the board's GPIO pins.
+
+### 2. Add an encoder component
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for the encoder model that matches your hardware:
+   - For a two-channel quadrature encoder, search for **incremental**.
+   - For a single-channel encoder, search for **single encoder**.
+4. Name your encoder (for example, `left-encoder`) and click **Create**.
+
+### 3. Configure encoder attributes
+
+**Incremental (quadrature) encoder:**
+
+```json
+{
+  "board": "my-board",
+  "pins": {
+    "a": "37",
+    "b": "35"
+  }
+}
+```
+
+| Attribute | Type   | Required | Description                  |
+| --------- | ------ | -------- | ---------------------------- |
+| `board`   | string | Yes      | Name of the board component. |
+| `pins.a`  | string | Yes      | GPIO pin for channel A.      |
+| `pins.b`  | string | Yes      | GPIO pin for channel B.      |
+
+**Single-channel encoder:**
+
+```json
+{
+  "board": "my-board",
+  "pins": {
+    "i": "37"
+  }
+}
+```
+
+| Attribute | Type   | Required | Description                      |
+| --------- | ------ | -------- | -------------------------------- |
+| `board`   | string | Yes      | Name of the board component.     |
+| `pins.i`  | string | Yes      | GPIO pin for the signal channel. |
+
+### 4. Link the encoder to a motor
+
+After creating the encoder, update your motor's configuration to reference it:
+
+```json
+{
+  "board": "my-board",
+  "max_rpm": 200,
+  "pins": { "a": "11", "b": "13", "pwm": "15" },
+  "encoder": "left-encoder",
+  "ticks_per_rotation": 600
+}
+```
+
+`ticks_per_rotation` is the number of encoder ticks in one full rotation of
+the motor shaft. Check your encoder's datasheet. Common values are 12, 48,
+200, or 600 depending on the encoder type and any gearing.
+
+### 5. Save and test
+
+Click **Save**, then expand the **Test** section for the encoder.
+
+- Manually rotate the motor shaft. The tick count should change.
+- Rotating in one direction should increase the count; the other direction
+  should decrease it (with an incremental encoder).
+
+Then test the motor. `GoFor` should now stop accurately at the target
+position.
+
+## Try it
+
+Read the encoder position and reset it.
+
+To get the credentials for the code below, go to your machine's page in the Viam app, click the **CONNECT** tab, and select **API keys**.
+Copy the **API key** and **API key ID**.
+Copy the **machine address** from the same tab.
+When you run the code below, you'll see the encoder's current position, then reset it to zero. Manually rotate the motor shaft to verify the count changes.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```bash
+pip install viam-sdk
+```
+
+Save this as `encoder_test.py`:
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.components.encoder import Encoder
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    encoder = Encoder.from_robot(robot, "left-encoder")
+
+    position, pos_type = await encoder.get_position()
+    print(f"Position: {position} ({pos_type})")
+
+    properties = await encoder.get_properties()
+    print(f"Ticks count supported: {properties.ticks_count_supported}")
+    print(f"Angle degrees supported: {properties.angle_degrees_supported}")
+
+    await encoder.reset_position()
+    print("Position reset to zero")
+
+    position, pos_type = await encoder.get_position()
+    print(f"Position after reset: {position}")
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```bash
+python encoder_test.py
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```bash
+mkdir encoder-test && cd encoder-test
+go mod init encoder-test
+go get go.viam.com/rdk
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/components/encoder"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("encoder-test")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    enc, err := encoder.FromProvider(robot, "left-encoder")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    position, posType, err := enc.Position(ctx, encoder.PositionTypeUnspecified, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Position: %.2f (%v)\n", position, posType)
+
+    properties, err := enc.Properties(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Ticks count supported: %v\n", properties.TicksCountSupported)
+    fmt.Printf("Angle degrees supported: %v\n", properties.AngleDegreesSupported)
+
+    if err := enc.ResetPosition(ctx, nil); err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Println("Position reset to zero")
+}
+```
+
+Run it:
+
+```bash
+go run main.go
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "Encoder count doesn't change" >}}
+
+- Verify the wiring: check that the encoder's power, ground, and signal pins
+  are connected correctly.
+- Confirm the GPIO pin numbers match your wiring. Use the board test panel to
+  check that the pins register changes when you rotate the shaft.
+
+{{< /expand >}}
+
+{{< expand "Count always increases (never decreases)" >}}
+
+- This happens with single-channel encoders, which can't detect direction.
+  If you need direction sensing, use an incremental (quadrature) encoder.
+
+{{< /expand >}}
+
+{{< expand "Position is inaccurate or drifts" >}}
+
+- Check `ticks_per_rotation`. If it's wrong, the motor will overshoot or
+  undershoot targets. Count actual ticks for one full shaft rotation to verify.
+- Try swapping the `a` and `b` pins. If they're reversed, the encoder may
+  count in the wrong direction.
+
+{{< /expand >}}
+
+## What's next
+
+- [Encoder API reference](/reference/apis/components/encoder/): full method documentation.
+- [Add a Motor](/hardware/common-components/add-a-motor/): configure the motor that
+  this encoder monitors.
+- [Add a Base](/hardware/common-components/add-a-base/): use motors with encoders
+  for accurate odometry on a wheeled base.
diff --git a/docs/hardware/common-components/add-an-input-controller.md b/docs/hardware/common-components/add-an-input-controller.md
new file mode 100644
index 0000000000..f112639f15
--- /dev/null
+++ b/docs/hardware/common-components/add-an-input-controller.md
@@ -0,0 +1,290 @@
+---
+linkTitle: "Input controller"
+title: "Add an input controller"
+weight: 50
+layout: "docs"
+type: "docs"
+description: "Add and configure a gamepad, joystick, or other input device for manual machine control."
+date: "2025-03-07"
+aliases:
+  - /hardware-components/add-an-input-controller/
+---
+
+Add an input controller to your machine's configuration so you can use a gamepad, joystick, or other input device to control your machine.
+
+## Concepts
+
+An input controller component reads events from human input devices: button
+presses, joystick axis movements, and trigger pulls. Your code registers
+callbacks for these events and translates them into machine actions.
+
+### Built-in models
+
+| Model        | Use case                                                                                                                     |
+| ------------ | ---------------------------------------------------------------------------------------------------------------------------- |
+| `gamepad`    | USB gamepad or joystick. Works with most HID-compatible controllers.                                                         |
+| `webgamepad` | Browser-based gamepad input in the Viam app's CONTROL tab. No physical controller needed.                                    |
+| `gpio`       | Buttons and switches wired to GPIO pins on a board.                                                                          |
+| `mux`        | Multiplexes multiple input controllers, allowing one to override another (for example, safety controller overrides gamepad). |
+
+Browse all available input controller models in the [Viam registry](https://app.viam.com/registry?type=component&subtype=input_controller).
+
+## Steps
+
+### Option A: USB gamepad
+
+#### 1. Add an input controller component
+
+1. Plug your gamepad into the machine's USB port.
+2. Click the **+** button.
+3. Select **Configuration block**.
+4. Search for **gamepad**. This is the built-in model for USB game
+   controllers.
+5. Name it (for example, `my-gamepad`) and click **Create**.
+
+#### 2. Configure attributes
+
+The `gamepad` model typically needs no attributes. It auto-detects the
+connected controller.
+
+If you have multiple controllers, specify which one:
+
+```json
+{
+  "dev_file": "/dev/input/event0"
+}
+```
+
+### Option B: Web gamepad
+
+#### 1. Add a webgamepad component
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for **webgamepad**. This model provides browser-based
+   controls in the Viam app.
+4. Name it (for example, `web-controller`) and click **Create**.
+
+No attributes needed. The web gamepad appears in the Viam app's CONTROL tab
+and works with browser-compatible game controllers or on-screen controls.
+
+### Option C: GPIO buttons
+
+#### 1. Prerequisites
+
+- A [board component](/hardware/common-components/add-a-board/) is configured.
+- Buttons or switches are wired to GPIO pins.
+
+#### 2. Add and configure
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for **gpio input controller**. This model maps GPIO pins to
+   controller buttons.
+4. Name it and click **Create**.
+5. Configure the pins:
+
+```json
+{
+  "board": "my-board",
+  "buttons": {
+    "ButtonNorth": "11",
+    "ButtonSouth": "13"
+  }
+}
+```
+
+### Save and test
+
+Click **Save**, then expand the **Test** section.
+
+- The test panel shows all available controls (buttons, axes).
+- Press buttons or move joystick axes. Events should appear in real time.
+
+## Try it
+
+List available controls and print events as they happen.
+
+To get the credentials for the code below, go to your machine's page in the Viam app, click the **CONNECT** tab, and select **API keys**.
+Copy the **API key** and **API key ID**.
+Copy the **machine address** from the same tab.
+When you run the code below, press buttons on your gamepad and watch the events print in real time.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```bash
+pip install viam-sdk
+```
+
+Save this as `input_test.py`:
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.components.input import Controller, Control, EventType
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    controller = Controller.from_robot(robot, "my-gamepad")
+
+    # List available controls
+    controls = await controller.get_controls()
+    print(f"Available controls: {controls}")
+
+    # Get current state of all events
+    events = await controller.get_events()
+    for control, event in events.items():
+        print(f"  {control}: {event.value}")
+
+    # Register a callback for button presses
+    def handle_press(event):
+        print(f"Button {event.control} {event.event}: value={event.value}")
+
+    controller.register_control_callback(
+        Control.BUTTON_START,
+        [EventType.BUTTON_PRESS, EventType.BUTTON_RELEASE],
+        handle_press,
+    )
+
+    print("\nPress buttons on the gamepad (Ctrl+C to stop)...")
+    # Keep running to receive callbacks
+    await asyncio.sleep(30)
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```bash
+python input_test.py
+```
+
+Press buttons on your gamepad and watch the events print.
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```bash
+mkdir input-test && cd input-test
+go mod init input-test
+go get go.viam.com/rdk
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "time"
+
+    "go.viam.com/rdk/components/input"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("input-test")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    controller, err := input.FromProvider(robot, "my-gamepad")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    // List available controls
+    controls, err := controller.Controls(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Available controls: %v\n", controls)
+
+    // Get current state
+    events, err := controller.Events(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    for control, event := range events {
+        fmt.Printf("  %s: %.2f\n", control, event.Value)
+    }
+
+    // Register a callback for the Start button
+    err = controller.RegisterControlCallback(
+        ctx,
+        input.ButtonStart,
+        []input.EventType{input.ButtonPress, input.ButtonRelease},
+        func(ctx context.Context, event input.Event) {
+            fmt.Printf("Button %s %s: value=%.2f\n",
+                event.Control, event.Event, event.Value)
+        },
+        nil,
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    fmt.Println("\nPress buttons on the gamepad (waiting 30s)...")
+    time.Sleep(30 * time.Second)
+}
+```
+
+Run it:
+
+```bash
+go run main.go
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "Gamepad not detected" >}}
+
+- Check the USB connection. Try a different USB port.
+- On Linux, verify the device exists: `ls /dev/input/event*` or
+  `ls /dev/input/js*`.
+- Some controllers need drivers. Check if the controller works with other
+  Linux applications first.
+
+{{< /expand >}}
+
+{{< expand "Buttons or axes map to wrong controls" >}}
+
+- Different gamepad manufacturers use different button/axis mappings.
+  Use the test panel to identify which physical button maps to which
+  control name, then update your callback registrations accordingly.
+
+{{< /expand >}}
+
+## What's next
+
+- [Input controller API reference](/reference/apis/components/input-controller/): full method documentation.
+- [Add a Base](/hardware/common-components/add-a-base/): drive a mobile robot
+  with your gamepad.
+- [What is a module?](/build-modules/overview/): write a module that
+  translates gamepad input into machine actions.
diff --git a/docs/hardware/component-types.md b/docs/hardware/component-types.md
new file mode 100644
index 0000000000..9462234fd7
--- /dev/null
+++ b/docs/hardware/component-types.md
@@ -0,0 +1,99 @@
+---
+linkTitle: "Component types"
+title: "Component types"
+weight: 5
+layout: "docs"
+type: "docs"
+description: "All the component types Viam supports and when to use each one."
+date: "2025-03-07"
+aliases:
+  - /hardware-components/component-types/
+---
+
+Every component on your machine has a **type** that determines its API,
+which defines what methods your code can call on it.
+Choosing the right type means platform features like data capture, test panels,
+and the SDKs work with your hardware automatically.
+
+## Sensing
+
+These components read information from the physical world.
+
+| Type                                                                  | What it does                                                 | Examples                                             |
+| --------------------------------------------------------------------- | ------------------------------------------------------------ | ---------------------------------------------------- |
+| [Camera](/hardware/common-components/add-a-camera/)                   | Captures 2D images or 3D point clouds                        | USB webcams, IP cameras, depth cameras, lidar        |
+| [Encoder](/hardware/common-components/add-an-encoder/)                | Tracks rotational or linear position                         | Incremental encoders, absolute encoders              |
+| [Movement sensor](/hardware/common-components/add-a-movement-sensor/) | Reports position, orientation, velocity, or angular velocity | GPS, IMU, accelerometer, gyroscope, odometry         |
+| [Power sensor](/hardware/common-components/add-a-power-sensor/)       | Reports voltage, current, and power consumption              | INA219, INA226, current clamps                       |
+| [Sensor](/hardware/common-components/add-a-sensor/)                   | Returns key-value readings                                   | Temperature, humidity, air quality, distance sensors |
+
+## Actuation
+
+These components make things move.
+
+| Type                                                  | What it does                                                          | Examples                                              |
+| ----------------------------------------------------- | --------------------------------------------------------------------- | ----------------------------------------------------- |
+| [Arm](/hardware/common-components/add-an-arm/)        | Controls a multi-jointed robotic arm                                  | xArm, UR5, custom serial arms                         |
+| [Base](/hardware/common-components/add-a-base/)       | Moves a mobile robot as a unit (no need to command individual motors) | Wheeled rovers, tracked vehicles, holonomic platforms |
+| [Gantry](/hardware/common-components/add-a-gantry/)   | Moves along linear rails with precise positioning                     | Single-axis stages, multi-axis CNC gantries           |
+| [Gripper](/hardware/common-components/add-a-gripper/) | Opens and closes a grasping device                                    | Parallel-jaw grippers, vacuum grippers                |
+| [Motor](/hardware/common-components/add-a-motor/)     | Drives rotational or linear motion with speed and position control    | DC motors, stepper motors, brushless motors           |
+| [Servo](/hardware/common-components/add-a-servo/)     | Moves to precise angular positions                                    | Hobby servos, PWM-controlled actuators                |
+
+## Interface
+
+These components provide low-level hardware access or human input.
+
+| Type                                                                     | What it does                                              | Examples                                      |
+| ------------------------------------------------------------------------ | --------------------------------------------------------- | --------------------------------------------- |
+| [Board](/hardware/common-components/add-a-board/)                        | Exposes GPIO pins, analog readers, and digital interrupts | Raspberry Pi GPIO, Arduino, custom I/O boards |
+| [Button](/hardware/common-components/add-a-button/)                      | Reads presses from a physical button                      | Momentary switches, push buttons              |
+| [Generic](/hardware/common-components/add-a-generic/)                    | Catch-all for hardware that doesn't fit another type      | Custom devices with non-standard interfaces   |
+| [Input controller](/hardware/common-components/add-an-input-controller/) | Reads human input from control devices                    | Gamepads, joysticks, custom button panels     |
+| [Switch](/hardware/common-components/add-a-switch/)                      | Reads position from a multi-position switch               | Toggle switches, selector switches            |
+
+## Choosing a type
+
+Match your hardware to the type whose API best describes what it does:
+
+- If it **produces images**, use [camera](/hardware/common-components/add-a-camera/).
+- If it **produces readings** (temperature, distance, pressure), use [sensor](/hardware/common-components/add-a-sensor/).
+- If it **reports position or motion** (GPS, IMU), use [movement sensor](/hardware/common-components/add-a-movement-sensor/).
+- If it **spins or drives linear motion**, use [motor](/hardware/common-components/add-a-motor/).
+- If it **moves to an angle**, use [servo](/hardware/common-components/add-a-servo/).
+- If you need **direct GPIO access**, use [board](/hardware/common-components/add-a-board/).
+- If **nothing fits**, use [generic](/hardware/common-components/add-a-generic/). It provides `DoCommand` for arbitrary interactions.
+
+Every type also has a `DoCommand` method for functionality beyond the standard
+API. For example, a sensor that also has a calibration routine can expose
+calibration through `DoCommand` while still using `GetReadings` for its primary
+data.
+
+## Models
+
+Each component type has one or more **models**: drivers that know how to communicate with specific hardware. Some models ship with `viam-server` (like `webcam` for USB cameras or `gpio` for motors). Most hardware-specific models come from the [Viam registry](https://app.viam.com/registry). All models work the same way regardless of where they come from.
+
+If no model exists for your hardware, you can [write a driver module](/build-modules/write-a-driver-module/) that implements the standard API for your device.
+
+## Switching hardware without changing code
+
+Because every model of a given type exposes the same API, your application
+code doesn't change when you swap hardware. For example, this Python code
+reads a motor's position:
+
+```python
+motor = Motor.from_robot(robot, "drive-motor")
+position = await motor.get_position()
+```
+
+This works whether `drive-motor` is configured as a `gpio` motor on a
+Raspberry Pi, a Trinamic stepper over CAN bus, or an ODrive brushless
+controller. To switch hardware, you change the model and attributes in your
+machine's configuration. Your code stays the same.
+
+## What's next
+
+- [How components work](/hardware/configure-hardware/): understand components
+  and walk through adding any component to your machine.
+- [Add a component](/hardware/common-components/): step-by-step guides for each
+  component type.
diff --git a/docs/hardware/configure-hardware.md b/docs/hardware/configure-hardware.md
new file mode 100644
index 0000000000..133b7a4feb
--- /dev/null
+++ b/docs/hardware/configure-hardware.md
@@ -0,0 +1,153 @@
+---
+linkTitle: "How components work"
+title: "How components work"
+weight: 1
+layout: "docs"
+type: "docs"
+description: "Understand how Viam represents hardware, add components to your machine, and configure them."
+date: "2025-03-07"
+aliases:
+  - /hardware-components/add-a-component/
+  - /hardware/add-a-component/
+---
+
+Viam represents every piece of physical hardware on your machine as a
+**component**.
+Each component has three things:
+
+- A **type** that defines what it can do: camera, motor, sensor, arm, and so on.
+  Every component of the same type exposes the same API, regardless of the
+  underlying hardware.
+- A **model** that provides the driver for your specific hardware.
+  For example, the camera type has models for USB webcams, IP cameras through
+  FFmpeg, and others.
+- **Attributes** that configure how the model talks to your hardware:
+  a device path, a baud rate, a pin mapping, or whatever else the driver needs.
+
+This abstraction means you can swap hardware without changing application code.
+A program that captures images from a webcam works identically with an IP camera.
+You change the model and attributes in configuration, not in your control logic.
+
+## Models
+
+When you add a component, you search for a **model** that matches your hardware. Models are drivers that know how to communicate with specific devices. Some models ship with `viam-server` (like `webcam` for USB cameras or `gpio` for motors wired to GPIO pins). Most hardware-specific models (arms, grippers, specialized sensors, motor controllers) come from **modules** in the [Viam registry](https://app.viam.com/registry).
+
+You don't need to think about where a model comes from. The Viam app shows all available models in one search, and they all work the same way: same API, same data capture, same test sections, same SDKs.
+
+If no model exists for your hardware, you can [write a driver module](/build-modules/write-a-driver-module/) that implements the Viam API for your device.
+
+## Add a component
+
+The process for adding any component is the same whether you're adding a motor,
+a sensor, a board, or anything else. For step-by-step guides for specific
+hardware, see [Add a component](/hardware/common-components/).
+
+### 1. Open your machine in the Viam app
+
+Go to [app.viam.com](https://app.viam.com) and navigate to your machine.
+Confirm it shows as **Live** in the upper left.
+If it shows as offline, verify that `viam-server` is running on your machine.
+
+### 2. Add the component
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for the model that matches your hardware (for example, "webcam", "gpio
+   motor", "xArm6"). The search covers all available models and fragments.
+4. Give your component a **name** and click **Create**. The name is how
+   you reference it in code and configuration, so keep it short,
+   descriptive, and unique on this machine.
+
+### 3. Configure attributes
+
+After creating the component, you'll see its configuration panel.
+Every model has its own set of attributes. These settings tell the driver
+how to communicate with your specific hardware.
+
+Common attributes include:
+
+- **Device paths** (for example, `/dev/video0`, `/dev/ttyUSB0`): which physical
+  device to use.
+- **Pin mappings**: which GPIO pins connect to the hardware.
+- **Communication settings**: baud rate, I2C address, SPI bus.
+- **Operational parameters**: resolution, speed limits, update frequency.
+
+Check the model's reference page for the full list of attributes and their
+defaults.
+You can configure attributes using the form fields in the UI, or switch to
+**JSON** mode to edit the configuration directly.
+
+### 4. Set up dependencies (if needed)
+
+Some components depend on other components.
+For example:
+
+- A **motor** may depend on a **board** for its GPIO pins.
+- An **encoder** may depend on a **board** for its interrupt pins.
+- A **sensor-controlled base** depends on a **base** and a **movement sensor**.
+
+If your component depends on another, that other component must already exist in
+your configuration. The model's reference page documents required dependencies.
+
+### 5. Save the configuration
+
+Click **Save** in the upper right of the configuration panel.
+
+When you save, `viam-server` automatically reloads the configuration and
+initializes the new component. You do not need to restart anything.
+
+### 6. Test the component
+
+Every component in Viam has a **test** section on its component card in the **CONFIGURE** tab. The test section uses the same API your code will use, so if the component works here, it will work in your programs.
+
+1. Find your component in the configuration view.
+2. Expand the **test** section at the bottom of the component card.
+3. Interact with the component:
+   - **Camera**: toggle the stream or capture an image.
+   - **Motor**: set power or move to a position.
+   - **Sensor**: view live readings.
+   - **Servo**: move to an angle.
+   - **Board**: read or set GPIO pin states.
+
+If the test section shows expected results, your component is configured
+correctly.
+
+## Troubleshooting
+
+{{< expand "Component not initializing (error in logs)" >}}
+
+- Check the **LOGS** tab in the Viam app for error messages from `viam-server`.
+- Verify that the device path or address in your attributes is correct.
+- If the component depends on another (for example, a motor depends on a board),
+  confirm the dependency is configured and working.
+
+{{< /expand >}}
+
+{{< expand "Model not appearing in the dropdown" >}}
+
+- **Built-in models** appear automatically. If you don't see the expected model,
+  confirm your `viam-server` version is up to date.
+- **Module models** appear in the configuration block search alongside
+  built-in models. If you don't see the model you expect, check that
+  your search terms match the model or module name.
+
+{{< /expand >}}
+
+{{< expand "Test panel shows no data or errors" >}}
+
+- Confirm the machine is **Live** in the Viam app.
+- Check physical connections: cables, power, and wiring.
+- Review attributes: wrong pin numbers, incorrect device paths, or typos in
+  attribute names are common causes.
+- Check the **LOGS** tab for specific error messages from the component.
+
+{{< /expand >}}
+
+## What's next
+
+- [Add a component](/hardware/common-components/): step-by-step guides for
+  each component type.
+- [Capture and sync data](/data/capture-sync/capture-and-sync-data/): once your component
+  works, start capturing its data to the cloud.
+- [What is a module?](/build-modules/overview/): write code that
+  reads from sensors and acts on what it finds.
diff --git a/docs/hardware/fragments.md b/docs/hardware/fragments.md
new file mode 100644
index 0000000000..acd85a162c
--- /dev/null
+++ b/docs/hardware/fragments.md
@@ -0,0 +1,90 @@
+---
+linkTitle: "Fragments"
+title: "Fragments"
+weight: 12
+layout: "docs"
+type: "docs"
+description: "Capture working hardware configurations and keep them consistent across your fleet."
+date: "2025-03-07"
+---
+
+Getting hardware to work together takes effort. Calibrating a camera mounted
+on an arm, tuning motor PID parameters, getting the frame transforms right
+between components. This work can take hours, and it's easy to lose when you
+set up the next machine.
+
+A **fragment** captures a working hardware configuration so you don't repeat
+that work. Define the configuration once, including components, attributes,
+and spatial relationships, then apply it to every machine that uses the same
+hardware. When you update the fragment, every machine gets the update
+automatically on its next config sync.
+
+## Use existing fragments
+
+When you search for a configuration block in the Viam app, fragments appear
+alongside individual models. If a fragment matches your hardware combination,
+use it. Someone has already figured out the right configuration for those
+components working together.
+
+For example, if you're setting up an xArm 6 with a wrist-mounted RealSense
+camera, a fragment for that combination configures both components and their
+spatial relationship in one step, rather than adding and configuring each one
+individually.
+
+## Save your own configurations
+
+Once you get a combination of components working together, capture it as a
+fragment so you can reuse it:
+
+1. Go to your organization's
+   [FRAGMENTS page](https://app.viam.com/fragments) in the Viam app.
+2. Create a new fragment.
+3. Add the components and their attributes. You can copy JSON from a working
+   machine's configuration to get started.
+
+The next time you build a machine with the same hardware, you can add the
+fragment instead of configuring each component from scratch.
+
+### Fragment variables
+
+If part of the configuration varies between machines, use a **fragment
+variable** instead of a fixed value. For example, if the arm's IP address
+differs per machine:
+
+```json
+{
+  "host": {
+    "$variable": {
+      "name": "arm_ip"
+    }
+  }
+}
+```
+
+Each machine sets the `arm_ip` variable to its own arm's address. Everything
+else comes from the fragment.
+
+### How fragments merge
+
+When you add a fragment to a machine, its configuration merges with the
+machine's own configuration. If you update the fragment later, every machine
+using it gets the update automatically on its next config sync.
+
+## Contribute to the community
+
+If you've built and tested a configuration that others with the same hardware
+would benefit from, consider sharing it. Contributing fragments to the
+registry means the next person setting up that hardware combination can start
+from a working config instead of building one from scratch.
+
+For the full walkthrough on creating and managing fragments, see
+[Reuse Machine Configuration](/fleet/reuse-configuration/).
+
+## What's next
+
+- [Add a component](/hardware/common-components/): step-by-step guides for
+  each component type.
+- [What is a module?](/build-modules/overview/): write
+  modules that tie your components together.
+- [Reuse Machine Configuration](/fleet/reuse-configuration/): the
+  complete guide to fragment creation, variables, and fleet-wide deployment.
diff --git a/docs/hardware/machine-configuration.md b/docs/hardware/machine-configuration.md
new file mode 100644
index 0000000000..596ee8fdfd
--- /dev/null
+++ b/docs/hardware/machine-configuration.md
@@ -0,0 +1,111 @@
+---
+linkTitle: "Machine configuration"
+title: "Machine configuration"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Understand the JSON configuration that defines your machine's components, and how to edit it."
+date: "2025-03-07"
+aliases:
+  - /hardware-components/configure-components/
+  - /hardware/configure-components/
+---
+
+When you add components through the Viam app, you're building a JSON
+configuration that tells `viam-server` what hardware is attached and how to
+talk to it. Understanding this configuration structure helps you work faster.
+You can edit JSON directly, copy configurations between machines, and debug
+issues by reading the raw config.
+
+## Configuration blocks
+
+Every component in your machine's configuration is a JSON block with these
+fields:
+
+| Field        | What it does                                                                                       |
+| ------------ | -------------------------------------------------------------------------------------------------- |
+| `name`       | A unique name for this component on this machine. Your code references the component by this name. |
+| `api`        | The component type, in the form `rdk:component:<type>` (for example, `rdk:component:arm`).         |
+| `model`      | The specific driver, in the form `namespace:family:name` (for example, `viam:ufactory:xArm6`).     |
+| `attributes` | Model-specific settings that control how to connect to the hardware and how it should behave.      |
+| `depends_on` | Other components this one requires (for example, a motor depends on a board).                      |
+| `frame`      | Optional spatial relationship to a parent component, used by the motion service.                   |
+
+### Example: a motor controlled by a board
+
+Here's a simple configuration with a Raspberry Pi board and a DC motor
+connected to its GPIO pins:
+
+```json
+{
+  "components": [
+    {
+      "name": "my-board",
+      "api": "rdk:component:board",
+      "model": "pi",
+      "attributes": {}
+    },
+    {
+      "name": "my-motor",
+      "api": "rdk:component:motor",
+      "model": "gpio",
+      "attributes": {
+        "pins": {
+          "a": "13",
+          "b": "15",
+          "pwm": "12"
+        },
+        "board": "my-board"
+      },
+      "depends_on": ["my-board"]
+    }
+  ]
+}
+```
+
+A few things to note:
+
+- **The board** uses `pi`, a built-in model. No attributes are needed
+  because the Pi's GPIO layout is known.
+- **The motor** uses `gpio`, a built-in model for DC motors driven by
+  GPIO pins. The `pins` attribute maps the motor's control wires to
+  specific board pins.
+- **`depends_on`** tells `viam-server` to initialize the board before
+  the motor, since the motor needs the board's GPIO pins to function.
+
+### Modules section
+
+When you use a model from the [Viam registry](https://app.viam.com/registry)
+(not built into `viam-server`), your configuration includes a `modules`
+section that tells `viam-server` what to download:
+
+| Field       | What it does                                                                           |
+| ----------- | -------------------------------------------------------------------------------------- |
+| `type`      | Always `"registry"` for modules from the Viam registry.                                |
+| `name`      | A local name for the module (used in logs).                                            |
+| `module_id` | The registry identifier, in the form `namespace:module-name`.                          |
+| `version`   | The version to use. Use a specific version for production; `"latest"` for development. |
+
+You don't need to write this JSON by hand. When you add a module model
+through the Viam app, the modules section is created automatically.
+
+## Editing configuration
+
+You can edit your machine's configuration in two ways:
+
+- **Builder UI**: the visual editor in the Viam app. Best for adding
+  components one at a time and using form fields for attributes.
+- **JSON mode**: click **JSON** in the left-hand menu on the CONFIGURE tab
+  to see and edit the raw JSON. Best for copying configurations, making bulk
+  changes, or understanding exactly what's configured.
+
+Both views edit the same underlying configuration. Changes in one are
+reflected in the other.
+
+## What's next
+
+- [Add a component](/hardware/common-components/): step-by-step guides for
+  each component type.
+- [Fragments](/hardware/fragments/): save and reuse working configurations.
+- [Component Types](/hardware/component-types/): find the right type and
+  model for your hardware.
diff --git a/docs/manage/_index.md b/docs/manage/_index.md
deleted file mode 100644
index 7f5604cdcf..0000000000
--- a/docs/manage/_index.md
+++ /dev/null
@@ -1,67 +0,0 @@
----
-linkTitle: "Deploy and Manage"
-title: "Deploy, manage, and troubleshoot"
-weight: 300
-layout: "docs"
-type: "docs"
-no_list: true
-notoc: true
-noedit: true
-open_on_desktop: true
-overview: true
-description: "Remotely deploy and manage software on any fleet of devices. You can monitor all connected devices and troubleshoot any issues - from anywhere."
-aliases:
-  - /cloud/
-  - /fleet/
-  - /manage/fleet-management/
-  - /product-overviews/fleet-management/
----
-
-Viam's fleet management tooling allows you to remotely deploy and manage software on any fleet of devices. You can monitor all connected devices and troubleshoot any issues - from anywhere.
-
-<div class="img-overlay-wrap aligncenter">
-  <img src="../platform/platform-all.svg" alt="Platform diagram" id="fleet-platform-all" class="aligncenter overview" style="width:800px;height:auto" >
-  <img src="../platform/platform-fleet-team.svg" alt="Platform diagram with team management elements highlighted" id="fleet-platform-team" class="aligncenter overlay" style="width:800px;height:auto" loading="lazy">
-  <img src="../platform/platform-fleet-management.svg" alt="Platform diagram with deploy and manage elements highlighted" class="aligncenter overlay" id="fleet-platform-management" style="width:800px;height:auto" loading="lazy" >
-  <img src="../platform/platform-fleet-monitor.svg" alt="Platform diagram with monitoring elements highlighted" class="aligncenter overlay" id="fleet-platform-monitor" style="width:800px;height:auto" loading="lazy" >
-</div>
-
-<div class="hoveraction">
-
-{{< how-to-expand "Deploy a fleet of machines" "4" "INTERMEDIATE" "" "fleet-platform-management">}}
-{{< cards >}}
-{{% card link="/manage/fleet/reuse-configuration/" noimage="true" %}}
-{{% card link="/manage/fleet/system-settings/" noimage="true" %}}
-{{% card link="/manage/fleet/provision/setup/" noimage="true" %}}
-{{% card link="manage/fleet/provision/end-user-setup/" noimage="true" %}}
-{{< /cards >}}
-{{< /how-to-expand >}}
-
-{{< how-to-expand "Deploy code and manage software on machines" "3" "INTERMEDIATE" "fleet-platform-management" >}}
-{{< cards >}}
-{{% card link="/manage/software/scheduled-jobs/" noimage="true" %}}
-{{% card link="/manage/software/deploy-software/" noimage="true" %}}
-{{% card link="/manage/software/update-software/" noimage="true" %}}
-{{< /cards >}}
-{{< /how-to-expand >}}
-
-{{< how-to-expand "Manage access for organizations" "4" "INTERMEDIATE" "" "fleet-platform-team" >}}
-{{< cards >}}
-{{% card link="/manage/manage/access/" noimage="true" %}}
-{{% card link="/manage/manage/rbac/" noimage="true" %}}
-{{% card link="/manage/manage/oauth/" noimage="true" %}}
-{{% card link="/manage/manage/white-labeled-billing/" noimage="true" %}}
-{{< /cards >}}
-{{< /how-to-expand >}}
-
-{{< how-to-expand "Remotely monitor and troubleshoot" "5" "INTERMEDIATE" "" "fleet-platform-monitor" >}}
-{{< cards >}}
-{{% card link="/manage/troubleshoot/monitor/" noimage="true" %}}
-{{% card link="/manage/troubleshoot/alert/" noimage="true" %}}
-{{% card link="/manage/troubleshoot/teleoperate/custom-interface" customTitle="Teleoperate with custom interface" noimage="true" %}}
-{{% card link="/manage/troubleshoot/teleoperate/default-interface" customTitle="Teleoperate with default interface" noimage="true" %}}
-{{% card link="/manage/troubleshoot/troubleshoot/" noimage="true" %}}
-{{< /cards >}}
-{{< /how-to-expand >}}
-
-</div>
diff --git a/docs/manage/fleet/_index.md b/docs/manage/fleet/_index.md
deleted file mode 100644
index a7376ed547..0000000000
--- a/docs/manage/fleet/_index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-linkTitle: "Deploy fleet"
-weight: 10
-layout: "empty"
-type: "docs"
-empty_node: true
-open_on_desktop: true
-header_only: true
-canonical: "/manage/fleet/reuse-configuration/"
----
diff --git a/docs/manage/fleet/change-network.md b/docs/manage/fleet/change-network.md
deleted file mode 100644
index 26c455471e..0000000000
--- a/docs/manage/fleet/change-network.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-title: "Connect a machine to a new network"
-linkTitle: "Connect to new network"
-weight: 55
-type: "docs"
-description: "Connect a machine to a new WiFi network."
-date: "2025-10-07"
----
-
-This page will guide you to connect your machine to a new WiFi network.
-
-## Prerequisites
-
-Your machine must have `viam-agent` installed to be able to configure network settings.
-
-## Connect to a different WiFi network
-
-As your machine boots, `viam-agent` checks for known networks, if none can be found, `viam-agent` automatically enters provisioning mode.
-
-Follow the instructions to [complete end-user setup for a machine](/manage/fleet/provision/end-user-setup/) and configure the new network settings.
-
-## Force provisioning mode
-
-If you want to change the WiFi network or the network credentials on a device that is already setup and can still connect to the current network, you can enter provisioning using the force provisioning mode.
-
-If you can manually `SSH` into a machine you can follow these steps:
-
-1. Add the [ViamShellDanger fragment](https://app.viam.com/fragment/b511adfa-80ab-4a70-9bd5-fbb14696b17e/json).
-   The `ViamShellDanger` fragment contains the latest version of the shell service, which you must add to your machine before you can use the `viam machines part shell` command.
-
-1. Open a shell on your machine:
-
-   ```sh {class="command-line" data-prompt="$" data-output="2-10"}
-   viam machines part shell --part <PART-ID>
-   ```
-
-1. On the machine, create an empty file at <FILE>/opt/viam/etc/force_provisioning_mode</FILE>:
-
-   ```sh {class="command-line" data-prompt="$" data-output="3-10"}
-   touch /opt/viam/etc/force_provisioning_mode
-   ```
-
-1. The machine will immediately enter provisioning mode until the machine receives the new credentials or the `retry_connection_timeout_minutes` limit, by default 10 minutes, expires.
-
-If you created a provisioning app, program it to add an empty file at <FILE>/opt/viam/etc/force_provisioning_mode</FILE>.
-
-Follow the instructions to [complete end-user setup for a machine](/manage/fleet/provision/end-user-setup/) and configure the new network settings.
-
-## Connect to multiple networks
-
-If your machine frequently moves between different WiFi networks, you can [add the credentials for additional networks in the machine settings](/manage/fleet/system-settings/#configure-networks).
-Your machine must still be internet-connected for this configuration to take effect.
diff --git a/docs/manage/fleet/metadata.md b/docs/manage/fleet/metadata.md
deleted file mode 100644
index f2de9ae659..0000000000
--- a/docs/manage/fleet/metadata.md
+++ /dev/null
@@ -1,151 +0,0 @@
----
-title: "Add custom metadata"
-linkTitle: "Add custom metadata"
-weight: 55
-type: "docs"
-description: "Add custom metadata to as a JSON object for machine parts, machines, locations, and organizations."
-date: "2025-11-14"
-aliases:
-  - /manage/fleet/machine-metadata/
-# updated: ""  # When the tutorial was last entirely checked
----
-
-To store metadata for a machine part, machine, or location you can add custom metadata in the UI or using the Viam SDKs.
-You can also add custom metadata for organizations using the Viam SDKs.
-
-## Prerequisites
-
-{{% expand "A running machine connected to Viam." %}}
-
-{{% snippet "setup-both.md" %}}
-
-{{% /expand%}}
-
-## Add and update custom machine part metadata
-
-{{< tabs >}}
-{{% tab name="Web UI" %}}
-
-1. On a machine page, click on the **...** menu next to the machine part.
-1. Select **Custom part metadata**.
-1. Add the metadata to the JSON object.
-1. Click **Save**.
-
-{{% /tab %}}
-{{% tab name="Python" %}}
-
-{{< read-code-snippet file="/static/include/examples-generated/add-metadata-part.snippet.add-metadata-part.py" lang="py" class="line-numbers linkable-line-numbers" data-line="30-32" >}}
-
-For more information, see [`GetRobotMetadata`](/dev/reference/apis/fleet/#getrobotmetadata) and [`UpdateRobotMetadata`](/dev/reference/apis/fleet/#updaterobotmetadata).
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-{{< read-code-snippet file="/static/include/examples-generated/add-metadata-part.snippet.add-metadata-part.go" lang="go" class="line-numbers linkable-line-numbers" data-line="29-31" >}}
-
-For more information, see [`GetRobotMetadata`](/dev/reference/apis/fleet/#getrobotmetadata) and [`UpdateRobotMetadata`](/dev/reference/apis/fleet/#updaterobotmetadata).
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-{{< read-code-snippet file="/static/include/examples-generated/add-metadata-part.snippet.add-metadata-part.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="22-24" >}}
-
-For more information, see [`GetRobotMetadata`](/dev/reference/apis/fleet/#getrobotmetadata) and [`UpdateRobotMetadata`](/dev/reference/apis/fleet/#updaterobotmetadata).
-
-{{% /tab %}}
-{{< /tabs >}}
-
-## Add and update custom machine metadata
-
-{{< tabs >}}
-{{% tab name="Web UI" %}}
-
-1. On a machine page, click on the **...** menu in the top-right corner.
-1. Select **Custom machine metadata**.
-1. Add the metadata to the JSON object.
-1. Click **Save**.
-
-{{% /tab %}}
-{{% tab name="Python" %}}
-
-{{< read-code-snippet file="/static/include/examples-generated/add-metadata.snippet.add-metadata.py" lang="py" class="line-numbers linkable-line-numbers" data-line="41-43" >}}
-
-For more information, see [`GetRobotMetadata`](/dev/reference/apis/fleet/#getrobotmetadata) and [`UpdateRobotMetadata`](/dev/reference/apis/fleet/#updaterobotmetadata).
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-{{< read-code-snippet file="/static/include/examples-generated/add-metadata.snippet.add-metadata.go" lang="go" class="line-numbers linkable-line-numbers" data-line="50-52" >}}
-
-For more information, see [`GetRobotMetadata`](/dev/reference/apis/fleet/#getrobotmetadata) and [`UpdateRobotMetadata`](/dev/reference/apis/fleet/#updaterobotmetadata).
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-{{< read-code-snippet file="/static/include/examples-generated/add-metadata.snippet.add-metadata.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="37-39" >}}
-
-For more information, see [`GetRobotMetadata`](/dev/reference/apis/fleet/#getrobotmetadata) and [`UpdateRobotMetadata`](/dev/reference/apis/fleet/#updaterobotmetadata).
-
-{{% /tab %}}
-{{< /tabs >}}
-
-## Add and update custom location metadata
-
-{{< tabs >}}
-{{% tab name="Web UI" %}}
-
-1. On a location page, click on the **...** menu in the top-right corner.
-1. Select **Custom location metadata**.
-1. Add the metadata to the JSON object.
-1. Click **Save**.
-
-{{% /tab %}}
-{{% tab name="Python" %}}
-
-{{< read-code-snippet file="/static/include/examples-generated/add-metadata-location.snippet.add-metadata-location.py" lang="py" class="line-numbers linkable-line-numbers" data-line="30-32" >}}
-
-For more information, see [`GetLocationMetadata`](/dev/reference/apis/fleet/#getlocationmetadata) and [`UpdateLocationtMetadata`](/dev/reference/apis/fleet/#updatelocationmetadata).
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-{{< read-code-snippet file="/static/include/examples-generated/add-metadata-location.snippet.add-metadata-location.go" lang="go" class="line-numbers linkable-line-numbers" data-line="28-30" >}}
-
-For more information, see [`GetLocationMetadata`](/dev/reference/apis/fleet/#getlocationmetadata) and [`UpdateLocationtMetadata`](/dev/reference/apis/fleet/#updatelocationmetadata).
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-{{< read-code-snippet file="/static/include/examples-generated/add-metadata-location.snippet.add-metadata-location.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="22-24" >}}
-
-For more information, see [`GetLocationMetadata`](/dev/reference/apis/fleet/#getlocationmetadata) and [`UpdateLocationtMetadata`](/dev/reference/apis/fleet/#updatelocationmetadata).
-
-{{% /tab %}}
-{{< /tabs >}}
-
-## Add and update custom organization metadata
-
-{{< tabs >}}
-
-{{% tab name="Python" %}}
-
-{{< read-code-snippet file="/static/include/examples-generated/add-metadata-organization.snippet.add-metadata-organization.py" lang="py" class="line-numbers linkable-line-numbers" data-line="30-32" >}}
-
-For more information, see [`GetOrganizationMetadata`](/dev/reference/apis/fleet/#getorganizationmetadata) and [`UpdateOrganizationMetadata`](/dev/reference/apis/fleet/#updateorganizationmetadata).
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-{{< read-code-snippet file="/static/include/examples-generated/add-metadata-organization.snippet.add-metadata-organization.go" lang="go" class="line-numbers linkable-line-numbers" data-line="28-30" >}}
-
-For more information, see [`GetOrganizationMetadata`](/dev/reference/apis/fleet/#getorganizationmetadata) and [`UpdateOrganizationMetadata`](/dev/reference/apis/fleet/#updateorganizationmetadata).
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-{{< read-code-snippet file="/static/include/examples-generated/add-metadata-organization.snippet.add-metadata-organization.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="22-24" >}}
-
-For more information, see [`GetOrganizationMetadata`](/dev/reference/apis/fleet/#getorganizationmetadata) and [`UpdateOrganizationMetadata`](/dev/reference/apis/fleet/#updateorganizationmetadata).
-
-{{% /tab %}}
-{{< /tabs >}}
diff --git a/docs/manage/fleet/provision/_index.md b/docs/manage/fleet/provision/_index.md
deleted file mode 100644
index 00287c2a8f..0000000000
--- a/docs/manage/fleet/provision/_index.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-linkTitle: "Provision devices"
-weight: 68
-layout: "empty"
-type: "docs"
-empty_node: true
-canonical: "/manage/fleet/provision/setup/"
----
diff --git a/docs/manage/fleet/provision/end-user-setup.md b/docs/manage/fleet/provision/end-user-setup.md
deleted file mode 100644
index 55f94a9c78..0000000000
--- a/docs/manage/fleet/provision/end-user-setup.md
+++ /dev/null
@@ -1,196 +0,0 @@
----
-title: "Complete end-user setup for a machine"
-linkTitle: "Set up machine (end-user)"
-weight: 69
-type: "docs"
-description: "If you have a machine that uses Viam and have been pointed to this guide, this guide will show you how to set it up."
-images: ["/platform/provisioning-demo.gif"]
-videos: ["/platform/provisioning-demo.webm", "/platform/provisioning-demo.mp4"]
-languages: []
-viamresources: []
-platformarea: ["fleet"]
-level: "Intermediate"
-date: "2024-08-21"
-aliases:
-  - /provision/
-# updated: ""  # When the tutorial was last entirely checked
-cost: "0"
----
-
-If you have a machine with Viam pre-installed on it, this guide will show you how to complete your device setup using either the [Viam mobile app](#set-up-your-machine-using-the-viam-mobile-app) or the [{{< glossary_tooltip term_id="captive-web-portal" text="captive portal" >}}](#set-up-your-machine-using-the-captive-portal).
-
-Whether you need to use the Viam mobile app or the captive portal, depends on how [provisioning was set up](/manage/fleet/provision/setup/) on your machine.
-
-## Prerequisites
-
-- Physical hardware constituting a machine
-- A WiFi-enabled computer, or mobile device (if using the Viam mobile app)
-
-## Set up your machine using the Viam mobile app
-
-<!-- {{<video webm_src="/platform/provisioning-demo.webm" mp4_src="/platform/provisioning-demo.mp4" alt="Using the Viam mobile app to provision a new machine with viam-agent." poster="/platform/provisioning-demo.jpg" max-width="300px" class="">}} -->
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Install the Viam mobile app**
-
-You can find the mobile app on the [App Store](https://apps.apple.com/vn/app/viam-robotics/id6451424162) and on [Google Play](https://play.google.com/store/apps/details?id=com.viam.viammobile&hl=en&gl=US).
-
-<a href="https://apps.apple.com/vn/app/viam-robotics/id6451424162" target="_blank">
-  <img src="/appstore.png" width="200px" alt="apple store icon" class="center-if-small" >
-</a>
-
-<a href="https://play.google.com/store/apps/details?id=com.viam.viammobile&hl=en&gl=US" target="_blank">
-  <img src="/googleplay.png" width="200px" alt="google play store icon" class="center-if-small" >
-</a>
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Create a machine**
-
-Open the Viam mobile app and sign in.
-Then, select an organization and location for your machine.
-Create a new machine or click on an existing machine that has not yet been set up and follow the instructions.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Turn on your machine and follow the app instructions**
-
-Turn on the smart machine you are attempting to connect to.
-
-Follow the instructions and connect to the Bluetooth hotspot your machine has created.
-You may need to wait a short time for your machine to boot and turn on Bluetooth.
-
-By default, the name will begin with `viam-setup-`.
-
-<!-- Then leave the app and navigate to your mobile device's WiFi settings and connect to the WiFi hotspot your machine has created.
-You may need to wait a short time for your machine to boot and create its WiFi hotspot.
-
-Select the machine's WiFi hotspot and enter the password.
-By default, the name will begin with `viam-setup-` and the password is `viamsetup`.
--->
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Provide the network information for the machine**
-
-In the mobile app, follow the instructions to provide the network information for the machine.
-
-The machine will now disable Bluetooth and attempt to connect using the provided network information.
-If the machine cannot establish a connection using the provided network information, the machine enable the hotspot again and prompt you to re-enter the network information until a connection is successfully established.
-
-<!-- The machine will now disable the hotspot network and attempt to connect using the provided network information.
-If the machine cannot establish a connection using the provided network information, the machine will create the hotspot again and prompt you to re-enter the network information until a connection is successfully established. -->
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Wait for machine to complete setup**
-
-If the machine can successfully connect to the network it will now complete its setup and become **live**.
-
-Any features that require internet access will not function if the connected WiFi network is not connected to the internet.
-{{% /tablestep %}}
-{{< /table >}}
-
-## Set up your machine using the captive portal
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Turn on the smart machine**
-
-Turn on the smart machine you are attempting to set up.
-{{% /tablestep %}}
-{{% tablestep %}}
-**Connect to your machine's WiFi hotspot**
-
-On a laptop or mobile device, open your WiFi settings and connect to the WiFi hotspot your machine has created.
-You may need to wait a short time for your machine to boot and create its WiFi hotspot.
-Select the machine's WiFi hotspot and enter the password.
-By default, the name will begin with `viam-setup-` and the password is `viamsetup`.
-
-Once you are connected to your machine's WiFi hotspot you will be redirected to a {{< glossary_tooltip term_id="captive-web-portal" text="captive portal" >}}.
-If you are using a laptop or are not redirected, try opening [http://viam.setup/](http://viam.setup/) in a browser.
-{{% /tablestep %}}
-{{% tablestep %}}
-**Follow the captive portal's instructions to provide network information**
-
-In the captive web portal, follow the instructions to provide the network information for the machine.
-{{% /tablestep %}}
-{{% tablestep %}}
-**If prompted, provide a machine cloud credentials configuration**
-
-Depending on how the machine was set up so far, the captive portal may also require you to paste machine cloud credentials.
-This is the JSON object which contains your machine part secret key and cloud app address, which your machine needs to connect to Viam.
-
-Log into [Viam](https://app.viam.com), and use an existing machine or create a new machine.
-
-To copy your machine cloud credentials:
-
-- Navigate to your machine's page.
-- Select the part status dropdown to the right of your machine's name on the top of the page.
-  {{<imgproc src="configure/machine-part-info.png" resize="500x" declaredimensions=true alt="Machine part info dropdown" class="shadow" >}}
-- Click the copy icon next to **Machine cloud credentials**.
-- Paste the credentials when prompted.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Wait for machine to complete setup**
-
-The machine will now disable the hotspot network and attempt to connect using the provided network information.
-If the machine cannot establish a connection using the provided network information, the machine will create the hotspot again and prompt you to re-enter the network information until a connection is successfully established.
-
-If the machine can successfully connect to the network it will now complete its setup and become **live**.
-
-Any features that require internet access will not function if the connected WiFi network is not connected to the internet.
-{{% /tablestep %}}
-{{< /table >}}
-
-## Troubleshooting
-
-### Bluetooth connection issues
-
-If you're having trouble with Bluetooth provisioning:
-
-1. **Check Bluetooth permissions**: Ensure the app used for provisioning has [Bluetooth permissions enabled](https://github.com/viamrobotics/viam_flutter_bluetooth_provisioning_widget?tab=readme-ov-file#platform-requirements) on your device.
-
-1. **Verify Bluetooth is enabled**: Make sure Bluetooth is turned on in your mobile device settings.
-
-1. **Restart Bluetooth**: Try turning Bluetooth off and on again on your mobile device.
-
-1. **Remove and re-add**: If you've already connected to the machine over Bluetooth, remove or forget the device from your mobile device's settings, and re-add it.
-
-If you can open a terminal on the machine:
-
-1. Check if Bluetooth is available:
-
-   ```sh {class="command-line" data-prompt="$"}
-   bluetoothctl list
-   ```
-
-1. Restart Bluetooth service:
-
-   ```sh {class="command-line" data-prompt="$"}
-   sudo systemctl restart bluetooth
-   ```
-
-1. **Configuration check**: If you set up provisioning, verify that `disable_bt_provisioning` is set to `false` in your configuration.
-
-### WiFi connection issues
-
-If you cannot connect to your machine's temporary WiFi hotspot, confirm you are using the correct password.
-The default password, unless changed by the manufacturer, is `viamsetup`,
-
-If your machine cannot connect to your permanent office or home WiFi network:
-
-1. **Check network credentials**: Verify that the WiFi network name (SSID) and password are correct.
-
-1. **Check network compatibility**: Ensure your WiFi network is compatible with your machine's WiFi band frequency (2.4ghz vs 5ghz).
-
-1. **Try a different network**: If possible, try connecting to a different WiFi network to isolate the issue.
-
-## Next Steps
-
-The machine is now usable.
-
-If the machine needs to be able to connect to more than one WiFi network, you can add additional networks in the [`viam-agent` network configuration](/manage/reference/viam-agent/#network_configuration).
-You can also override other configuration details in the [`viam-agent` configuration](/manage/reference/viam-agent/#configuration).
diff --git a/docs/manage/fleet/provision/setup.md b/docs/manage/fleet/provision/setup.md
deleted file mode 100644
index 427addda84..0000000000
--- a/docs/manage/fleet/provision/setup.md
+++ /dev/null
@@ -1,578 +0,0 @@
----
-linkTitle: "Provision devices"
-title: "Provision devices using viam-agent"
-weight: 68
-type: "docs"
-description: "Provision a machine as it first comes online with a pre-defined configuration - in the factory or when the machine is taken into service."
-tags: ["fleet management", "viam-server", "viam-agent"]
-images: ["/installation/thumbnails/install.png"]
-imageAlt: "Install Viam"
-languages: []
-viamresources: []
-platformarea: ["fleet"]
-level: "Intermediate"
-date: "2024-08-21"
-aliases:
-  - "/build/provision/"
-  - /how-tos/provision-setup/
-  - /fleet/provision/
-  - /how-tos/provision/
-# updated: ""  # When the tutorial was last entirely checked
-# SMEs: James, Ale
-cost: "0"
----
-
-You can install [`viam-agent`](/manage/reference/viam-agent/) as part of your manufacturing process and provision machines with a pre-defined configuration as they come online.
-When the end user sets the machine up, they provide network access and `viam-agent` installs `viam-server` and your latest software.
-
-If you're looking for a full tutorial, see [Monitor Air Quality with a Fleet of Sensors](/tutorials/control/air-quality-fleet/).
-
-## Provisioning flow
-
-To prepare a device, you will follow these steps:
-
-1. You create a machine configuration template: a _{{< glossary_tooltip term_id="fragment" text="fragment" >}}_ on Viam.
-1. You create a defaults file specifying the provisioning method and the fragment.
-1. You flash the SD card for the single-board computer with an operating system.
-1. You install `viam-agent` with the `preinstall` script on the SD card providing the defaults file.
-
-Once a customer receives your machine, they will plug the machine in and turn it on.
-
-The next steps depend on the provisioning method:
-
-{{< tabs >}}
-{{% tab name="Bluetooth + WiFi provisioning (recommended)" %}}
-
-1. `viam-agent` starts Bluetooth Low Energy (BLE) and accepts connections.
-1. The customer installs an app you provide on a mobile device.
-1. The customer uses the app to connect to the machine over Bluetooth.
-1. Using the app, the customer provides the machine WiFi credentials to the machine to connect to a WiFi network.
-1. The machine connects to the internet and sets itself up based on the specified fragment.
-
-{{% /tab %}}
-{{% tab name="WiFi hotspot provisioning" %}}
-
-1. `viam-agent` starts a WiFi hotspot.
-1. The customer uses a mobile device to connect to the machine's temporary WiFi network.
-1. Using a {{< glossary_tooltip term_id="captive-web-portal" text="captive web portal" >}} or a mobile app, the customer provides WiFi credentials to connect to a WiFi network.
-1. The machine connects to the internet and sets itself up based on the specified fragment.
-
-{{% /tab %}}
-{{% tab name="Bluetooth provisioning" %}}
-
-1. `viam-agent` starts Bluetooth Low Energy (BLE) and accepts connections.
-1. The customer installs an app you provide on a mobile device.
-1. The customer uses the app to connect to the machine over Bluetooth and shares the mobile device's internet connection with the machine for setup.
-1. The machine uses the mobile-devices internet to set itself up based on the specified fragment.
-
-{{% /tab %}}
-{{< /tabs >}}
-
-## Provision a device
-
-The following instructions will preinstall `viam-agent` into an image.
-
-**Only use the following method for offline pre-installs with images. For live systems, follow the instructions on a machine's setup tab to install `viam-server` with `viam-agent`.**
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Create a fragment**
-
-If you do not yet have a {{< glossary_tooltip term_id="fragment" text="fragment" >}}, follow the steps to [Create a fragment](/manage/fleet/reuse-configuration/#create-a-fragment) and make a note of the fragment ID.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Create the defaults file**
-
-If you would like to use a {{< glossary_tooltip term_id="captive-web-portal" text="captive web portal" >}}, skip this and the next step.
-
-Create a defaults file called <FILE>viam-defaults.json</FILE> to configure the provisioning experience for the users setting up their machines.
-You will later pass this file to a script, so you can save it anywhere.
-The script will save the file is at <file>/etc/viam-defaults.json</file> on the machine.
-
-You must at least specify a `fragment_id`.
-
-{{< tabs >}}
-{{% tab name="Template" %}}
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "network_configuration": {
-    "manufacturer": "<NAME>", # your company name
-    "model": "<NAME>", # the machine's model
-    "fragment_id": "<ID>", # the fragment id, required for mobile app
-    "hotspot_interface": "<INTERFACE>", # the interface to use for hotspot/provisioning/wifi management
-    "hotspot_prefix": "<PREFIX>", # machine creates a hotspot with prefix-hostname during setup
-    "disable_captive_portal_redirect": false, # set to true if using a mobile app
-    "hotspot_password": "<PASSWORD>", # password for the WiFi or bluetooth hotspot
-    "disable_bt_provisioning": false, # set to true to disable Bluetooth provisioning
-    "disable_wifi_provisioning": false, # set to true to disable WiFi hotspot provisioning
-    "bluetooth_trust_all": false, # set to true to accept all Bluetooth pairing requests (which is only needed for Bluetooth tethering) without requiring an unlock command from a mobile app.
-    "turn_on_hotspot_if_wifi_has_no_internet": false, # set to true if networks without internet should not be accepted.
-    "offline_before_starting_hotspot_minutes": "3m30s",
-    "user_idle_minutes": "2m30s",
-    "retry_connection_timeout_minutes": "15m"
-  }
-}
-```
-
-{{% /tab %}}
-{{% tab name="Example" %}}
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "network_configuration": {
-    "manufacturer": "Skywalker",
-    "model": "C-3PO",
-    "fragment_id": "2567c87d-7aef-41bc-b82c-d363f9874663",
-    "hotspot_interface": "wlan0",
-    "hotspot_prefix": "skywalker-setup",
-    "disable_captive_portal_redirect": false,
-    "hotspot_password": "skywalker123",
-    "disable_bt_provisioning": false,
-    "disable_wifi_provisioning": false,
-    "bluetooth_trust_all": false,
-    "turn_on_hotspot_if_wifi_has_no_internet": false,
-    "offline_before_starting_hotspot_minutes": "3m30s",
-    "user_idle_minutes": "2m30s",
-    "retry_connection_timeout_minutes": "15m"
-  }
-}
-```
-
-This file configures some basic metadata, specifies a fragment to use to configure the machine, and provides the WiFi hotspot network name and password to use on startup.
-It also configures timeouts to control how long `viam-agent` waits for a valid local WiFi network to come online before creating its hotspot network, and how long to keep the hotspot active before terminating it.
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% expand "Click to view attribute information" %}}
-
-<!-- prettier-ignore -->
-| Name       | Type   | Required? | Description |
-| ---------- | ------ | --------- | ----------- |
-| `manufacturer` | string | Optional | Purely informative. May be displayed on captive portal or provisioning app. Default: `"viam"`. |
-| `model` | string | Optional | Purely informative. May be displayed on captive portal or provisioning app. Default: `"custom"`. |
-| `fragment_id` | string | Optional | The `fragment_id` of the fragment to configure machines with. Required when using the Viam mobile app for provisioning. The Viam mobile app uses the fragment to configure the machine. |
-| `hotspot_interface` | string | Optional | The interface to use for hotspot/provisioning/wifi management. Example: `"wlan0"`. Default: first discovered 802.11 device. |
-| `hotspot_prefix` | string | Optional | `viam-agent` will prepend this to the hostname of the device and use the resulting string for the provisioning hotspot SSID or the Bluetooth device name(`<hotspot_prefix>-<hostname>`).  Default: `"viam-setup"`. |
-| `hotspot_password` | string | Optional | Depending on the provisioning method, this is either the Wifi password or bluetooth connection password for the provisioning hotspot. **Important:** When provisioning devices with the Viam mobile app, the password must currently be `"viamsetup"`. Be aware that if you do not set a custom password this may be a security risk. Default: `"viamsetup"`. |
-| `disable_captive_portal_redirect` | boolean | Optional | By default, all DNS lookups are redirected to the "sign in" portal, which can cause mobile devices to automatically display the portal. When set to true, only DNS requests for domains ending in .setup, like `viam.setup` are redirected, preventing the portal from appearing unexpectedly, especially convenient when using a mobile app for provisioning. Default: `false`. |
-| `disable_bt_provisioning` | boolean | Optional | When set to true, disables Bluetooth provisioning. The machine will not advertise Bluetooth services for provisioning. Default: `false`. |
-| `disable_wifi_provisioning` | boolean | Optional | When set to true, disables WiFi hotspot provisioning. The machine will not create a WiFi hotspot for provisioning. Default: `false`. |
-| `turn_on_hotspot_if_wifi_has_no_internet` | boolean | Optional | By default, the device connects to a single prioritized WiFi network (provided during provisioning) and is considered online even if the global internet is not reachable. When `turn_on_hotspot_if_wifi_has_no_internet` is true and the primary network lacks internet connectivity, the device will try all configured networks and only mark itself as online if it successfully connects to the internet. Default: `false`. |
-| `offline_before_starting_hotspot_minutes` | integer | Optional | Will only enter provisioning mode (hotspot) after being disconnected longer than this time. It may be useful to increase this on flaky connections, or when part of a system where the device may start quickly, but the wifi/router may take longer to be available. Default: `2` (2 minutes). |
-| `user_idle_minutes` | integer | Optional | Amount of time before considering a user (using the captive web portal or provisioning app) idle, and resuming normal behavior. Used to avoid interrupting provisioning mode (for example for network tests/retries) when a user might be busy entering details. Default: `5` (5 minutes). |
-| `retry_connection_timeout_minutes` | integer | Optional | Provisioning mode will exit after this time, to allow other unmanaged (for example wired) or manually configured connections to be tried. Provisioning mode will restart if the connection/online status doesn't change. Default: `10` (10 minutes). |
-| `wifi_power_save` | boolean | Optional | Boolean, which, if set, will explicitly enable or disable power save for all WiFi connections managed by NetworkManager. If not set, the system default applies. Default: `NULL`.  |
-| `device_reboot_after_offline_minutes` | integer | Optional | If set, `viam-agent` will reboot the device after it has been offline (and in hotspot mode) for the specified duration. Default: `0` (disabled). |
-
-{{% /expand%}}
-{{% /tablestep %}}
-{{% tablestep %}}
-**Configure Networks**
-
-If a machine connects to a network during setup and you know in advance which WiFi a machine will connect to, this step allows you to add credentials for it.
-
-If you do not know the network in advance, skip this step.
-In this case the end user will have to provide network details later in the process.
-
-If you know in advance that the machine should be able to connect to multiple networks, we recommend that you add WiFi settings in the operating system (for example, directly in NetworkManager).
-If that is not possible, you can add networks with the `additional_networks` field.
-`viam-agent` will then try to connect to each specified network in order of `priority` from highest to lowest.
-
-The following configuration defines the connection information and credentials for two WiFi networks named `fallbackNetOne` and `fallbackNetTwo`:
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "network_configuration": {
-    "manufacturer": "Skywalker",
-    "model": "C-3PO",
-    "fragment_id": "2567c87d-7aef-41bc-b82c-d363f9874663",
-    "hotspot_interface": "wlan0",
-    "hotspot_prefix": "skywalker-setup",
-    "disable_captive_portal_redirect": false,
-    "hotspot_password": "skywalker123",
-    "disable_bt_provisioning": false,
-    "disable_wifi_provisioning": false,
-    "turn_on_hotspot_if_wifi_has_no_internet": false,
-    "offline_before_starting_hotspot_minutes": "3m30s",
-    "user_idle_minutes": "2m30s",
-    "retry_connection_timeout_minutes": "15m",
-    "turn_on_hotspot_if_wifi_has_no_internet": true
-  },
-  "additional_networks": {
-    "testNet1": {
-      "priority": 30,
-      "psk": "myFirstPassword",
-      "ssid": "fallbackNetOne",
-      "type": "wifi"
-    },
-    "testNet2": {
-      "priority": 10,
-      "psk": "mySecondPassword",
-      "ssid": "fallbackNetTwo",
-      "type": "wifi"
-    }
-  }
-}
-```
-
-<!-- prettier-ignore -->
-| Name       | Type   | Description |
-| ---------- | ------ | ----------- |
-| `type`     | string | The type of the network. Options: `"wifi"`|
-| `ssid`     | string | The network's SSID. |
-| `psk`      | string | The network password/pre-shared key. |
-| `priority` | int    | Priority to choose the network with. Values between -999 and 999. Default: `0`. |
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Create a machine in advance**
-
-If you are using a mobile app for provisioning, skip this step.
-
-If you provision devices using a captive web portal, you can create a machine in advance.
-You can either provide its machine cloud credentials to the preinstall script you will run in the next steps, or provide them using the captive web portal.
-
-You can get the machine cloud credentials by clicking the copy icon next to **Machine cloud credentials** in the part status dropdown to the right of your machine's name on the top of the page.
-Paste the machine cloud credentials into a file on your hard drive called <FILE>viam.json</FILE>.
-You will pass the file to the preinstall script later, so you can store it anywhere.
-The script will save the file is at <file>/etc/viam.json</file> on the machine.
-
-{{<imgproc src="configure/machine-part-info.png" resize="500x" declaredimensions=true alt="Machine part info dropdown" class="shadow" >}}
-
-{{< expand "Want to create a machine and obtain its machine cloud credentials programmatically?" >}}
-
-You can use the [Fleet Management API](/dev/reference/apis/fleet/) to create machines, and obtain their machine cloud credentials:
-
-```python {class="line-numbers linkable-line-numbers"}
-import asyncio
-import requests
-
-from viam.rpc.dial import DialOptions, Credentials
-from viam.app.viam_client import ViamClient
-from viam.app.app_client import APIKeyAuthorization
-
-# TODO: Replace "<API-KEY>" (including brackets) with your API key
-API_KEY = "<API-KEY>"
-# TODO: Replace "<API-KEY-ID>" (including brackets) with your API key ID
-API_KEY_ID = "<API-KEY-ID>"
-# The id of the location to create the machine in
-LOCATION_ID = ""
-# The name for the machine to create
-MACHINE_NAME = ""
-
-
-async def connect() -> ViamClient:
-    dial_options = DialOptions(
-      credentials=Credentials(
-        type="api-key",
-        payload=API_KEY,
-      ),
-      auth_entity=API_KEY_ID
-    )
-    return await ViamClient.create_from_dial_options(dial_options)
-
-
-async def main():
-    async with await connect() as viam_client:
-        cloud = viam_client.app_client
-        new_machine_id = await cloud.new_robot(
-            name=MACHINE_NAME, location_id=LOCATION_ID)
-        print("Machine created: " + new_machine_id)
-        list_of_parts = await cloud.get_robot_parts(
-            robot_id=new_machine_id)
-        print("Part id: " + list_of_parts[0].id)
-
-        org_list = await cloud.list_organizations()
-        print(org_list[0].id)
-
-        auth = APIKeyAuthorization(
-            role="owner",
-            resource_type="robot",
-            resource_id=new_machine_id
-        )
-        api_key, api_key_id = await cloud.create_key(
-            org_list[0].id, [auth], "test_provisioning_key")
-        print(api_key, api_key_id)
-
-        headers = {
-            'key_id': api_key_id,
-            'key': api_key
-        }
-        params = {
-            "client": 'true',
-            "id": list_of_parts[0].id
-        }
-        res = requests.get(
-            'https://app.viam.com/api/json1/config',
-            params=params,
-            headers=headers,
-            timeout=10
-        )
-        print(res.text)
-
-        with open("viam.json", "w") as text_file:
-            text_file.write(res.text)
-
-
-if __name__ == '__main__':
-    asyncio.run(main())
-```
-
-{{< /expand >}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Flash an operating system to the SD card of the single-board computer**
-
-{{< tabs >}}
-{{% tab name="Raspberry Pi" %}}
-
-If you are flashing a Raspberry Pi using the Raspberry Pi Imager, flash a 64-bit image to your SD card and **customize at least the hostname** when prompted by the Raspberry Pi Imager.
-
-When you customize the hostname or other settings, the Raspberry Pi Imager creates `firstrun.sh` which is required to set up provisioning.
-
-{{% /tab %}}
-{{% tab name="Other" %}}
-
-See [`viam-server` Platform requirements](/operate/install/setup/#prerequisite-install-operating-system) and [`viam-micro-server` hardware requirements](/operate/install/setup-micro/#supported-microcontrollers).
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{< alert title="Support Notice" color="note" >}}
-
-Provisioning is supported and tested on Ubuntu 22.04, Debian 11 (Bullseye), and 12 (Bookworm) but should work on most distros using NetworkManager v1.30 (or newer) as well.
-For Bullseye, the installation of `viam-agent` changes the network configuration to use NetworkManager.
-
-{{< /alert >}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Mount the SD card**
-
-Still using the computer used for flashing the SD card, eject and reinsert the card to make sure it's mounted with the newly written operating system.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Download the preinstall script**
-
-Run the following commands to download the preinstall script and make the script executable:
-
-{{< tabs >}}
-{{% tab name="wget" %}}
-
-```sh {class="command-line" data-prompt="$"}
-wget https://storage.googleapis.com/packages.viam.com/apps/viam-agent/preinstall.sh
-chmod 755 preinstall.sh
-```
-
-{{% /tab %}}
-{{% tab name="curl" %}}
-
-```sh {class="command-line" data-prompt="$"}
-curl -O https://storage.googleapis.com/packages.viam.com/apps/viam-agent/preinstall.sh
-chmod 755 preinstall.sh
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{< alert title="Support notice" color="note" >}}
-Please note this script works only under POSIX (macOS and Linux) at the moment.
-{{< /alert >}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Run the preinstall script**
-
-Run the preinstall script.
-It will attempt to auto-detect a mounted root filesystem (or for Raspberry Pi, bootfs) and also automatically determine the architecture.
-
-```sh {class="command-line" data-prompt="$"}
-sudo ./preinstall.sh
-```
-
-Follow the instructions.
-If you created a <FILE>viam-defaults.json</FILE> file or a <FILE>viam.json</FILE> file, specify their locations when prompted.
-
-{{% expand "Optional environment variables for the preinstall script" %}}
-
-<!-- prettier-ignore -->
-| Argument | Description |
-| -------- | ----------- |
-| `VIAM_JSON_PATH` | The path to the machine cloud credentials file (<FILE>viam.json</FILE>) to be copied to the machine. The script will also prompt you for this file if not provided. |
-| `DEFAULTS_PATH` | The path to the <FILE>viam-defaults.json</FILE> file. The script will also prompt you for this file if not provided. |
-| `VIAM_AGENT_PATH` | The path to a beta or local build of `viam-agent`. Used for testing. |
-
-{{% /expand%}}
-
-<br>
-Troubleshooting:
-
-{{% expand "Using a Raspberry Pi?" %}}
-
-{{< alert title="Important: Required customization" color="note" >}}
-
-You **must customize at least the hostname** when prompted by the Raspberry Pi Imager.
-
-{{< imgproc alt="Raspberry Pi Imager window showing gear-shaped settings icon is selected." src="/installation/rpi-setup/advanced-options-yes.png" resize="800x" declaredimensions=true class="shadow" >}}
-
-When you customize the hostname or other settings, the Raspberry Pi Imager creates `firstrun.sh` which is required to set up provisioning.
-
-If you do not customize anything, `firstrun.sh` is not present on the device and the `preinstall.sh` script fails.
-
-{{< /alert >}}
-
-For Raspberry Pis, the script will automatically perform the required next steps, it will:
-
-- create a tarball
-- update `firstrun.sh`.
-- extract the tarball to the mounted root filesystem
-
-```sh {class="command-line" data-prompt="$" data-output="2-40"}
-sudo ./preinstall.sh
-
-
-Found Raspberry Pi bootfs mounted at /Volumes/bootfs
-
-
-A Raspberry Pi boot partition has been found mounted at /Volumes/bootfs
-This script will modify firstrun.sh on that partition to install Viam agent.
-Continue pre-install? (y/n): y
-Path to custom viam-agent binary (leave empty to download default):
-Path to custom viam-defaults.json (leave empty to skip):
-Path to custom viam.json (leave empty to skip)
-Creating tarball for install.
-a opt
-a opt/viam
-a opt/viam/cache
-a opt/viam/bin
-a opt/viam/bin/viam-agent
-a opt/viam/bin/agent-provisioning
-a opt/viam/cache/viam-agent-provisioning-factory-aarch64
-a opt/viam/cache/viam-agent-factory-aarch64
-a etc
-a usr
-a usr/local
-a usr/local/lib
-a usr/local/lib/systemd
-a usr/local/lib/systemd/system
-a usr/local/lib/systemd/system/viam-agent.service
-a usr/local/lib/systemd/system/multi-user.target.wants
-a usr/local/lib/systemd/system/multi-user.target.wants/viam-agent.service
-
-
-Install complete! You can eject/unmount and boot the image now.
-```
-
-{{% /expand%}}
-
-{{% expand "Error: no valid image found at mountpoints (or manually provided path)" %}}
-
-If you get this error, you can run the script for the target system's architecture.
-It will create a tarball for the system's architecture which you will then need to manually extract.
-
-{{< tabs >}}
-{{% tab name="arm64" %}}
-
-```sh {class="command-line" data-prompt="$"}
-sudo ./preinstall.sh --aarch64
-```
-
-{{% /tab %}}
-{{% tab name="x86_64" %}}
-
-```sh {class="command-line" data-prompt="$"}
-sudo ./preinstall.sh --x86_64
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-To extract the tarball, run:
-
-```sh {class="command-line" data-prompt="$"}
-sudo tar -xJvpf $TARBALL -C <PATH_TO_ROOT_FS>
-```
-
-{{% /expand%}}
-
-{{% expand "Refusing to install to unknown/unset ROOTFS" %}}
-
-If your root file system cannot be detected, you can specify it directly:
-
-```sh {class="command-line" data-prompt="$"}
-sudo ./preinstall.sh /path/to/rootfs
-```
-
-{{% /expand %}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Set up more devices**
-
-Unless you provided a machine cloud credentials file (<FILE>viam.json</FILE>) to the machine, you can clone SD cards to speed up the provisioning process.
-
-{{% /tablestep %}}
-{{< /table >}}
-
-## Use a mobile app for provisioning
-
-You can create your own custom mobile provisioning app using the [Flutter SDK](https://flutter.viam.dev/viam_protos.provisioning.provisioning/ProvisioningServiceClient-class.html) or the [TypeScript SDK](https://github.com/viamrobotics/viam-typescript-sdk/blob/main/src/app/provisioning-client.ts).
-Alternatively you can use the [Viam mobile app](/manage/troubleshoot/teleoperate/default-interface/#viam-mobile-app).
-
-### Custom Flutter apps
-
-If you are building your own app to provide provisioning functionality you have three options for provisioning.
-You can support any number of these options.
-
-<!-- prettier-ignore -->
-| Provisioning method | Description | Package |
-| ------------------- | ----------- | ------- |
-| **Bluetooth with WiFi** | Ask the user to connect to the machine over Bluetooth. The user then provides network credentials for an internet-connected WiFi network, through which machine setup can then occur. Recommended, if available. | [Example](https://github.com/viamrobotics/viam_flutter_provisioning/) |
-| **WiFi** | Ask the user to connect to the machine's temporary WiFi hotspot. The user then provides network credentials for an internet-connected WiFi network, through which machine setup can then occur. Slower than Bluetooth with WiFi but faster than Bluetooth tethering. | [Example](https://github.com/viamrobotics/viam_flutter_hotspot_provisioning_widget) |
- | **Bluetooth tethering** | Ask the user to connect to the machine over Bluetooth. The user shares their mobile device's internet with the machine over Bluetooth. Slowest provisioning method. | [Example](https://github.com/viamrobotics/viam_flutter_bluetooth_provisioning_widget/) |
-
-{{< alert title="Tip" color="tip" >}}
-If you are not using Flutter or TypeScript and would like to use provisioning, please [contact us](mailto:support@viam.com).
-{{< /alert >}}
-
-### The Viam mobile app
-
-The Viam mobile app allows end users to create a new machine in the app, and `viam-agent` will then install `viam-server` and run it with the configuration provided by the `fragment_id` in the defaults file.
-If you choose to use the Viam mobile app, you must provide a {{< glossary_tooltip term_id="fragment" text="fragment" >}} for provisioning.
-
-{{< alert title="Caution" color="caution" >}}
-Currently, if you are using Bluetooth provisioning, you must leave `hotspot_password` as the default value `viamsetup`.
-{{< /alert >}}
-
-{{<video webm_src="/platform/provisioning-demo.webm" mp4_src="/platform/provisioning-demo.mp4" alt="Using the Viam mobile app to provision a new machine with viam-agent." poster="/platform/provisioning-demo.jpg" class="" max-width="400px" style="margin-left: 2rem">}}
-
-## Troubleshooting
-
-### Can I re-provision a machine that was already provisioned?
-
-You cannot re-run the `preinstall.sh` script.
-Once a device is set up for provisioning and has a <FILE>viam-provisioning.json</FILE> file on it, it will attempt to provision the machine when it comes online.
-If you have not yet connected the device to a network and setup has not completed, you can still make changes to the <FILE>viam-provisioning.json</FILE> file on the device.
-
-Once a machine has completed the provisioning flow, you cannot re-run the final setup steps without first manually removing the machine cloud credentials file (<FILE>/etc/viam.json</FILE>).
-
-### Device not detecting networks
-
-Some systems can't scan for WiFi networks while in hotspot mode, meaning they won't automatically detect networks coming online or into range until the `retry_connection_timeout_minutes` expires.
-The `retry_connection_timeout_minutes` causes your device to exit hotspot mode, at which point your device will be able to detect newly available networks.
-If your device does not connect to your network, adjust the `retry_connection_timeout_minutes` value in the defaults file.
-
-### Device not connecting or showing as offline
-
-Check if other devices on the network can connect to the internet without problems.
-If other devices are fine, try restarting your device and [check for other logs](/manage/troubleshoot/troubleshoot/#check-logs).
-
-### Test GRPC components of the provisioning service
-
-If you need to test the GRPC components of the provisioning service, there is a CLI client available.
-Get the code from the [`agent` repo](https://github.com/viamrobotics/agent/tree/main/cmd/provisioning-client) and run `go run ./cmd/provisioning-client/` for info.
diff --git a/docs/manage/fleet/reuse-configuration.md b/docs/manage/fleet/reuse-configuration.md
deleted file mode 100644
index 0cc2aa02cb..0000000000
--- a/docs/manage/fleet/reuse-configuration.md
+++ /dev/null
@@ -1,566 +0,0 @@
----
-title: "Reuse machine configuration on many machines"
-linkTitle: "Reuse machine configuration"
-weight: 20
-type: "docs"
-tags: ["data management", "data", "services"]
-images: ["/how-tos/one-to-many/new-fragment.png"]
-description: "Reuse the machine configuration from one machine for multiple machines."
-aliases:
-  - /use-cases/one-to-many/
-  - /how-tos/one-to-many/
-  - /fleet/fragments/
-  - /fleet/configure-a-fleet/
-languages: []
-viamresources: []
-platformarea: ["fleet"]
-level: "Beginner"
-date: "2025-02-07"
-# updated: ""  # When the tutorial was last entirely checked
-cost: "0"
----
-
-Fragments allow you to share configurations for one or more resources across multiple machines.
-
-For example, you may use the same networking credentials across rovers and robotic arms.
-Another example is a fleet of rovers that use a fragment to configure the motors, base component, and other components.
-
-## Create a fragment
-
-You must be an [organization owner](/manage/manage/rbac/) to create fragments for an organization.
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Go to the [FRAGMENTS page](https://app.viam.com/fragments) and create a fragment** in your {{< glossary_tooltip term_id="organization" text="organization" >}}.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Add and configure all the resources** you want to use on your machines.
-
-Fragments support all available resources except [triggers](/data-ai/reference/triggers-configuration/).
-You can also add other fragments inside a fragment.
-
-{{< alert title="Tip: Switch to JSON" color="tip" >}}
-If you already created a machine to test your configuration, you can **Switch to JSON**, copy its JSON configuration and paste it into the fragment.
-
-{{<imgproc src="/how-tos/one-to-many/raw-json.png" resize="700x" class="shadow fill" style="width: 400px" declaredimensions=true alt="JSON subtab of the CONFIGURE tab">}}
-{{< /alert >}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Add variable templates.**
-
-Fragments support variable substitution, allowing you to use the same fragment for multiple use cases even if there are small differences in configuration.
-
-When configuring resources, click the **{} JSON** button to switch to advanced view.
-Instead of a key value, add a variable in the form `"$variable": { "name": "placeholder" } }}`.
-For example:
-
-{{< tabs >}}
-{{% tab name="With Variable" %}}
-
-```json {class="line-numbers linkable-line-numbers" data-line="4-8"}
-{
-  "api": "rdk:component:camera",
-  "attributes": {
-    "preloaded_image": {
-      "$variable": {
-        "name": "placeholder"
-      }
-    }
-  },
-  "model": "rdk:builtin:image_file",
-  "name": "camera-placeholder"
-}
-```
-
-{{% /tab %}}
-{{% tab name="Without Variable" %}}
-
-```json {class="line-numbers linkable-line-numbers" data-line="4"}
-{
-  "api": "rdk:component:camera",
-  "attributes": {
-    "preloaded_image": "dog"
-  },
-  "model": "rdk:builtin:image_file",
-  "name": "camera-placeholder"
-}
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-
-**Set your privacy settings in the menu bar.**
-There are three options for this:
-
-- **Public:** Any user inside or outside of your organization will be able to view and use this fragment.
-- **Private:** No user outside of your organization will be able to view or use this fragment.
-- **Unlisted:** Any user inside or outside of your organization, with a direct link, will be able to view and use this fragment.
-
-Click **Save**.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Add a description**
-
-While not required, we recommend you add a description to your fragment from the fragment's page.
-
-{{% /tablestep %}}
-{{< /table >}}
-
-{{< alert title="Tip: Organize resources into folders" color="tip" >}}
-
-If you have many components and services in one fragment, you can add folders to your fragment and use them to organize the resources.
-
-{{< /alert >}}
-
-## Add the fragment to machines
-
-With your fragment created, you can add it to any number of machines.
-
-In the following steps, you will see how to add a fragment manually. If you are working in a factory setting and need to set up devices before they reach the end user, you can also use fragments to [provision](/manage/fleet/provision/setup/) your machines.
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**On your machine's CONFIGURE tab, click the + button and select Insert fragment.**
-
-Search for your fragment and add it.
-
-Click **Save** in the upper right corner of the screen.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Add variables** if the fragment uses variable templates.
-
-In the fragment's panel, find the **Variables** section and add them to the JSON object.
-For example:
-
-```json {class="line-numbers linkable-line-numbers" data-line="5"}
-{
-  "placeholder": "dog"
-}
-```
-
-Click **Save** in the upper right corner of the screen.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Repeat step 1 for each of the machines** that you want to configure in the same way.
-
-If some of your machines have slight differences, you can still add the fragment and then add fragment overwrites in the next section.
-
-{{% /tablestep %}}
-{{< /table >}}
-
-## Modify fragment settings on a machine
-
-If some of your machines are similar but not identical, you can use a fragment with all of them and then overwrite parts of the configuration to customize it **without modifying the upstream fragment**.
-
-For example, consider a fleet of rovers that all have the same motors, wheels, and base but a few rovers have a different camera than most.
-You can configure a fragment that has the motors, wheels, base on the rovers as well as the camera that is used on most rovers.
-For the rovers that have a different camera, you would then add the fragment and overwrite the camera configuration.
-
-If you or a collaborator later modify fields within the upstream fragment, your modifications will still apply.
-For example if you changed the default camera configuration in the fragment to be a different camera model, your modified rovers would still overwrite the camera model set by the fragment.
-
-{{< table >}}
-{{% tablestep start=1 %}}
-
-<!-- markdownlint-disable MD036 -->
-
-**On the CONFIGURE tab of the machine whose config you want to modify, make your edits** just as you would edit a non-fragment {{< glossary_tooltip term_id="resource" text="resource" >}}.
-
-{{< tabs >}}
-{{% tab name="Config Builder" %}}
-
-You can click the **{}** button to switch to advanced view and see the changes.
-
-Click **Save**.
-
-{{<gif webm_src="/how-tos/fragment-overwrite.webm" mp4_src="/how-tos/fragment-overwrite.mp4" alt="A motor config panel from a fragment being edited with different direction and pwm pin values." max-width="500px" class="" >}}
-
-{{% /tab %}}
-{{% tab name="JSON" %}}
-
-You can modify fragment fields in your machine's raw JSON config by using [update operators](https://www.mongodb.com/docs/manual/reference/operator/update/positional/#---update-).
-Viam supports all update operators except for `$setOnInsert`, `$`, `$[]`, and `$[<identifier>]`.
-
-To configure fragment overwrites manually instead of using the builder UI:
-
-1. Navigate to your machine's **CONFIGURE** tab.
-2. Switch to **JSON** mode.
-3. Add a top-level section called `"fragment_mods"` (alongside the other top-level sections like `"components"` and `"fragments"`):
-
-{{< tabs >}}
-{{% tab name="Template" %}}
-
-```json {class="line-numbers linkable-line-numbers"}
-  "fragment_mods": [
-    {
-      "fragment_id": "<YOUR FRAGMENT ID>",
-      "mods": [
-        {
-          <INSERT YOUR MODS HERE>
-        }
-      ]
-    }
-  ],
-```
-
-{{% /tab %}}
-{{% tab name="Full example" %}}
-This example assumes the fragment with ID `abcd7ef8-fa88-1234-b9a1-123z987e55aa` contains a motor configured with `"name": "motor1"`.
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "components": [],
-  "fragment_mods": [
-    {
-      "fragment_id": "abcd7ef8-fa88-1234-b9a1-123z987e55aa",
-      "mods": [
-        {
-          "$set": {
-            "components.motor1.attributes.max_rpm": 1818,
-            "components.motor1.attributes.pins.a": 30,
-            "components.motor1.attributes.board": "local"
-          }
-        },
-        {
-          "$unset": {
-            "components.motor1.attributes.pins.pwm": 0
-          }
-        }
-      ]
-    }
-  ],
-  "fragments": [
-    {
-      "_id": "abcd7ef8-fa88-1234-b9a1-123z987e55aa"
-    }
-  ]
-}
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-4. Edit the `fragment_id` value to match the ID of the fragment you want to modify, for example `"12345678-1a2b-9b8a-abcd987654321"`.
-5. Add any update operators you'd like to apply to the fragment to the `mods` section.
-   Click to view each example:
-
-{{< expand "Change the name and attributes of a component" >}}
-This example uses [`$set`](https://www.mongodb.com/docs/manual/reference/operator/update/set/#mongodb-update-up.-set) to make the following changes to the attributes of a motor named `motor1`:
-
-- Sets the `max_rpm` to `1818`.
-- Changes the name of `motor1` to `my_motor`.
-  Note that this does not affect the other mods; you still use `motor1` for them.
-- Sets the pin number for pin `a` to `30`.
-- Sets the name of the board associated with this motor to `local`.
-- Sets the `capture_frequency_hz` in the `service_config` for the first capture method in the `capture_methods` array.
-
-```json {class="line-numbers linkable-line-numbers"}
-"fragment_mods": [
- {
-   "fragment_id": "abcd7ef8-fa88-1234-b9a1-123z987e55aa",
-   "mods": [
-     {
-       "$set": {
-         "components.motor1.attributes.max_rpm": 1818,
-         "components.motor1.name": "my_motor",
-         "components.motor1.attributes.pins.a": 30,
-         "components.motor1.attributes.board": "local",
-         "components.motor1.service_configs.0.attributes.capture_methods.0.capture_frequency_hz": 0.25
-        }
-     }
-   ]
- }
-],
-```
-
-{{< /expand >}}
-{{< expand "Remove an attribute" >}}
-This example uses [`$unset`](https://www.mongodb.com/docs/manual/reference/operator/update/unset/#mongodb-update-up.-unset) to remove the pin number set for the `pwm` pin, so the motor no longer has a PWM pin set.
-In other words, it deletes the `pwm` pin field.
-
-```json {class="line-numbers linkable-line-numbers"}
-"fragment_mods": [
-  {
-    "fragment_id": "abcd7ef8-fa88-1234-b9a1-123z987e55aa",
-    "mods": [
-      {
-       "$unset": {
-         "components.motor1.attributes.pins.pwm": 0
-       }
-      }
-    ]
-  }
-],
-```
-
-{{< /expand >}}
-{{< expand "Modify dependencies" >}}
-This example uses [`$set`](https://www.mongodb.com/docs/manual/reference/operator/update/set/#mongodb-update-up.-set) to assign a new list of dependencies to a component named `rover_base2`.
-
-```json {class="line-numbers linkable-line-numbers"}
-"fragment_mods": [
-  {
-    "fragment_id": "abcd7ef8-fa88-1234-b9a1-123z987e55aa",
-    "mods": [
-      {
-       "$set": {
-         "components.rover_base2.attributes.depends_on": ["local", "motor1"]
-       }
-      }
-    ]
-  }
-],
-```
-
-{{< /expand >}}
-{{< expand "Change motor pins from A and B to PWM and DIR" >}}
-This example uses [`$rename`](https://www.mongodb.com/docs/manual/reference/operator/update/rename/) to make the following changes to the attributes of a motor named `motor1` in the fragment:
-
-- Retrieves the pin number for pin `a` and assigns that value to the PWM pin.
-  Deletes the `pins.a` field.
-- Retrieves the pin number for pin `b` and assigns that value to the DIR pin.
-  Deletes the `pins.b` field.
-
-_`$rename` is for changing an attribute's key, not its value.
-If you want to change the `name` of a component (for example, `motor1`), use `$set`, as shown in the change the name of a component example._
-
-```json {class="line-numbers linkable-line-numbers"}
-"fragment_mods": [
- {
-   "fragment_id": "abcd7ef8-fa88-1234-b9a1-123z987e55aa",
-   "mods": [
-     {
-       "$rename": {
-         "components.motor1.attributes.pins.a": "components.motor1.attributes.pins.pwm",
-         "components.motor1.attributes.pins.b": "components.motor1.attributes.pins.dir"
-       }
-     }
-   ]
- }
-],
-```
-
-{{< /expand >}}
-{{< expand "Change a camera path" >}}
-This example uses [`$set`](https://www.mongodb.com/docs/manual/reference/operator/update/set/#mongodb-update-up.-set) to change the video path for a camera named `camera-one` in the fragment:
-
-```json {class="line-numbers linkable-line-numbers"}
-"fragment_mods": [
-  {
-    "fragment_id": "abcd7ef8-fa88-1234-b9a1-123z987e55aa",
-    "mods": [
-      {
-        "$set": {
-          "components.camera-one.attributes.video_path": "0x11100004a12345"
-        }
-      }
-    ]
-  }
-],
-```
-
-{{< /expand >}}
-{{< expand "Modify data sync settings" >}}
-This example uses [`$set`](https://www.mongodb.com/docs/manual/reference/operator/update/set/#mongodb-update-up.-set) to change the sync interval for a [data management service](/data-ai/capture-data/capture-sync/) named `data-management` in the fragment:
-
-```json {class="line-numbers linkable-line-numbers"}
-"fragment_mods": [
-  {
-    "fragment_id": "abcd7ef8-fa88-1234-b9a1-123z987e55aa",
-    "mods": [
-      {
-        "$set": {
-          "services.data-management.attributes.sync_interval_mins": "0.5"
-        }
-      }
-    ]
-  }
-],
-```
-
-{{< /expand >}}
-{{< expand "Set a module version" >}}
-This example uses [`$set`](https://www.mongodb.com/docs/manual/reference/operator/update/set/#mongodb-update-up.-set) to configure [version update settings for a module](/operate/modules/advanced/module-configuration/#module-configuration-details) named `custom-sensor` from the fragment:
-
-```json {class="line-numbers linkable-line-numbers"}
-"fragment_mods": [
-  {
-    "fragment_id": "abcd7ef8-fa88-1234-b9a1-123z987e55aa",
-    "mods": [
-      {
-        "$set": {
-          "modules.custom-sensor.version": "1.8.0"
-        }
-      }
-    ]
-  }
-],
-```
-
-The `version` field supports the following values:
-
-- To update with new minor releases of the same major release branch, use `"^<major version number>"`, for example `"^1"`
-- To update with new patch releases of the same minor release branch, use `"~<minor version number>"`, for example `"~1.8"`
-- To always update with the latest release, use `"latest"`
-- To pin to a specific release, use `"<version number>"`, for example `"1.8.3"`
-
-{{< /expand >}}
-{{< expand "Set a package version" >}}
-This example uses [`$set`](https://www.mongodb.com/docs/manual/reference/operator/update/set/#mongodb-update-up.-set) to configure [version update settings for a package](/data-ai/ai/deploy/#deploy-a-specific-version-of-an-ml-model) named `package_name` from the fragment:
-
-```json {class="line-numbers linkable-line-numbers"}
-"fragment_mods": [
-  {
-    "fragment_id": "abcd7ef8-fa88-1234-b9a1-123z987e55aa",
-    "mods": [
-      {
-        "$set": {
-          "packages.package_name.version": "latest"
-        }
-      }
-    ]
-  }
-],
-```
-
-The `version` field supports the following values:
-
-- To update with new minor releases of the same major release branch, use `"^<major version number>"`, for example `"^1"`
-- To update with new patch releases of the same minor release branch, use `"~<minor version number>"`, for example `"~1.8"`
-- To always update with the latest release, use `"latest"`
-- To pin to a specific release, use `"<version number>"`, for example `"1.8.3"`
-
-{{< /expand >}}
-{{< expand "Change the log level of a resource" >}}
-This example uses [`$set`](https://www.mongodb.com/docs/manual/reference/operator/update/set/#mongodb-update-up.-set) to modify [the log level](/operate/reference/viam-server/#logging) from the fragment for a resource:
-
-```json {class="line-numbers linkable-line-numbers"}
-"fragment_mods": [
-  {
-    "fragment_id": "abcd7ef8-fa88-1234-b9a1-123z987e55aa",
-    "mods": [
-      {
-        "$set": {
-          "components.control.log_configuration.level": "debug"
-        }
-      }
-    ]
-  }
-],
-```
-
-If the resource comes from a module, you must instead set the `log_level` attribute on the module itself:
-
-```json {class="line-numbers linkable-line-numbers"}
-"fragment_mods": [
-  {
-    "fragment_id": "abcd7ef8-fa88-1234-b9a1-123z987e55aa",
-    "mods": [
-      {
-        "$set": {
-          "modules.my-control-logic.log_level":  "debug"
-        }
-      }
-    ]
-  }
-],
-```
-
-{{< /expand >}}
-
-6. Click **Save** in the upper right corner of the page to save your new configuration.
-7. To check that your mods are working, view your machine's debug configuration.
-   In **Builder** mode on the **CONFIGURE** tab, select the **...** (Actions) menu to the right of your main part's name in the left-hand panel and click the **View debug configuration** option to view the full configuration file.
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**After configuring fragment overwrites, check your machine's [**LOGS** tab](/manage/troubleshoot/troubleshoot/#check-logs).**
-
-If there are problems with overwrites to the fragment, the overwrites will not be partially applied and the configuration changes will not take effect until the configuration is fixed.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-{{<imgproc src="/how-tos/one-to-many/reset.png" class="shadow fill alignleft" resize="500x" style="width: 250px"  declaredimensions=true alt="Reset to fragment">}}
-**(Optional) Revert fragment modifications.**
-
-If you need to restore the original fragment, click the **...** in the upper right corner of the card you modified, and click **Revert changes**.
-Now, the fragment will be identical to the upstream fragment.
-
-{{% /tablestep %}}
-{{< /table >}}
-
-## Update a fragment
-
-You and your collaborators can edit a fragment at any time.
-Viam automatically creates new versions of your fragment as you make changes.
-Fragments can only be deleted if no machines are using them.
-
-If you've already deployed the fragment to one or more machines, Viam updates the configuration on each deployed machine that uses that fragment.
-You can see the number of machines using your fragment from the [fragments page](https://app.viam.com/fragments).
-
-{{< alert title="Test updates first" color="caution" >}}
-We recommend testing updates to fragments on a small number of machines before deploying them to a larger fleet.
-For recommendations on updating software on deployed machines, see [Update software](/manage/software/update-software/).
-{{< /alert >}}
-
-### Create fragment tags
-
-You can create tags to differentiate between versions of your fragment.
-For example, you may want to create a tag for `stable` and `beta`.
-
-1. Go to the [FRAGMENTS tab](https://app.viam.com/fragments) and click on a fragment.
-1. Click on **Versions** in the menu bar.
-1. Click **Add Tag**.
-1. Select a version to pin the tag to.
-   You can change this later.
-1. Type in a name for your tag.
-
-### Pin to a fragment version or tag
-
-When you add a fragment to a machine you can choose to pin the fragment version to use:
-
-- the **latest version**: Always update to the latest version of this fragment as soon as a new version becomes available.
-  This is the default.
-- a **specific version**: Do not update to any other version.
-- a **tag**: Always use the version of this fragment with the selected tag.
-  For example `stable` or `beta`.
-
-### Add fragment prefix
-
-Resource names must be unique on each machine.
-To avoid name collisions with resources you add using a fragment, you can set a `prefix`.
-If set, all resource added through the fragment have the prefix.
-For example, a component with the name `arm-1` configured in a fragment with the configuration `"prefix": "test123"` returns the name `test123-arm-1`.
-
-On your machine's **CONFIGURE** tab, switch to **JSON** mode and add a `prefix` to the fragment object:
-
-```json {class="line-numbers linkable-line-numbers" data-line="6-9"}
-{
-  "components": [ ... ],
-  "services": [ ... ],
-  "modules": [ ... ],
-  "fragments": [
-    {
-      "id": "0a44e14b-ec43-40e7-9641-1f593072e281",
-      "prefix": "hello-world-mlresources"
-    }
-  ]
-}
-```
-
-## Example fragments
-
-For an example of a fragment that configures multiple components and services, see the [Viam Rover fragment](https://app.viam.com/fragment?id=3e8e0e1c-f515-4eac-8307-b6c9de7cfb84).
-
-For an example of creating a fragment and using it to configure a fleet of machines, see the [air quality fleet tutorial](/tutorials/control/air-quality-fleet/).
diff --git a/docs/manage/fleet/system-settings.md b/docs/manage/fleet/system-settings.md
deleted file mode 100644
index a55a4bed76..0000000000
--- a/docs/manage/fleet/system-settings.md
+++ /dev/null
@@ -1,204 +0,0 @@
----
-linkTitle: "Configure machine settings"
-title: "Configure machine operating system settings"
-weight: 50
-layout: "docs"
-type: "docs"
-description: "Configure network settings, operating system package updates and logging defaults."
----
-
-The `viam-agent` configuration allows you to configure:
-
-- [settings for package updates for the host operating system](#manage-os-package-updates)
-- [networks a machine can connect to](#configure-networks)
-- [parameters for operating system logging](#configure-operating-system-logging)
-
-## Manage OS package updates
-
-By default, the configuration in <FILE>/etc/apt/apt.conf.d/</FILE> determines the behavior for updating operating system packages.
-To manage OS package updates using Viam, add a `"system_configuration"` object to the `"agent"` object in the machine's JSON configuration, if it doesn't already exist.
-Then, add the `"os_auto_upgrade_type"` field in its attributes:
-
-```json
-"agent": {
-    "system_configuration": {
-        "os_auto_upgrade_type": "security"
-    }
-}
-```
-
-When the `os_auto_upgrade_type` is set, `viam-agent` will install the `unattended-upgrades` package and replace `20auto-upgrades` and `50unattended-upgrades` in <FILE>/etc/apt/apt.conf.d/</FILE> with an Origins-Pattern list generated automatically from configured repositories on the system.
-Custom repos installed on the system at the time the setting is enabled will be included.
-
-You can set automatic upgrades to the following options:
-
-- `"all"`: automatic upgrades are performed for all packages
-- `"security"`: automatic upgrades for only packages containing `"security"` in their codename (for example `bookworm-security`)
-- `""`: disable automatic upgrades
-
-For complete reference information, see [viam-agent](/manage/reference/viam-agent/#system-configuration).
-
-## Configure networks
-
-By default, your machine can connect to networks added at the operating system level, for example, directly in NetworkManager.
-
-For an already-online device, you can add new WiFi networks by updating the `"agent"` value in the machine's JSON configuration.
-This is primarily useful for a machine that moves between different networks, so the machine can automatically connect when moved between locations.
-
-To add networks, add or update the `additional_networks` field to the `agent` object and set `"turn_on_hotspot_if_wifi_has_no_internet": true`.
-
-{{< alert title="Note" color="note" >}}
-If you are adding networks to a machine’s configuration, the machine will need to be connected to the internet to retrieve the configuration information containing the network credentials before it can use them.
-{{< /alert >}}
-
-The following configuration defines the connection information and credentials for two WiFi networks named `fallbackNetOne` and `fallbackNetTwo`.
-`viam-agent` will try to connect to `fallbackNetOne` first, since its priority is highest.
-If the `fallbackNetOne` is not available or the machine can connect but internet is not available, `viam-agent` will then attempt to connect to `fallbackNetTwo`.
-
-```json
-"agent": {
-    "additional_networks": {
-        "network_name_1": {
-            "type": "wifi",
-            "ssid": "fallbackNetOne",
-            "psk": "myFirstPassword",
-            "priority": 30
-        },
-        "network_name_2": {
-            "type": "wifi",
-            "ssid": "fallbackNetTwo",
-            "psk": "mySecondPassword",
-            "priority": 10
-        }
-    }
-}
-```
-
-Configuring multiple WiFi networks for the Micro-RDK is similar but the only supported attributes are `priority`, `psk`, and `ssid`.
-
-For complete reference information, see [viam-agent](/manage/reference/viam-agent/#network_configuration).
-
-## Configure network settings for tunneling
-
-To tunnel to a machine part you must first explicitly enumerate ports to which you are allowed to tunnel in your machine's JSON config.
-The following configuration allows you to tunnel to ports `5900` and `5901`:
-
-```json {class="line-numbers linkable-line-numbers"}
-"network": {
-  "traffic_tunnel_endpoints": [
-    {
-      "port": 5900
-    },
-    {
-      "port": 5901,
-      "connection_timeout": "5s"
-    }
-  ]
-}
-```
-
-Then you can use the [`viam machine part tunnel`](https://docs.viam.com/dev/tools/cli/#machines-alias-robots-and-machine) command:
-
-```sh {class="command-line" data-prompt="$" data-output="2-10"}
-viam machine part tunnel --part=123 --destination-port=1111 --local-port 5900
-```
-
-## Configure network settings to disable TLS
-
-To configure your machine to disable TLS on the hosted HTTP server, you must specify `"no_tls": true` in your machine's configuration:
-
-```json {class="line-numbers linkable-line-numbers"}
-"network": {
-  "no_tls": true
-}
-```
-
-## Configure bind address and port
-
-If you are running `viam-server` on a different port that `8080`, set the `bind_address` in your machine settings:
-
-```json {class="line-numbers linkable-line-numbers"}
-"network": {
-  "bind_address": "localhost:8081"
-}
-```
-
-## Configure operating system logging
-
-By default, the maximum disk space `journald` will use for `viam-server` logs is 512MB.
-
-To adjust these settings update the `"agent"` value in the machine's JSON configuration.
-
-For complete reference information, see [viam-agent](/manage/reference/viam-agent/#system-configuration) and the [`journald` docs](https://www.freedesktop.org/software/systemd/man/latest/journald.conf.html#SystemMaxUse=).
-
-### Set the maximum disk space
-
-To set the maximum disk space `journald` will use to persist logs, add the `logging_journald_system_max_use_megabytes` field to the `system_configuration` object.
-You may need to add the `system_configuration` object to the `agent` object if it doesn't already exist.
-
-The configured values will take precedence over operating system defaults.
-
-```json
-"agent": {
-    "system_configuration": {
-        "os_auto_upgrade_type": "security",
-        "logging_journald_system_max_use_megabytes": 512
-    }
-}
-```
-
-### Set the runtime space limit space
-
-To set the temporary space limit for logs, add the `logging_journald_runtime_max_use_megabytes` field to the `system_configuration` object.
-You may need to add the `system_configuration` object to the `agent` object if it doesn't already exist.
-
-The configured values will take precedence over operating system defaults.
-
-```json
-"agent": {
-    "system_configuration": {
-        "os_auto_upgrade_type": "security",
-        "logging_journald_runtime_max_use_megabytes": 512
-    }
-}
-```
-
-### Forward system logs to the cloud
-
-You can configure `viam-agent` to forward system logs from journald to the cloud for additional diagnostics information.
-This allows you to view system logs from your machine alongside Viam's own logs.
-
-To enable system log forwarding, add the `forward_system_logs` field to the `system_configuration` object. This field accepts a comma-separated list of service identifiers to include or exclude from forwarding.
-
-```json
-"agent": {
-    "system_configuration": {
-        "forward_system_logs": "kernel,NetworkManager,tailscaled"
-    }
-}
-```
-
-{{< alert title="Note" color="note" >}}
-System log forwarding requires journald to be available on the system. This feature is only supported on Linux systems.
-{{< /alert >}}
-
-#### Filtering options
-
-You can control which system logs are forwarded using the following syntax:
-
-- `"all"`: Forward all system logs (in addition to`viam-agent` and `viam-server` logs which are sent directly to the cloud and always visible)
-- Comma-separated list of service identifiers: Forward only logs from the specified services
-- Prefix a service with `-` to exclude it: For example, `"all,-gdm,-tailscaled"` forwards all logs except those from `gdm` and `tailscaled`
-
-Examples:
-
-```json
-// Forward only kernel, NetworkManager, and tailscaled logs
-"forward_system_logs": "kernel,NetworkManager,tailscaled"
-
-// Forward all system logs except gdm and tailscaled
-"forward_system_logs": "all,-gdm,-tailscaled"
-
-// Disable system log forwarding (default)
-"forward_system_logs": ""
-```
diff --git a/docs/manage/reference/_index.md b/docs/manage/reference/_index.md
deleted file mode 100644
index ab25c4c8cf..0000000000
--- a/docs/manage/reference/_index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-linkTitle: "Reference"
-title: "Reference"
-weight: 300
-layout: "empty"
-type: "docs"
-empty_node: true
-header_only: true
-canonical: "/manage/reference/viam-agent/"
----
diff --git a/docs/manage/reference/accounts.md b/docs/manage/reference/accounts.md
deleted file mode 100644
index 57ab1f529d..0000000000
--- a/docs/manage/reference/accounts.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-linkTitle: "Account management"
-title: "Account management"
-weight: 900
-layout: "docs"
-type: "docs"
-no_list: true
-description: "Log in and out of your Viam account."
-aliases:
-  - /fleet/account/
-  - /cloud/account/
----
-
-Viam has a [web UI](https://app.viam.com/) for managing and building machines.
-To use Viam, you need a free account.
-Accounts can have [different permissions](/manage/manage/rbac/) to different groups of machines.
-
-## Create account and log in
-
-To get started, you must log in with a Viam account.
-Viam supports sign-up using Google, GitHub, Apple, and email.
-
-Navigate to [the main page](https://app.viam.com/).
-If you haven't created an account yet, click **Sign Up** to create a new account using your preferred single sign-on method or your email address and a password.
-If you already have an account, click **Log In** to log in using your single sign-on credentials or your email address and password.
-
-If you forget your password to the app, click **Forgot password** and enter your email address to obtain instructions to reset your password.
-
-{{< alert title="Info" color="info" >}}
-Accounts created from separate authentication sources are unique to each other.
-{{< /alert >}}
-
-Once you have logged in, get started by [creating a machine](/operate/install/setup/).
-
-{{% hiddencontent %}}
-You cannot change email address within the app.
-If you must change your email address, please reach out to Viam Support at [contact@viam.com](mailto:contact@viam.com).
-{{% /hiddencontent %}}
-
-## Sign out
-
-To log out of [Viam](https://app.viam.com/), click on your profile icon in the upper right corner of your browser window.
-Click **Sign out** to sign out of accessing all organizations, locations, and machines your credentials manage.
-
-## Delete account
-
-To delete your account, you can contact Viam Support at [contact@viam.com](mailto:contact@viam.com).
-
-Some important things to note:
-
-- Account termination may result in the destruction of any associated content
-- If you delete your machine, location, organization, or account by mistake, contact [contact@viam.com](mailto:contact@viam.com) immediately - they will try to help but cannot guarantee recovery or restoration.
diff --git a/docs/manage/reference/architecture.md b/docs/manage/reference/architecture.md
deleted file mode 100644
index 51d064e771..0000000000
--- a/docs/manage/reference/architecture.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-linkTitle: "Architecture of a machine"
-title: "Viam architecture"
-weight: 65
-type: "docs"
-layout: "empty"
-canonical: "/operate/reference/architecture/"
----
diff --git a/docs/manage/reference/billing-client.md b/docs/manage/reference/billing-client.md
deleted file mode 100644
index 2a82cc7847..0000000000
--- a/docs/manage/reference/billing-client.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: "Retrieve billing data with Viam's billing client API"
-linkTitle: "Billing client API"
-weight: 800
-type: "docs"
-layout: "empty"
-canonical: "/dev/reference/apis/billing-client/"
----
diff --git a/docs/manage/reference/billing.md b/docs/manage/reference/billing.md
deleted file mode 100644
index 599d9d9061..0000000000
--- a/docs/manage/reference/billing.md
+++ /dev/null
@@ -1,97 +0,0 @@
----
-title: "Payment and billing"
-linkTitle: "Billing"
-weight: 50
-type: "docs"
-description: "An overview of the Payments & Billing page."
-tags: ["fleet management", "cloud", "app"]
-aliases:
-  - /fleet/billing/
-  - /billing/
-date: "2024-03-13"
-no_list: true
-# updated: ""  # When the content was last entirely checked
----
-
-{{<imgproc src="/billing-menu.png" resize="400x" declaredimensions=true alt="Payment and billing menu item" class="alignright shadow">}}
-
-To access the **Payment and billing** page, click on the organization name in the top right of the navigation bar and then click on **Payment and billing**.
-You must be an [organization owner](/manage/manage/rbac/) to see this page.
-
-The **Payment and billing** page shows you:
-
-- your usage for the current billing period
-- the date for your next invoice
-- the payment method on the account
-- a cost breakdown for cloud storage, cloud data upload, cloud data egress, remote control, and standard compute costs
-- all your invoices (monthly or annual depending on your billing configuration)
-
-{{< alert title="Note" color="note" >}}
-
-For Pricing information, please see [pricing & billing explained](https://www.viam.com/product/pricing).
-
-{{< /alert >}}
-
-![Payment and billing overview](/billing-overview.png)
-
-## Add a payment method
-
-1. Click on the organization name in the top right of the navigation bar and then click on **Payment and billing**.
-   You must be an [organization owner](https://docs.viam.com/manage/manage/rbac/) to see this page.
-1. Under **Payment method**, click **Add payment method**.
-1. Fill in the form with your credit card details or a US bank account.
-
-## Change payment method
-
-To replace the credit card details or bank account details used for an organization, you must have access to the organization's billing settings.
-Follow these steps:
-
-1. Click on the organization name in the top right of the navigation bar and then click on **Payment and billing**.
-   You must be an [organization owner](https://docs.viam.com/manage/manage/rbac/) to see this page.
-1. Under **Payment method**, click **Remove payment method**.
-1. Confirm the removal when prompted.
-1. Under **Payment method**, click **Add payment method**.
-1. Fill in the form with your credit card details or a US bank account.
-
-{{< alert title="Caution" color="caution" >}}
-Ensure the new payment method is added immediately after removing the old one to avoid any service interruptions.
-Organizations without valid payment methods may experience limitations on their services.
-{{< /alert >}}
-
-## Download an invoice
-
-You can view all your invoices for your organization:
-
-1. Click on the organization name in the top right of the navigation bar and then click on **Payment and billing**.
-   You must be an [organization owner](https://docs.viam.com/manage/manage/rbac/) to see this page.
-1. Find the **Invoices** section of the **Payment & Billing** page.
-1. Click on **Download (PDF)** next to the relevant billing period.
-
-{{< alert title="Note" color="note" >}}
-Invoices may be generated monthly or annually depending on your billing configuration. Organizations using annual billing will receive invoices every 12 months instead of monthly.
-{{< /alert >}}
-
-## Set billing alerts
-
-You can set alerts to receive an email notification when your monthly spend exceeds a certain threshold:
-
-1. Click on the organization name in the top right of the navigation bar and then click on **Payment and billing**.
-   You must be an [organization owner](https://docs.viam.com/manage/manage/rbac/) to see this page.
-1. Scroll to the bottom of the **Payment & Billing** page.
-1. Click **Set amount** and enter a monthly threshold amount.
-
-## Receive billing emails at a different email or and email alias
-
-You cannot currently specify an additional email address to receive billing emails at.
-You can, however, create an account for the email address and make it part of your organization.
-
-## Help
-
-For questions about your bill, email [billing@viam.com](mailto:billing@viam.com).
-You can expect a response within 1–3 business days.
-
-## Access billing information programmatically
-
-The [billing client API](/dev/reference/apis/billing-client/) supports the following methods to retrieve billing information from [Viam](https://app.viam.com):
-
-{{< readfile "/static/include/services/apis/billing-client.md" >}}
diff --git a/docs/manage/reference/fleet.md b/docs/manage/reference/fleet.md
deleted file mode 100644
index 5af5eae50f..0000000000
--- a/docs/manage/reference/fleet.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: "Manage your fleet with Viam's fleet management API"
-linkTitle: "Fleet management API"
-weight: 750
-type: "docs"
-layout: "empty"
-canonical: "/dev/reference/apis/fleet/"
----
diff --git a/docs/manage/reference/glossary.md b/docs/manage/reference/glossary.md
deleted file mode 100644
index c1b9504bcd..0000000000
--- a/docs/manage/reference/glossary.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: "Glossary"
-linkTitle: "Glossary"
-weight: 999
-type: "docs"
-layout: "empty"
-canonical: "/dev/reference/glossary/"
----
diff --git a/docs/manage/reference/organize.md b/docs/manage/reference/organize.md
deleted file mode 100644
index 71d5559f59..0000000000
--- a/docs/manage/reference/organize.md
+++ /dev/null
@@ -1,128 +0,0 @@
----
-linkTitle: "Organize your machines"
-title: "Organize your machines"
-weight: 60
-layout: "docs"
-type: "docs"
-no_list: true
-description: "Organize and manage access to your fleet by grouping machines into organizations and locations."
-aliases:
-  - /how-tos/manage-fleet/
-  - /use-cases/manage-fleet/
-  - /cloud/machines/
-  - /fleet/robots/
-  - /manage/fleet/machines/
-  - /fleet/machines/
-  - /cloud/locations/
-  - /manage/fleet/locations/
-  - /fleet/locations/
-  - /cloud/organizations/
-  - /manage/fleet/organizations/
-  - /fleet/organizations/
----
-
-Before you start connecting your devices to Viam, you need to decide how you want to group your machines.
-
-On Viam, {{< glossary_tooltip term_id="machine" text="machines" >}} are grouped into _locations_, and locations are grouped into _organizations_:
-
-- Each location can represent either a physical location or some other conceptual grouping like "Production" and "Testing".
-- An organization is the highest level grouping, and often contains all the locations (and machines) of an entire company.
-
-These groupings allow you to manage permissions; you can grant a user access to an individual machine, to all the machines in a location, or to everything in an entire organization.
-You choose how to group your machines.
-
-<p>
-{{<imgproc src="/fleet/fleet.svg" class="fill aligncenter" resize="800x" style="width: 600px" declaredimensions=true alt="Two locations within an organization">}}
-</p>
-
-## Create organization
-
-1. Log into [Viam](https://app.viam.com) in a web browser.
-1. Click the dropdown in the upper-right corner of the **FLEET** page and use the **+** button to create a new organization.
-1. Name the organization.
-1. From the **Data region** dropdown, choose the [geographic location](/manage/manage/data-regions/) where Viam should store your application data.
-1. Click **Create**.
-
-## Create location
-
-1. Click **FLEET** in the upper-left corner of the page and click **LOCATIONS**.
-   A new location called `First Location` is automatically generated for you.
-
-   Use the **...** menu to edit the location name to what it represents for your use case.
-
-1. Click **Save**.
-
-1. To create additional locations, click the **+ Add location** button on the **LOCATIONS** page.
-
-## Create sub-locations
-
-If needed, you can add further sub-locations to, for example, differentiate groups of machines within an office.
-
-To add a sub-location:
-
-1. Add a new location using the same **+ Add location** button.
-1. On the location's page, click the **...** menu and click **Move**.
-1. Choose a new parent for the location.
-   This can be the organization the location is in or another location.
-
-You can nest locations up to three levels deep.
-
-## Example
-
-If you'd like to look at an example, see [Monitor Air Quality with a Fleet of Sensors](/tutorials/control/air-quality-fleet/#organize-devices-for-third-party-usage).
-
-## Frequently asked questions
-
-### Can I move a machine to a different location?
-
-Yes, organization owners and location owners can move machines between locations within their organization.
-
-To move a machine:
-
-1. Navigate to your machine's page.
-1. Click the **...** button in the upper-right corner.
-1. Select **Move to a new location**.
-1. Choose the destination location from the organization tree.
-1. Confirm the move.
-
-{{< alert title="Important considerations" color="caution" >}}
-Moving a machine has several important implications:
-
-- **Machine address changes**: The machine's network address will change to `<machine-main-part-name>.<new-location-id>.viam.cloud`. You'll need to update any code that references the old address.
-- **Permission changes**: Access permissions will be updated. Users with access to the current location lose access, and users with access to the new location gain access to the machine.
-- **Data access**: Users in the new location cannot access historical data from when the machine was in the previous location.
-
-{{< /alert >}}
-
-**Requirements for moving machines:**
-
-- You must be an organization owner, or an owner of both the current and destination locations
-- The destination location must be within the same organization
-- No other machine in the destination location can have the same name
-
-### Can I move a location to a different organization?
-
-No, it is not possible to move a location to a different organization.
-
-You can share a location with another organization.
-However, machines will continue to use the primary organization as a reference point.
-This means any captured data is associated with the primary organization and the machines are only able to use private ML models and registry items from the primary owner.
-
-### Can I rename my organization after its creation?
-
-Yes, you can rename your organization if you are an organization owner.
-
-{{< alert title="Caution" color="caution" >}}
-If your organization owns modules or packages in the Viam Registry, the namespace for those modules and packages will be changed in the registry automatically.
-You will need to update any configurations that reference your modules using the old namespace.
-{{< /alert >}}
-
-1. Click the organization name in the upper-right corner of the **FLEET** page and click on **Settings and invites**.
-1. Find the **Details** section of the page.
-1. Change the organization name and click on the **Rename** button.
-
-### How do I delete an organization?
-
-1. Delete all the locations in your organization.
-1. Click the organization name in the upper-right corner of the **FLEET** page and click on **Settings and invites**.
-1. At the bottom of the page click **Delete organization**.
diff --git a/docs/manage/reference/robot.md b/docs/manage/reference/robot.md
deleted file mode 100644
index 7e1ee142fa..0000000000
--- a/docs/manage/reference/robot.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: "Manage machines with Viam's machine management API"
-linkTitle: "Machine management API"
-weight: 700
-type: "docs"
-layout: "empty"
-canonical: "/dev/reference/apis/robot/"
----
diff --git a/docs/manage/reference/viam-agent/_index.md b/docs/manage/reference/viam-agent/_index.md
deleted file mode 100644
index 808732d283..0000000000
--- a/docs/manage/reference/viam-agent/_index.md
+++ /dev/null
@@ -1,392 +0,0 @@
----
-title: "viam-agent"
-linkTitle: "viam-agent"
-weight: 20
-type: docs
-description: "The viam-agent is a self-updating service manager that maintains the lifecycle for Viam's system services, among them viam-server and provisioning."
-date: "2025-02-14"
-aliases:
-  - /configure/agent/
-# updated: ""  # When the content was last entirely checked
-# SMEs: James, Ale
----
-
-The [`viam-agent`](https://github.com/viamrobotics/agent) is a self-updating service manager that maintains the lifecycle for itself and `viam-server`.
-
-Among other things, `viam-agent`:
-
-- Installs, runs, and monitors `viam-server` or a custom build of `viam-server`.
-- Provides tooling for device provisioning and network management.
-- Provides automatic updates for `viam-server` and the agent itself.
-- Allows control of deployed software versions.
-- Provides various operating system settings.
-
-{{< alert title="Support notice" color="note" >}}
-Currently, `viam-agent` is only supported on Linux for amd64 (x86_64) and arm64 (aarch64) CPUs, MacOS for arm64 (M/silicon) CPUs, and Windows (native).
-{{< /alert >}}
-
-To provision machines using `viam-agent`, see [Provision Machines](/manage/fleet/provision/setup/).
-
-## Installation
-
-{{< table >}}
-{{% tablestep start=1 %}}
-Add a new machine.
-{{% /tablestep %}}
-{{% tablestep %}}
-Navigate to the machine's **CONFIGURE** tab.
-{{% /tablestep %}}
-{{% tablestep %}}
-Click **View setup instructions** on the alert to **Set up your machine part**:
-
-{{<imgproc src="/installation/setup.png" resize="400x" declaredimensions=true alt="Machine setup alert in a newly created machine" class="shadow imgzoom">}}
-{{% /tablestep %}}
-{{% tablestep %}}
-Follow the instructions to install `viam server` with `viam-agent`.
-Your machine must have `curl` available in order to install `viam-agent`.
-
-{{< tabs >}}
-{{% tab name="Linux/MacOS" %}}
-
-You can use `viam-agent` either with
-
-{{< tabs >}}
-{{% tab name="environment variables" %}}
-
-The command will be of the following form:
-
-```sh {class="command-line" data-prompt="$" data-output=""}
-sudo /bin/sh -c "VIAM_API_KEY_ID=<KEYID> VIAM_API_KEY=<KEY> VIAM_PART_ID=<PARTID>; $(curl -fsSL https://storage.googleapis.com/packages.viam.com/apps/viam-agent/install.sh)"
-```
-
-{{% /tab %}}
-{{% tab name="a machine credentials file" %}}
-
-```sh {class="command-line" data-prompt="$"}
-sudo /bin/sh -c "$(curl -fsSL https://storage.googleapis.com/packages.viam.com/apps/viam-agent/install.sh)"
-```
-
-The machine credentials file must be at <file>/etc/viam.json</file>.
-You can get the machine cloud credentials by clicking the copy icon next to **Machine cloud credentials** in the part status dropdown to the right of your machine's name on the top of the page.
-
-{{<imgproc src="configure/machine-part-info.png" resize="500x" declaredimensions=true alt="Machine part info dropdown" class="shadow">}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-On Linux, `viam-agent` will install itself as a systemd service named `viam-agent`. On MacOS, `viam-agent` will install itself as a launchd daemon named `system/com.viam.agent`.
-
-For information on managing the service, see [Manage `viam-agent`](/manage/reference/viam-agent/manage-viam-agent/).
-
-{{% /tab %}}
-{{% tab name="Windows" %}}
-
-On Windows, the [`viam-agent` installer](https://storage.googleapis.com/packages.viam.com/apps/viam-agent/viam-agent-windows-installer.exe) installs `viam-agent` as a service.
-Your machine credentials file must be at <file>\etc\viam.json</file>.
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /tablestep %}}
-{{< /table >}}
-
-## Configuration
-
-{{< tabs >}}
-{{% tab name="Config Builder" %}}
-
-1. Navigate to your machine's page.
-1. Navigate to the **CONFIGURE** tab.
-1. Click on **machine settings**.
-1. Edit and fill in the attributes as applicable.
-
-{{% /tab %}}
-{{% tab name="JSON Example" %}}
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "agent": {
-    "version_control": {
-      "agent": "stable",
-      "viam-server": "0.52.1"
-    },
-    "advanced_settings": {
-      "debug": false,
-      "wait_for_update_check": false,
-      "viam_server_start_timeout_minutes": 10,
-      "disable_viam_server": false,
-      "disable_network_configuration": false,
-      "disable_system_configuration": false,
-      "viam_server_env": {
-        "CUSTOM_VAR": "value"
-      }
-    },
-    "network_configuration": {
-      "manufacturer": "viam",
-      "model": "custom",
-      "fragment_id": "",
-      "hotspot_interface": "wlan0",
-      "hotspot_prefix": "viam-setup",
-      "hotspot_password": "viamsetup",
-      "disable_captive_portal_redirect": false,
-      "disable_bt_provisioning": false,
-      "disable_wifi_provisioning": false,
-      "bluetooth_trust_all": false,
-      "offline_before_starting_hotspot_minutes": 2,
-      "user_idle_minutes": 5,
-      "retry_connection_timeout_minutes": 10,
-      "turn_on_hotspot_if_wifi_has_no_internet": true,
-      "wifi_power_save": null
-    },
-    "additional_networks": {
-      "network1": {
-        "type": "wifi",
-        "interface": "",
-        "ssid": "fallbackNetOne",
-        "psk": "myFirstPassword",
-        "priority": 30,
-        "ipv4_address": "",
-        "ipv4_gateway": "",
-        "ipv4_dns": [],
-        "ipv4_route_metric": 0
-      },
-      "network2": {
-        "type": "wifi",
-        "interface": "",
-        "ssid": "fallbackNetTwo",
-        "psk": "mySecondPassword",
-        "priority": 10,
-        "ipv4_address": "",
-        "ipv4_gateway": "",
-        "ipv4_dns": [],
-        "ipv4_route_metric": 0
-      }
-    },
-    "system_configuration": {
-      "logging_journald_system_max_use_megabytes": 128,
-      "logging_journald_runtime_max_use_megabytes": 96,
-      "os_auto_upgrade_type": "all",
-      "forward_system_logs": "all,-gdm,-tailscaled"
-    }
-  }
-}
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-## `version_control`: Version management for `viam-agent` and `viam-server`
-
-By default, when a new version of `viam-server` becomes available, it will automatically download.
-When `viam-agent` next restarts, it installs and starts using the new version of `viam-server`.
-To ensure that updates only occur when your machines are ready, configure a [maintenance window](/operate/reference/viam-server/#maintenance-window). With a configured maintenance window, `viam-agent` will restart and upgrade `viam-server` only when maintenance is allowed and when `viam-server` is not currently processing config changes.
-
-{{< alert title="Tip: Check versions of viam-agent and viam-server" color="tip" >}}
-
-You can find the installed versions of viam-agent and viam-server on your machine's page. Click on the part status dropdown to the right of your machine's name on the top of the page.
-
-{{< /alert >}}
-
-<!-- prettier-ignore -->
-| Name       | Type | Required? | Description |
-| ---------- | ---- | --------- | ----------- |
-| `agent` | string | **Required** | The version of Viam agent specified as either:<ul><li>a version number`"5.6.77"` or `"0.65.1-dev.7"` (indicating the seventh commit to "main" after the previous non-dev release, `0.65.0`)</li><li>a tag such as`"stable"` or `"dev"`.</li><li>a URL such as `"http://example.com/viam-agent-test-aarch64"`, `"file:///home/myuser/viam-agent-test-aarch64"`, or `"file:///C:/Users/viam/Downloads/viam-agent-v0.31.0-windows-x86_64.exe"`</li></ul> Viam agent is semantically versioned and is tested before release. Releases happen infrequently. When set to `"stable"`, `viam-agent` will automatically upgrade when a new version is released. Default: `"stable"`. |
-| `viam-server` | string | **Required** | The version of `viam-server` specified as `"5.6.77"`, `"stable"`, `"dev"` or by providing a URL such as `"http://example.com/viam-server-test-aarch64"`, `"file:///home/myuser/viam-server-test-aarch64"`, or `"file:///C:/Users/viam/Downloads/viam-server-v0.72.0-windows-x86_64.exe"`. `viam-server` is semantically versioned and is tested before release. When set to `"stable"`, `viam-server` will automatically upgrade when a new stable version is released. Default: `"stable"`. |
-
-For more information on managing `viam-agent` see [Manage `viam-agent`](/manage/reference/viam-agent/manage-viam-agent/).
-
-### Update or downgrade `viam-server` with `viam-agent`
-
-{{< alert title="Tip" color="tip" >}}
-The current version of `viam-server` is displayed in the machine's part status dropdown to the right of your machine’s name on its page.
-{{< /alert >}}
-
-{{% hiddencontent %}}
-`viam-server` is made from the RDK. Therefore the version of RDK and `viam-server` installed on a machine is always the same.
-
-To check the version of `viam-server` (or the RDK) check the machine part status dropdown.
-To update the version of `viam-server` (or the RDK) update the machine settings.
-{{% /hiddencontent %}}
-
-1. Navigate to your machine's **CONFIGURE** tab.
-2. Click on **machine settings** on the left side of the page.
-3. Change the specified `viam-server` version.
-4. Save your configuration.
-
-## `advanced_settings`
-
-<!-- prettier-ignore -->
-| Name       | Type | Required? | Description |
-| ---------- | ---- | --------- | ----------- |
-| `debug` | boolean | Optional | Sets the log level to debug for any logging from the Viam agent binary. Default: `false`. |
-| `disable_network_configuration` | boolean | Optional | Disables the network and hotspot configuration, as well as the configuration of additional networks. Default: `false`. |
-| `disable_system_configuration` | boolean | Optional | Disables the system configuration. Default: `false`. |
-| `disable_viam_server` | boolean | Optional | Disable `viam-server` remotely. This option is often used by developers working on Viam agent or when manually running `viam-server`. Default: `false`. |
-| `viam_server_env` | object | Optional | A map of environment variable names to values that `viam-agent` passes to `viam-server` and its child processes (including modules). Both keys and values must be strings. See [Environment Variables for viam-server](#environment-variables-for-viam-server). Default: `{}` (empty). |
-| `viam_server_start_timeout_minutes` | integer | Optional | Specify a time after which, if `viam-server` hasn't successfully started, Viam agent will kill it and restart. Default: `10`. |
-| `wait_for_update_check` | boolean | Optional | If set to `true`, `viam-agent` will wait for a network connection and check for updates before starting `viam-server`. See [Reduce startup time](#reduce-startup-time). Default: `false`. |
-
-### Environment Variables for viam-server
-
-You can configure environment variables for `viam-server` using the `viam_server_env` setting in `advanced_settings`.
-Environment variables set through `viam_server_env` are passed to `viam-server` and all child processes it launches, including modules.
-`viam-server` also inherits existing environment variables from `viam-agent`, such as `HOME`, `PWD`, `TERM`, `PATH`.
-
-{{< alert title="Important" color="note" >}}
-When you change environment variables in `viam_server_env`, `viam-agent` will automatically restart `viam-server` to apply these and any other changes made before saving.
-This restart will occur immediately if `viam-server` is in a maintenance window and not currently processing configuration changes.
-{{< /alert >}}
-
-Changes to `viam_server_env` are the only changes that automatically trigger a `viam-server` restart. Changing other configuration options requires a manual restart unless you've also changed `viam_server_env`.
-
-#### Example configurations
-
-```json
-{
-  "agent": {
-    "advanced_settings": {
-      "viam_server_env": {
-        "PION_LOG_TRACE": "all", # Debug logging for WebRTC
-        "HTTPS_PROXY": "socks5://proxy.example.com:1080", # SOCKS proxy
-        "HTTP_PROXY": "socks5://proxy.example.com:1080",
-        "CUSTOM_VAR": "value"
-      }
-    }
-  }
-}
-```
-
-To remove an environment variable, remove it from the `viam_server_env` object and save your configuration.
-
-### Reduce startup time
-
-You can set `wait_for_update_check` to `false` to bypass `viam-agent` waiting for a network connection to be established and checking for updates during initial startup.
-This will result in `viam-server` executing as quickly as possible.
-
-This is useful if you have a device that often starts when offline or on a slow connection, and if having the latest version immediately after start isn't required.
-
-{{< alert title="Note" color="note" >}}
-Periodic update checks will continue to run afterwards.
-This setting only affects the initial startup sequencing.
-{{< /alert >}}
-
-You can also start `viam-agent` in fast start mode by setting `VIAM_AGENT_FAST_START=1` in your environment.
-
-## `network_configuration`
-
-<!-- prettier-ignore -->
-| Name       | Type | Required? | Description |
-| ---------- | ---- | --------- | ----------- |
-| `device_reboot_after_offline_minutes` | integer | Optional | If set, `viam-agent` will reboot the device after it has been offline for the specified duration. Default: `0` (disabled). |
-| `disable_bt_provisioning` | boolean | Optional | When set to true, disables Bluetooth provisioning. The machine will not advertise Bluetooth services for provisioning. Both WiFi hotspot and Bluetooth provisioning can be enabled simultaneously. Default: `false`. |
-| `disable_captive_portal_redirect` | boolean | Optional | By default, ALL DNS lookups using the provisioning hotspot will redirect to the device. This causes most phones/mobile devices to automatically redirect the user to the {{< glossary_tooltip term_id="captive-web-portal" text="captive portal" >}} as a "sign in" screen. When disabled, only domains ending in .setup (ex: viam.setup) will be redirected. This generally avoids displaying the portal to users and is mainly used in conjunction with a mobile provisioning application workflow. Default: `false`. |
-| `disable_wifi_provisioning` | boolean | Optional | When set to true, disables WiFi hotspot provisioning. The machine will not create a WiFi hotspot for provisioning. Both WiFi hotspot and Bluetooth provisioning can be enabled simultaneously. Default: `false`. |
-| `bluetooth_trust_all` | boolean | Optional | Set to true to accept all Bluetooth pairing requests (which is only needed for Bluetooth tethering) without requiring an unlock command from a mobile app. Default: `false`. |
-| `fragment_id` | string | Optional | The `fragment_id` of the fragment to configure machines with. Required when using Bluetooth or the Viam mobile app for provisioning. The Viam mobile app uses the fragment to configure the machine. |
-| `hotspot_interface` | string | Optional | The interface to use for hotspot/provisioning/wifi management. Example: `"wlan0"`. Default: first discovered 802.11 device. |
-| `hotspot_password` | string | Optional | Depending on the provisioning method, this is either the Wifi password or bluetooth connection password for the provisioning hotspot. **Important:** When provisioning devices with the Viam mobile app, the password must currently be `"viamsetup"`. Be aware that if you do not set a custom password this may be a security risk. Default: `"viamsetup"`. |
-| `hotspot_prefix` | string | Optional | `viam-agent` will prepend this to the hostname of the device and use the resulting string for the provisioning hotspot SSID or the Bluetooth device name(`<hotspot_prefix>-<hostname>`).  Default: `"viam-setup"`. |
-| `manufacturer` | string | Optional | Purely informative. May be displayed on captive portal or provisioning app. Default: `"viam"`. |
-| `model` | string | Optional | Purely informative. May be displayed on captive portal or provisioning app. Default: `"custom"`. |
-| `offline_before_starting_hotspot_minutes` | integer | Optional | Amount of time the device will spend offline, in minutes, before the machine begins broadcasting a wireless hotspot. Default: `2`. |
-| `retry_connection_timeout_minutes` | integer | Optional | Provisioning mode will exit after this time (in minutes), to allow other unmanaged (for example wired) or manually configured connections to be tried. Provisioning mode will restart if the connection/online status doesn't change. Default: `10`. |
-| `turn_on_hotspot_if_wifi_has_no_internet` | boolean | Optional | When enabled, Wi-Fi connections without Internet access are considered offline. After `offline_before_starting_hotspot_minutes` minutes offline, your device will begin broadcasting a hotspot. This setting must be enabled for your device to attempt connecting to `additional_networks`. Default: `false`. |
-| `user_idle_minutes` | integer | Optional | Amount of time before considering a user (using the captive web portal or provisioning app) idle, and resuming normal behavior. Used to avoid interrupting provisioning mode (for example for network tests/retries) when a user might be busy entering details. Default: `5` (5 minutes). |
-| `wifi_power_save` | boolean | Optional | If set, will explicitly enable or disable power save for all WiFi connections managed by NetworkManager. If not set, the system default applies. Default: `null`. |
-
-For more detailed instructions on what these settings do, see [Provisioning](/manage/fleet/provision/setup/).
-
-## `additional_networks`
-
-For an already-online device, you can configure new WiFi or wired networks in the machine's [`viam-agent` configuration](/manage/reference/viam-agent/#configuration).
-It's primarily useful for a machine that moves between different networks, so the machine can automatically connect when moved between locations.
-
-<!-- prettier-ignore -->
-| Name       | Type | Required? | Description | Available with the Micro-RDK |
-| ---------- | ---- | --------- | ----------- | ---------------------------- |
-| `interface` | string | Optional | Name of interface, for example: `"wlan0"`, `"eth0"`, `"enp14s0"`. Default: `""`. | |
-| `ipv4_address` | string | Optional | IPv4 address in CIDR format, for example: `"192.168.0.1/24"`. Default: `"auto"`. | |
-| `ipv4_dns` | string | Optional | Array of IPv4 DNS such as `["192.168.0.254", "8.8.8.8"]`. Default: `[]`. | |
-| `ipv4_gateway` | string | Optional | IPv4 gateway. Default: `""`. | |
-| `ipv4_route_metric` | integer | Optional | IPv4 route metric. Lower values are preferred. Default: `0` which defaults to `100` for wired networks and `600` for wireless network. | |
-| `priority` | integer | Optional | Priority to choose the network with. Values between -999 and 999 with higher values taking precedence. Default: `0`. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| `psk` | string | Optional | The network password/pre-shared key. Default: `""`. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| `ssid` | string | Optional | The WiFi network's SSID. Only needed for WiFi networks. Default: `""`. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| `type` | string | Optional | The type of the network. Required if a network is provided. Options: `"wifi"`, `"wired"`. | |
-
-To add additional networks add them using the JSON editor for your device's config.
-
-{{< alert title="Important" color="note" >}}
-Note that if you are adding networks to a machine's configuration, the machine will need to be connected to the internet to retrieve the configuration information containing the network credentials before it can use them.
-{{< /alert >}}
-
-During provisioning, `viam-agent` will try to connect to each specified network in order of `priority` from highest to lowest.
-If the highest-priority network is not available (or, if `turn_on_hotspot_if_wifi_has_no_internet` is enabled, the machine can connect but internet is not available), `viam-agent` will then attempt to connect to the next-highest network, and so on until all configured networks have been tried.
-
-## `system-configuration`
-
-<!-- prettier-ignore -->
-| Name       | Type | Required? | Description |
-| ---------- | ---- | --------- | ----------- |
-| `forward_system_logs` | string | Optional | Enable forwarding of system logs (journald) to the cloud. A comma-separated list of SYSLOG_IDENTIFIERs to include, optionally prefixed with "-" to exclude. "all" is a special keyword to log everything. Examples: `"kernel,tailscaled,NetworkManager"` or `"all,-gdm,-tailscaled"`. Default: `""` (disabled). |
-| `logging_journald_runtime_max_use_megabytes` | integer | Optional |Set the temporary space limit for logs. `-1` to disable. Default: `512` (512 MB). |
-| `logging_journald_system_max_use_megabytes` | integer | Optional | Sets the maximum disk space `journald` will use for persistent log storage. `-1` to disable. Default: `512` (512 MB). |
-| `os_auto_upgrade_type` | string | Optional | Manage OS package updates using Viam by setting this field. Installs the `unattended-upgrades` package, and replace `20auto-upgrades` and `50unattended-upgrades` in <FILE>/etc/apt/apt.conf.d/</FILE>, with an automatically generated Origins-Pattern list that is generated based on that of `50unattended-upgrades`. Custom repos installed on the system at the time the setting is enabled will be included. Options: `"all"` (automatic upgrades are performed for all packages), `"security"` (automatic upgrades for only packages containing `"security"` in their codename (for example `bookworm-security`)), `"disable"` (disable automatic upgrades), `""` (do not change system settings). Default: `""`. |
-
-For more detailed instructions, see [Configure machine settings](https://docs.viam.com/manage/fleet/system-settings/).
-
-## Agent logs
-
-These log messages include `viam-server` stops and starts, the status of `viam-agent`, and any errors or warnings encountered during operation.
-
-{{< tabs >}}
-{{% tab name="App UI" %}}
-
-`viam-agent` writes log messages to Viam.
-
-`viam-agent` only sends messages when your machine is online and connected to the internet.
-If your machine is offline, log messages are queued and are sent to Viam once your machine reconnects to the internet.
-
-Navigate to the **LOGS** tab of your machine's page.
-
-Select from the **Levels** dropdown menu to filter the logs by severity level:
-
-{{<imgproc src="/build/program/sdks/log-level-info.png" resize="600x" declaredimensions=true alt="Filtering by log level of info in the logs tab." class="shadow imgzoom">}}
-
-{{% /tab %}}
-{{% tab name="Command line on Linux" %}}
-
-```sh {class="command-line" data-prompt="$"}
-sudo journalctl --unit=viam-agent
-```
-
-{{% /tab %}}
-{{% tab name="Command line on MacOS" %}}
-
-```sh {class="command-line" data-prompt="$"}
-less /var/log/viam-agent.log
-```
-
-{{% /tab %}}
-{{% tab name="Event Viewer on Windows" %}}
-
-Open the Windows Event Viewer (`eventvwr` from the command line).
-
-You will find the `viam-agent` logs under **Windows Logs > Application** on the **Details** tab
-
-{{<imgproc src="/manage/windows-logs.png" resize="1000x" class="imgzoom" style="width:600px" declaredimensions=true alt="Windows Event Viewer showing logs">}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-## Core options
-
-<!-- prettier-ignore -->
-| Option | Description |
-| ------ | ----------- |
-| `-c`, `--config` | Path to machine credentials file. Default: `/etc/viam.json`. |
-| `--defaults` | Path to manufacturer defaults file. Default: `/etc/viam-defaults.json` |
-| `-d`, `--debug` | Enable debug logging (on agent only). Can also be set with environment variable `VIAM_AGENT_DEBUG`. |
-| `-w`, `--wait` | Update versions before starting. Can also be set with environment variable `VIAM_AGENT_WAIT_FOR_UPDATE`. |
-| `-h`, `--help` | Show help message. |
-| `--install` | Install systemd/launchd service. |
diff --git a/docs/manage/reference/viam-agent/manage-viam-agent.md b/docs/manage/reference/viam-agent/manage-viam-agent.md
deleted file mode 100644
index 0b1cb6fa1d..0000000000
--- a/docs/manage/reference/viam-agent/manage-viam-agent.md
+++ /dev/null
@@ -1,242 +0,0 @@
----
-title: "Manage viam-agent"
-linkTitle: "Manage viam-agent"
-weight: 110
-no_list: true
-type: docs
-draft: false
-images: ["/installation/thumbnails/manage.png"]
-imageAlt: "Manage viam-agent"
-description: "Control and manage the viam-agent system service."
-date: "2024-08-16"
-aliases:
-  - /installation/manage-viam-agent/
-# updated: ""  # When the content was last entirely checked
----
-
-[`viam-agent`](/manage/reference/viam-agent/) is installed as a `systemd` service named
-`viam-agent` on Linux, and as a `launchd` daemon named `system/com.viam.agent` on MacOS.
-
-{{< tabs >}}
-{{% tab name="Linux" %}}
-
-- To restart `viam-agent`:
-
-  {{< alert title="Alert" color="note" >}}
-  When you restart `viam-agent`, the agent will restart `viam-server` as well.
-  {{< /alert >}}
-
-  {{< tabs >}}
-  {{% tab name="Web UI" %}}
-
-  1. Navigate to your machine in [Viam](https://app.viam.com).
-  1. Click on the machine status indicator next to the machine name.
-  1. Click on the restart arrow symbol.
-     This will restart `viam-server` and `viam-agent`.
-
-  {{% /tab %}}
-  {{% tab name="Shell" %}}
-
-  ```sh {class="command-line" data-prompt="$"}
-  sudo systemctl restart viam-agent
-  ```
-
-  {{% /tab %}}
-  {{< /tabs >}}
-
-- To start `viam-agent`:
-
-  ```sh {class="command-line" data-prompt="$"}
-  sudo systemctl start viam-agent
-  ```
-
-- To stop `viam-agent`:
-
-  {{< alert title="Alert" color="note" >}}
-  When you stop `viam-agent`, the agent will stop `viam-server` as well.
-  {{< /alert >}}
-
-  ```sh {class="command-line" data-prompt="$"}
-  sudo systemctl stop viam-agent
-  ```
-
-- To completely uninstall `viam-agent` and `viam-server`, run the following command:
-
-  ```sh {class="command-line" data-prompt="$"}
-  sudo /bin/sh -c "$(curl -fsSL https://storage.googleapis.com/packages.viam.com/apps/viam-agent/uninstall.sh)"
-  ```
-
-  This command uninstalls `viam-agent`, `viam-server`, the machine cloud credentials file (<file>/etc/viam.json</file>), and the provisioning configuration file (<file>/etc/viam-provisioning.json</file>).
-
-{{< alert title="Caution" color="caution" >}}
-If you remove the machine cloud credentials file you will not be able to connect to your machine.
-You can only restore this file if you have access to the machine configuration.
-{{< /alert >}}
-
-{{% /tab %}}
-{{% tab name="MacOS" %}}
-
-- To restart `viam-agent`:
-
-  {{< alert title="Alert" color="note" >}}
-  When you restart `viam-agent`, the agent will restart `viam-server` as well.
-  {{< /alert >}}
-
-  {{< tabs >}}
-  {{% tab name="Web UI" %}}
-
-  1. Navigate to your machine in [Viam](https://app.viam.com).
-  1. Click on the machine status indicator next to the machine name.
-  1. Click on the restart arrow symbol.
-     This will restart `viam-server` and `viam-agent`.
-
-  {{% /tab %}}
-  {{% tab name="Shell" %}}
-
-  ```sh {class="command-line" data-prompt="$"}
-  sudo launchctl kickstart -k system/com.viam.agent
-  ```
-
-  {{% /tab %}}
-  {{< /tabs >}}
-
-- To start `viam-agent`:
-
-  ```sh {class="command-line" data-prompt="$"}
-  sudo launchctl kickstart system/com.viam.agent
-  ```
-
-  If the service fails to start, make sure it is bootstrapped. The following command will
-  print an error message if the service is NOT bootstrapped.
-
-  ```sh {class="command-line" data-prompt="$"}
-  sudo launchctl print system/com.viam.agent
-  ```
-
-  The following command will bootstrap the service.
-
-  ```sh {class="command-line" data-prompt="$"}
-  sudo launchctl bootstrap system /Library/LaunchDaemons/com.viam.agent.plist
-  ```
-
-  If the service STILL fails to start, ensure that it is enabled. The following command
-  will enable the service.
-
-  ```sh {class="command-line" data-prompt="$"}
-  sudo launchctl enable system/com.viam.agent
-  ```
-
-- To stop `viam-agent`:
-
-  {{< alert title="Alert" color="note" >}}
-  When you stop `viam-agent`, the agent will stop `viam-server` as well.
-  {{< /alert >}}
-
-  `sudo launchctl kill` and `sudo launchctl stop` will NOT fully stop `viam-agent`, as
-  launchd will automatically resurrect it. You can use the following to "boot out" the
-  service and fully stop it.
-
-  ```sh {class="command-line" data-prompt="$"}
-  sudo launchctl bootout system/com.viam.agent
-  ```
-
-  If you would like to start `viam-agent` again after this command, you will need to
-  bootstrap it again.
-
-  ```sh {class="command-line" data-prompt="$"}
-  sudo launchctl bootstrap system /Library/LaunchDaemons/com.viam.agent.plist
-  ```
-
-- To completely uninstall `viam-agent` and `viam-server`, run the following command:
-
-  ```sh {class="command-line" data-prompt="$"}
-  sudo /bin/sh -c "$(curl -fsSL https://storage.googleapis.com/packages.viam.com/apps/viam-agent/uninstall.sh)"
-  ```
-
-  This command uninstalls `viam-agent`, `viam-server`, and the machine cloud credentials file (<file>/etc/viam.json</file>).
-
-{{< alert title="Caution" color="caution" >}}
-If you remove the machine cloud credentials file you will not be able to connect to your machine.
-You can only restore this file if you have access to the machine configuration.
-{{< /alert >}}
-
-{{% /tab %}}
-{{% tab name="Windows native" %}}
-
-On Windows, you can manage `viam-agent` using the Services GUI or the command line.
-You can also use the Viam web UI to restart `viam-agent`.
-
-{{< tabs >}}
-{{% tab name="Services GUI" %}}
-
-1. Open the **Services** management console from your computer's start menu.
-
-1. Find `viam-agent` in the list of services.
-
-   {{<imgproc src="/manage/viam-agent-windows-services-manager.png" resize="x1100" declaredimensions=true alt="Windows Services manager with viam-agent highlighted." style="max-width:600px" class="shadow imgzoom" >}}
-
-1. Use the **Restart Service**, **Stop Service**, and **Start Service** buttons to manage `viam-agent`.
-
-1. To change the startup type of `viam-agent`, right-click on `viam-agent` and select **Properties**.
-   Select your desired startup type from the **Startup type** dropdown menu.
-
-   {{<imgproc src="/manage/startup-type-windows.png" resize="x1000" declaredimensions=true alt="Windows Services manager with viam-agent properties open." style="max-width:350px" class="shadow imgzoom" >}}
-
-{{% /tab %}}
-{{% tab name="Command line" %}}
-
-1. Open a PowerShell prompt, selecting **Run as administrator**.
-
-1. Use the following commands to manage `viam-agent`:
-
-   - To start `viam-agent`:
-
-     ```sh {class="command-line" data-prompt="$"}
-     Start-Service viam-agent
-     ```
-
-   - To stop `viam-agent`:
-
-     ```sh {class="command-line" data-prompt="$"}
-     Stop-Service viam-agent
-     ```
-
-   - To restart `viam-agent`:
-
-     ```sh {class="command-line" data-prompt="$"}
-     Restart-Service viam-agent
-     ```
-
-   - To change the startup type of `viam-agent`, use one of the following commands:
-
-     ```sh {class="command-line" data-prompt="$"}
-     Set-Service -Name "viam-agent" -StartupType Manual
-     Set-Service -Name "viam-agent" -StartupType Automatic
-     ```
-
-{{% /tab %}}
-{{% tab name="Web UI" %}}
-
-1. Navigate to your machine in [Viam](https://app.viam.com).
-1. Click on the machine status indicator next to the machine name.
-1. Click on the restart arrow symbol.
-   This will restart `viam-server` and `viam-agent`.
-
-{{% /tab %}}
-{{< /tabs >}}
-
-To uninstall `viam-agent`, run the following command in an administrator prompt:
-
-```sh {class="command-line" data-prompt="$"}
-sc stop viam-agent
-sc delete viam-agent
-Remove-Item \opt\viam -Recurse
-Remove-Item C:\Windows\system32\config\systemprofile\.viam -Recurse
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-## Troubleshooting
-
-You can find assistance in the [Troubleshooting section](/manage/troubleshoot/troubleshoot/).
diff --git a/docs/manage/software/_index.md b/docs/manage/software/_index.md
deleted file mode 100644
index ad3edfa36b..0000000000
--- a/docs/manage/software/_index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-linkTitle: "Code Deployment"
-weight: 20
-layout: "empty"
-type: "docs"
-empty_node: true
-open_on_desktop: true
-header_only: true
-canonical: "/manage/software/deploy-software/"
----
diff --git a/docs/manage/software/deploy-software.md b/docs/manage/software/deploy-software.md
deleted file mode 100644
index d8d668d620..0000000000
--- a/docs/manage/software/deploy-software.md
+++ /dev/null
@@ -1,102 +0,0 @@
----
-linkTitle: "Deploy software"
-title: "Deploy software packages to machines (OTA)"
-weight: 35
-layout: "docs"
-type: "docs"
-images: ["/registry/module-puzzle-piece.svg"]
-description: "Deploy code packages with machine control logic to one or more machines."
-languages: []
-viamresources: []
-platformarea: ["registry", "fleet"]
-level: "Intermediate"
-date: "2025-02-14"
-aliases:
-  - /how-tos/deploy-packages/
-  - /manage/software/deploy-packages/
-# updated: ""  # When the tutorial was last entirely checked
-cost: "0"
----
-
-The following steps show you how to deploy and manage your machine's software over the air (OTA).
-
-For microcontrollers, see [Over-the-air firmware updates](/operate/install/setup-micro/#configure-over-the-air-updates) for more information.
-
-## Prerequisites
-
-Start by [setting up one machine](/operate/install/setup/).
-Once your machine is connected to Viam, return to this page.
-
-## Create a fragment
-
-Viam has a built-in tool called _{{< glossary_tooltip term_id="fragment" text="fragments" >}}_ that enable you to reuse one configuration across multiple machines.
-When deploying or updating software on many machines, you should use fragments to deploy your modules OTA to your machines.
-For more detailed information, see [Reuse configuration](/manage/fleet/reuse-configuration/).
-
-1. Go to [app.viam.com/fragments](https://app.viam.com/fragments).
-1. Click **Create fragment**.
-1. Set your privacy settings at the top of the page.
-
-   Choose one of the following privacy options for your fragment:
-
-   - **Public:** Any user inside or outside of your organization will be able to view and use this fragment.
-   - **Private:** No user outside of your organization will be able to view or use this fragment.
-   - **Unlisted:** Any user inside or outside of your organization, with a direct link, will be able to view and use this fragment.
-
-1. Click **Save**.
-
-## Configure your hardware and software
-
-1.  Click the **+** button to add drivers for your hardware resources and any other resources you want to use with your control logic.
-    For more information, see [Supported hardware](/operate/modules/configure-modules/).
-1.  If you created a [control logic module](/operate/modules/write-a-logic-module/), add it to your machine.
-
-    {{<imgproc src="/how-tos/deploy-packages/add-package.png" resize="800x" class="shadow" style="width: 500px" declaredimensions=true alt="Configuration builder UI">}}
-
-1.  Optionally, add other resources, or settings.
-
-## Set the version and update strategy
-
-For each module:
-
-1. Scroll to the module card for your control logic module.
-1. Select a **Pinned version type**.
-
-   You can select a specific version or set the machine to always update to the latest major, minor, patch, or pre-release version once new versions are available.
-   For more information on these configuration options, see [Module versioning](/operate/modules/advanced/module-configuration/#module-versioning).
-
-   By default, if the set version type allows for automatic updates, when a new version of a module or package becomes available, it will automatically update when the configuration is synced next.
-   To ensure that updates only occur when your machines are ready, configure a [maintenance window](/operate/reference/viam-server/#maintenance-window). With a configured maintenance window, configuration updates will only be applied when maintenance is allowed.
-
-   {{<imgproc src="/how-tos/deploy-packages/version.png" resize="800x" class="shadow" style="width: 500px" declaredimensions=true alt="Module card UI">}}
-
-{{% alert title="Caution" color="caution" %}}
-For any version type other than **Patch (X.Y.Z)**, the module will upgrade as soon as an update that matches that specified version type is available, which will **restart the module**.
-If the module cannot be interrupted, the module will not be upgraded.
-{{% /alert %}}
-
-## Add the fragment automatically to your machines with provisioning
-
-Provisioning allows you to automatically add fragments to your machines.
-See [Provisioning](/manage/fleet/provision/setup/) for more information.
-
-## Add the fragment to your machines manually
-
-You can also add fragments manually to the machines that need it:
-
-1. Navigate to your machine's **CONFIGURE** tab.
-1. Click the **+** button.
-1. Select **Insert fragment**.
-
-   {{<imgproc src="/how-tos/deploy-packages/insert.png" resize="800x" class="fill imgzoom shadow" style="width: 250px" declaredimensions=true alt="Add fragment">}}
-
-1. Search for your fragment and add it.
-1. Click **Save** in the upper right corner of the screen.
-
-{{< alert title="Tip" color="tip" >}}
-You can also add multiple fragments to one machine.
-{{< /alert >}}
-
-{{% hiddencontent %}}
-You cannot add the same fragment to a machine twice.
-{{% /hiddencontent %}}
diff --git a/docs/manage/software/scheduled-jobs.md b/docs/manage/software/scheduled-jobs.md
deleted file mode 100644
index 3ecffdc100..0000000000
--- a/docs/manage/software/scheduled-jobs.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-linkTitle: "Schedule automated jobs"
-title: "Schedule automated jobs on machines"
-weight: 40
-layout: "docs"
-type: "docs"
-images: ["/registry/module-puzzle-piece.svg"]
-description: "Configure automated jobs that run on machines at specified intervals."
-languages: []
-viamresources: []
-platformarea: ["fleet"]
-level: "Intermediate"
-date: "2025-06-17"
-# updated: ""  # When the tutorial was last entirely checked
-cost: "0"
----
-
-Viam's machine job scheduler allows you to configure automated jobs that run on your machines at specified intervals.
-This enables you to automate routine tasks such as data collection, sensor readings, maintenance operations, and system checks.
-
-The job scheduler is built into `viam-server` and executes configured jobs according to their specified schedules.
-Each job targets a specific resource on your machine and calls a designated component or service API method at the scheduled intervals.
-
-## Configure a job
-
-{{< tabs >}}
-{{% tab name="Builder mode" %}}
-
-1. Go to the **CONFIGURE** tab of your machine.
-   Click the **+** (Create) button in the left side menu and select **Job**.
-
-1. Enter a name and click **Create**.
-
-1. For the **Schedule**, select **Interval** or **Cron** and specify the interval the job should be run in.
-
-1. For **Job**, select a **Resource**, and a component or service API **method**.
-   For the `DoCommand` method also specify the command parameters.
-
-{{% /tab %}}
-{{% tab name="JSON Template" %}}
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "components": [ ... ],
-  "services": [ ... ],
-  "jobs": [
-    {
-      "name": "hourly-job",
-      "schedule": "0 * * * *",
-      "resource": "<resource-name>",
-      "method": "<method-name>"
-    },
-    {
-      "name": "daily-job",
-      "schedule": "0 8 * * *",
-      "resource": "<resource-name>",
-      "method": "<method-name>"
-    },
-    {
-      "name": "periodic-job",
-      "schedule": "15m",
-      "resource": "<resource-name>",
-      "method": "<method-name>"
-    },
-    {
-      "name": "do-command-job",
-      "schedule": "0 2 * * 0",
-      "resource": "<resource-name>",
-      "method": "DoCommand",
-      "command": {
-        "key": "calibrate",
-        "mode": "full"
-      }
-    }
-  ]
-}
-```
-
-{{% /tab %}}
-{{% tab name="JSON Example" %}}
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "components": [
-    {
-      "name": "temp-sensor",
-      "model": "fake",
-      "type": "sensor"
-    },
-    {
-      "name": "camera1",
-      "model": "webcam",
-      "type": "camera"
-    }
-  ],
-  "services": [
-    {
-      "name": "data_manager",
-      "type": "data_manager"
-    }
-  ],
-  "jobs": [
-    {
-      "name": "hourly-sensor-reading",
-      "schedule": "0 * * * *",
-      "resource": "temp-sensor",
-      "method": "GetReadings"
-    },
-    {
-      "name": "daily-camera-capture",
-      "schedule": "0 8 * * *",
-      "resource": "camera1",
-      "method": "GetImages"
-    },
-    {
-      "name": "periodic-sync",
-      "schedule": "15m",
-      "resource": "data_manager",
-      "method": "Sync"
-    },
-    {
-      "name": "custom-maintenance",
-      "schedule": "0 2 * * 0",
-      "resource": "temp-sensor",
-      "method": "DoCommand",
-      "command": {
-        "action": "calibrate",
-        "mode": "full"
-      }
-    }
-  ]
-}
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-## Job configuration
-
-Jobs are configured as part of your machine's configuration. Each job requires the following parameters:
-
-<!-- prettier-ignore -->
-| Parameter  | Type   | Required     | Description |
-| ---------- | ------ | ------------ | ----------- |
-| `name`     | string | **Required** | Unique identifier for the job within the machine.                |
-| `schedule` | string | **Required** | Schedule specification using unix-cron format or Golang duration. Values must be non-zero. Accepts <ul><li>Unix-cron expressions for time-based scheduling:<ul><li>`"*/5 * * * * *"`: Runs at 5 seconds past the minute</li><li>`"0 */6 * * *"`: Every 6 hours</li><li>`"0 0 * * 0"`: Every Sunday at midnight</li><li>`"*/15 * * * *"`: Every 15 minutes</li><li>`"0 9 * * 1-5"`: Every weekday at 9 AM</li></ul></li><li>Golang duration strings for interval-based scheduling:<ul><li>`"10ms"`: Every 30 milliseconds</li><li>`"30s"`: Every 30 seconds</li><li>`"5m"`: Every 5 minutes</li><li>`"1h"`: Every hour</li><li>`"24h"`: Every 24 hours</li></ul></li></ul>Job schedules are evaluated in the machine's local timezone. |
-| `resource` | string | **Required** | Name of the target resource (component or service).               |
-| `method`   | string | **Required** | Component or service API method to call on the target resource.   |
-| `command`  | object | Optional     | Command parameters for `DoCommand` operations.                    |
-
-## Monitoring and troubleshooting
-
-Monitor job execution through `viam-server` logs. Look for `rdk.job_manager`:
-
-```sh {class="command-line" data-prompt="$" data-output="1-10"}
-8/19/2025, 7:38:59 PM info rdk.job_manager.periodic-job   jobmanager/jobmanager.go:160   Job succeeded   response map[action:true]
-8/19/2025, 7:38:59 PM info rdk.job_manager.periodic-job   jobmanager/jobmanager.go:155   Job triggered
-8/19/2025, 7:51:33 PM warn rdk.job_manager.periodic-job   jobmanager/jobmanager.go:151   Could not get resource   error could not find the resource for name generic-2
-```
-
-## Limitations
-
-- There is no timeout on job's invocations of gRPC requests.
-- Jobs only run when `viam-server` is running.
-- If a unix-cron job is scheduled to start but a previous invocation is still running, the job will be skipped. The job will next run once the previous invocation has finished running and the next scheduled time is reached.
-- If a Golang duration job is scheduled to run but a previous invocation is still running, the next invocation will not run until the previous invocation finishes, at which point it will run immediately.
-- `DoCommand` is currently the only supported component and service API method which you can invoke with arguments.
-  Aside from `DoCommand`, Jobs currently only support component and service API methods that do not require arguments.
-  To avoid this limitation, create a module and encapsulate API calls in a DoCommand API call.
-- Jobs run locally on each machine and are not coordinated across multiple machines.
-- Job execution depends on `viam-server` running.
-- Failed jobs do not retry.
diff --git a/docs/manage/software/update-software.md b/docs/manage/software/update-software.md
deleted file mode 100644
index acfbf01e17..0000000000
--- a/docs/manage/software/update-software.md
+++ /dev/null
@@ -1,192 +0,0 @@
----
-linkTitle: "Update software"
-title: "Roll out software updates to machines"
-weight: 40
-layout: "docs"
-type: "docs"
-description: "As new versions of software modules or ML models become available, you can update the deployed version on all machines in one go."
-date: "2025-02-14"
-aliases:
-  - /manage/software/update-packages/
----
-
-If you have already [deployed software](/manage/software/deploy-software/), you can inspect the fragment you have created.
-Each deployed {{< glossary_tooltip term_id="module" text="module" >}} or {{< glossary_tooltip term_id="package" text="package" >}} has a `version` field.
-Unless the `version` field is set to a specific version, updates for that module or package happen automatically.
-
-{{% alert title="Updates for microcontrollers" color="note" %}}
-To update the firmware on your microcontroller, see [Over-the-air updates](/operate/install/setup-micro/#configure-over-the-air-updates).
-{{% /alert %}}
-
-## Test and update software
-
-You can either use fragment tags for testing or manually overwrite the version of the module or package or the configuration for a subset of machines.
-We strongly recommend that you test changes on a subset of machines before deploying it to all machines.
-
-{{< tabs >}}
-{{< tab name="Version tags (recommended)" >}}
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Navigate to your fragment's page** on On your fragment's page, from the [FRAGMENTS tab](https://app.viam.com/fragments).
-{{% /tablestep %}}
-{{% tablestep %}}
-**Create a `stable` fragment tag**.
-On your fragment's page, click on **Versions** in the menu bar and add a tag called `stable`.
-{{% /tablestep %}}
-{{% tablestep %}}
-**Pin all machine configurations** to the `stable` fragment tag.
-For each machine that uses the fragment, update its configuration.
-{{% /tablestep %}}
-{{% tablestep %}}
-**Edit the fragment** and change the version of your module or package or the configuration in the development fragment.
-This will create a new version of the fragment.
-
-For example:
-
-```json {class="line-numbers linkable-line-numbers"}
-{
-  "version": "0.0.7"
-}
-```
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Create a development tag**.
-On your fragment's page, click on **Versions** in the menu bar and add a tag called `development`.
-Select the most recent version that you just created for the tag.
-{{% /tablestep %}}
-{{% tablestep %}}
-**Add the development fragment to a subset of machines** by pinning the fragment configuration to the `development` fragment tag.
-For each machine that you want to test the changes on, update the configuration.
-{{% /tablestep %}}
-{{% tablestep %}}
-**Test the new version of your module or package**.
-{{% /tablestep %}}
-{{% tablestep %}}
-**Update the `stable` fragment tag**.
-When you are satisfied that your module or package works as expected, set the **Version** for the `stable` fragment tag to the new version.
-This will update all machines that use the `stable` fragment tag.
-{{% /tablestep %}}
-{{< /table >}}
-
-{{< /tab >}}
-{{< tab name="Manual testing" >}}
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**For one or more machines, change the version of the module.**
-
-You can overwrite parts of a fragment to use a new version of a module or package without modifying the upstream fragment.
-
-For each machine that you would like to test the new version of the module or package on, go to its **CONFIGURE** tab, find the module or package, and edit its version number.
-
-{{<imgproc src="/how-tos/deploy-packages/version-change.png" resize="800x" class="shadow fill" style="width: 600px" declaredimensions=true alt="Configuration builder UI">}}
-
-Click **Save** in the upper right corner of the screen.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Test your changes.**
-{{% /tablestep %}}
-{{% tablestep %}}
-**Update the fragment.**
-
-When you are satisfied that your changes work as expected, click the **...** menu on the resource you updated and click **Merge changes**.
-This will create a new version of your fragment.
-
-Fragment tags remain unchanged.
-
-All machines configured with your fragment will update when they next check for configuration updates.
-
-{{% /tablestep %}}
-{{< /table >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{< alert title="Manage when machines update their config" color="tip" >}}
-By default, when a fragment is updated, machines using it will automatically update when the configuration is synced next.
-To ensure that updates only occur when your machines are ready, configure a [maintenance window](/operate/reference/viam-server/#maintenance-window).
-With a configured maintenance window, configuration updates will only be applied when maintenance is allowed.
-{{< /alert >}}
-
-## Check machine status
-
-To check when your machines have last updated their configuration, iterate over your machines using the Fleet Management API, connect to each machine, and use the [`GetMachineStatus` method](/dev/reference/apis/robot/#getmachinestatus).
-
-The following example script iterates over all machines in a given location and if it can connect to the machines, it prints their status information.
-If it cannot connect to a machine, it prints the most recent log entries.
-
-```python {class="line-numbers linkable-line-numbers"}
-import asyncio
-
-from viam.rpc.dial import DialOptions
-from viam.app.viam_client import ViamClient
-from viam.robot.client import RobotClient
-
-
-# TODO: Replace "<API-KEY>" (including brackets) with your API key and
-# "<API-KEY-ID>" with your API key ID
-API_KEY = "<API-KEY>"
-API_KEY_ID = "<API-KEY-ID>"
-LOCATION_ID = "<LOCATION-ID>"
-
-
-async def connect() -> ViamClient:
-    dial_options = DialOptions.with_api_key(API_KEY, API_KEY_ID)
-    return await ViamClient.create_from_dial_options(dial_options)
-
-
-async def machine_connect(address):
-    opts = RobotClient.Options.with_api_key(
-        api_key=API_KEY,
-        api_key_id=API_KEY_ID
-    )
-    return await RobotClient.at_address(address, opts)
-
-
-async def main():
-    async with await connect() as viam_client:
-        cloud = viam_client.app_client
-
-        machines = await cloud.list_robots(location_id=LOCATION_ID)
-        print("Found {} machines.".format(len(machines)))
-
-        for m in machines:
-            machine_parts = await cloud.get_robot_parts(m.id)
-            main_part = None
-            for p in machine_parts:
-                if p.main_part:
-                    main_part = p
-
-            # Get machine address
-            machine_address = main_part.fqdn
-
-            print("Attempting to connect to {}...".format(machine_address))
-
-            try:
-                async with await machine_connect(machine_address) as machine:
-                    status = await machine.get_machine_status()
-                    print(status.config)
-
-            except ConnectionError:
-                print("Unable to establish a connection to the machine.")
-                logs = await cloud.get_robot_part_logs(
-                    robot_part_id=main_part.id,
-                    num_log_entries=5
-                )
-                if not logs:
-                    print("No logs available.")
-                else:
-                    print("Most recent 5 log entries:")
-                for log in logs:
-                    print("{}-{} {}: {}".format(
-                        log.logger_name, log.level, log.time, log.message))
-                    if log.stack:
-                        print(log.stack)
-
-
-if __name__ == '__main__':
-    asyncio.run(main())
-```
diff --git a/docs/manage/troubleshoot/_index.md b/docs/manage/troubleshoot/_index.md
deleted file mode 100644
index 1dc9504ac0..0000000000
--- a/docs/manage/troubleshoot/_index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-linkTitle: "Monitor & Troubleshoot"
-weight: 30
-layout: "empty"
-type: "docs"
-empty_node: true
-open_on_desktop: true
-header_only: true
-canonical: "/manage/troubleshoot/monitor/"
----
diff --git a/docs/manage/troubleshoot/alert.md b/docs/manage/troubleshoot/alert.md
deleted file mode 100644
index 585c0401a5..0000000000
--- a/docs/manage/troubleshoot/alert.md
+++ /dev/null
@@ -1,513 +0,0 @@
----
-linkTitle: "Alert on machine telemetry"
-title: "Alert on machine telemetry"
-weight: 20
-layout: "docs"
-type: "docs"
-description: "Receive alerts for events involving machine performance telemetry."
-tags: ["triggers"]
-images: ["/services/data/monitor.gif"]
-videos: ["/services/data/monitor.webm", "/services/data/monitor.mp4"]
-languages: []
-viamresources: ["sensor", "data_manager"]
-platformarea: ["data", "registry"]
-aliases:
-  - /build/configure/webhooks/
-  - /build/configure/triggers/
-  - "/data/capture/performance-metrics/"
-  - "/services/data/capture/performance-metrics/"
-  - /configure/triggers/
-  - /how-tos/performance-metrics/
-date: "2024-12-07"
-# updated: ""  # When the content was last entirely checked
-cost: "0"
----
-
-You can configure triggers that alert you when machine telemetry data syncs from your local device to the Viam cloud or based on log messages:
-
-- **Telemetry sync**: Alerts whenever certain telemetry syncs
-- **Conditional telemetry sync**: Alert only when synced telemetry satisfies a condition
-- **Logs**: Alert on error, warning, or info logs appearing on a machine
-
-For example, you can configure a trigger to send you a notification when your machine's CPU usage reaches a certain threshold.
-
-Additionally, you can receive continuous alerts at a specified interval indicating one of the following machine statuses:
-
-- **Part is online**: alert while the {{< glossary_tooltip term_id="part" text="machine part" >}} is online
-- **Part is offline**: alert while the machine part is offline
-
-### Prerequisites
-
-{{% expand "A running machine connected to Viam." %}}
-
-{{% snippet "setup.md" %}}
-
-{{% /expand %}}
-
-{{% expand "On macOS, an installation of Telegraf." %}}
-
-To install [`telegraf`](https://github.com/influxdata/telegraf), run the following command:
-
-```sh {class="command-line" data-prompt="$"}
-brew install telegraf
-```
-
-{{% /expand %}}
-
-## Alert on telemetry sync
-
-{{< tabs >}}
-{{% tab name="Linux" %}}
-
-The following steps show you how to configure [`sbc-hwmonitor`](https://app.viam.com/module/rinzlerlabs/sbc-hwmonitor) sensors to monitor different metrics about a machine, such as:
-
-- `memory_monitor`: Memory stats for the SBC.
-- `cpu_monitor`: Reports per-core and overall usage percentages.
-- `temperature`: Reports the temperature of various temperature sensors.
-
-{{% /tab %}}
-{{% tab name="macOS" %}}
-
-The following steps show you how to configure [`telegraf`](https://app.viam.com/module/viam/viam-telegraf-sensor) sensors to monitor different metrics about a machine, such as:
-
-- `mem`: Memory stats for the SBC.
-- `cpu`: Reports per-core and overall usage percentages.
-
-{{% /tab %}}
-{{< /tabs >}}
-
-### Add performance sensor
-
-{{< tabs >}}
-{{% tab name="Linux" %}}
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Add the performance metrics sensors**
-
-On your machine's **CONFIGURE** page, click the **+** icon next to your machine part in the left-hand menu and select **Component or service**.
-
-Search for and add the `hwmonitor:cpu_monitor` model provided by the [`sbc-hwmonitor`](https://app.viam.com/module/rinzlerlabs/sbc-hwmonitor).
-
-{{% /tablestep %}}
-
-<!-- markdownlint-disable-file MD034 -->
-
-{{% tablestep %}}
-**(Optional) Customize the sensor configuration**
-
-Add additional sensors for any other metrics you want to track.
-You can find a list of sensors on the [`sbc-hwmonitor`](https://app.viam.com/module/rinzlerlabs/sbc-hwmonitor) module page.
-
-{{% /tablestep %}}
-{{% tablestep  number=3 %}}
-**Test the sensor**
-
-Click **Save** to put your configuration changes into effect.
-
-Now, click **Test** at the bottom of the sensor configuration card to view the readings.
-You can also see readings on the **CONTROL** tab.
-
-{{<imgproc src="/how-tos/telegraf-test.png" resize="1000x" style="width:600px" class="shadow imgzoom" declaredimensions=true alt="Test panel with readings displayed.">}}
-
-{{% /tablestep %}}
-{{< /table >}}
-{{% /tab %}}
-{{% tab name="macOS" %}}
-{{< table >}}
-{{% tablestep start=1 %}}
-**Add the performance metrics sensors**
-
-On your machine's **CONFIGURE** page, click the **+** icon next to your machine part in the left-hand menu and select **Component**.
-
-Search for and add the [`viam-sensor:telegrafsensor` model](https://github.com/viam-modules/viam-telegraf-sensor).
-
-{{% /tablestep %}}
-
-<!-- markdownlint-disable-file MD034 -->
-
-{{% tablestep %}}
-**(Optional) Customize the sensor configuration**
-
-Add additional sensors for any other metrics you want to track.
-You can find a list of sensors on the [`viam-telegraf-sensor`](https://app.viam.com/module/viam/viam-telegraf-sensor) module page.
-
-{{% /tablestep %}}
-{{% tablestep  number=3 %}}
-**Test the sensor**
-
-Click **Save** to apply your configuration changes.
-
-Now, click **Test** at the bottom of the sensor configuration card to view the readings.
-You can also see readings on the **CONTROL** tab.
-
-{{<imgproc src="/how-tos/telegraf-test.png" resize="1000x" style="width:600px" class="shadow imgzoom" declaredimensions=true alt="Test panel with readings displayed.">}}
-
-{{% /tablestep %}}
-{{< /table >}}
-{{% /tab %}}
-{{< /tabs >}}
-
-### Configure data management
-
-To capture or alert on the data from your configured sensor, you must add the [data management service](/data-ai/capture-data/capture-sync/) and configure it to capture and sync the sensor data:
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Add the data management service**
-
-On your machine's **CONFIGURE** page, click the **+** icon next to your machine part in the left-hand menu and select **Component or service**.
-
-Select the `data management / RDK` service and click **Create**.
-You can leave the default data sync interval of `0.1` minutes to sync every 6 seconds.
-Also leave both **Capturing** and **Syncing** toggles in the "on" position.
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Configure data capture on the sensor**
-
-Return to your sensor's configuration card.
-
-In the **Data capture** section, click **Add method**.
-
-From the **Method** dropdown select `Readings`.
-Set the **Frequency** to `0.05` Hz to capture readings once every 20 seconds.
-
-{{<imgproc src="/how-tos/capture-readings.png" resize="1000x" style="width:600px" class="shadow imgzoom" declaredimensions=true alt="Sensor readings capture configuration.">}}
-
-Click the **Save** button to apply your configuration changes.
-{{% /tablestep %}}
-{{% tablestep %}}
-**View synced data**
-
-Click the **...** menu in the upper-right corner of the sensor configuration card.
-Select **View captured data**.
-If you do not immediately see data, wait a minute for the data to be captured and synced at the intervals you specified, then refresh the page.
-
-![View of sensor data](/services/data/sensor-data.png)
-
-{{% /tablestep %}}
-{{< /table >}}
-
-### Configure trigger
-
-{{< tabs >}}
-{{% tab name="Builder mode" %}}
-
-Use **Builder mode** to create a trigger:
-
-{{< table >}}
-{{< tablestep >}}
-
-Go to the **CONFIGURE** tab of your machine.
-Click the **+** (Create) button in the left side menu and select **Trigger**.
-
-{{< /tablestep >}}
-{{< tablestep >}}
-**Create the trigger**
-
-Enter a name and click **Create**.
-
-{{< /tablestep >}}
-{{< tablestep >}}
-**Configure type**
-
-In the **Type** dropdown, choose one of the following types:
-
-- **Data has been synced to the cloud**:
-  Whenever your machine syncs data of any of the specified data types, the trigger sends an alert.
-
-  To use this trigger type, select the data types for which the trigger should send requests.
-
-- **Conditional data ingestion**:
-  Whenever your machine syncs data that meets certain criteria, the trigger sends an alert.
-
-  To use this trigger type:
-
-  1. Choose the target component and method for your condition.
-  1. Add a **condition**: specify a **key** in the synced data, an **operator**, and a **value**.
-     When data from the target component and method syncs from your machine, the trigger uses the key as a path to look up a value in the synced data object.
-     The trigger applies the operator to the extracted value and the value you specified in your condition.
-
-     For example, the following trigger sends an alert when the `cpu-monitor` component's `Readings` method syncs `cpu` usage greater than `50`:
-
-     {{<imgproc src="/build/configure/conditional-data-ingested.png" resize="x400" declaredimensions=true alt="Example conditional data ingestion trigger with a condition." class="shadow" >}}
-
-     For more information, see [Conditional attributes](/data-ai/reference/triggers-configuration/#conditional-attributes).
-
-{{< /tablestep >}}
-{{< tablestep >}}
-**Configure notification method and frequency**
-
-To add a notification method, add an entry to the **Webhooks** or **Alert options** sub-panels:
-
-To add an email notification for specific email addresses:
-
-1. Toggle **Email specific addresses** on and add the email addresses you wish to be notified whenever this trigger fires.
-1. Set the alert frequency (minimum time between notifications).
-
-To add an email notification for all machine owners:
-
-1. Toggle **Email all machine owners** on.
-1. Set the alert frequency (minimum time between notifications).
-
-To add a webhook notification:
-
-1.  Click **Add Webhook**.
-1.  Add the URL of your cloud function.
-1.  Set the alert frequency (minimum time between notifications).
-1.  Write your cloud function to process the [webhook](/data-ai/reference/triggers-configuration/#webhook-attributes).
-    Use your cloud function to process data or interact with any external API, including Twilio, PagerDuty, or Zapier.
-
-{{< /tablestep >}}
-{{< /table >}}
-
-{{% /tab %}}
-{{% tab name="JSON mode" %}}
-
-Use the following template in your `components` JSON to configure the top-level `triggers` field:
-
-{{< tabs >}}
-{{% tab name="Telemetry sync" %}}
-
-```json {class="line-numbers linkable-line-numbers"}
-"triggers": [
-  {
-    "name": "trigger-1",
-    "event": {
-      "type": "part_data_ingested",
-      "data_ingested": {
-        "data_types": ["binary", "tabular", "file", "unspecified"]
-      }
-    },
-    "notifications": [
-      {
-        "type": "<webhook|email>",
-        "value": "<webhook URL or email address or all_machine_owners>",
-        "seconds_between_notifications": <int>
-      }
-    ]
-  }
-]
-```
-
-{{% /tab %}}
-{{% tab name="Conditional telemetry sync" %}}
-
-```json {class="line-numbers linkable-line-numbers"}
-"triggers": [
-  {
-    "name": "<trigger name>",
-    "event": {
-      "type": "conditional_data_ingested",
-      "conditional": {
-        "data_capture_method": "<component>:<name-of-component>:<method>",
-        "conditions": {
-          "evals": [
-            {
-              "operator": "<lt|gt|lte|gte|eq|neq|regex>",
-              "value": <object, string, bool, regex, or int>
-            }
-          ]
-        }
-      }
-    },
-    "notifications": [
-      {
-        "type": "<webhook|email>",
-        "value": "<webhook URL or email address or all_machine_owners>",
-        "seconds_between_notifications": <number of seconds>
-      }
-    ]
-  }
-]
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-For more information about triggers, see [Trigger configuration](/data-ai/reference/triggers-configuration/).
-
-### Stop data capture
-
-If this is a test project, make sure you stop data capture to avoid charges for syncing unwanted data.
-
-In the **Data capture** section of your sensor's configuration, toggle the switch to **Off**.
-
-Click the **Save** button in the top right corner of the page to save your configuration.
-
-## Alert on machine logs
-
-{{< tabs >}}
-{{% tab name="Builder mode" %}}
-
-1. Go to the **CONFIGURE** tab of your machine.
-   Click the **+** (Create) button in the left side menu and select **Trigger**.
-
-1. Name the trigger and click **Create**.
-
-1. Select **Conditional logs ingestion** as the trigger **Type**.
-
-1. Select any number of log levels (**Error**, **Warn**, and **Info**) to alert on.
-
-   **Once per hour**, Viam issues an alert if machine logs are found.
-
-To add a notification method, add an entry to the **Webhooks** or **Alert options** sub-panels:
-
-To add an email notification for specific email addresses:
-
-1. Toggle **Email specific addresses** on and add the email addresses you wish to be notified whenever this trigger fires.
-1. Set the alert frequency (minimum time between notifications).
-
-To add an email notification for all machine owners:
-
-1. Toggle **Email all machine owners** on.
-1. Set the alert frequency (minimum time between notifications).
-
-To add a webhook notification:
-
-1.  Click **Add Webhook**.
-1.  Add the URL of your cloud function.
-1.  Set the alert frequency (minimum time between notifications).
-1.  Write your cloud function to process the [webhook](/data-ai/reference/triggers-configuration/#webhook-attributes).
-    Use your cloud function to process data or interact with any external API, including Twilio, PagerDuty, or Zapier.
-
-{{% /tab %}}
-{{% tab name="JSON mode" %}}
-
-Use the following template in your `components` JSON to configure the top-level `triggers` field:
-
-```json {class="line-numbers linkable-line-numbers"}
-"triggers": [
-  {
-    "name": "<trigger name>",
-    "event": {
-      "type": "conditional_logs_ingested",
-      "log_levels": [
-          "error",
-          "warn",
-          "info"
-        ]
-    },
-    "notifications": [
-      {
-        "type": "<webhook|email>",
-        "value": "<webhook URL or email address or all_machine_owners>"
-      }
-    ]
-  }
-]
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-For more information about triggers, see [Trigger configuration](/data-ai/reference/triggers-configuration/).
-
-## Alert on machine status
-
-### Part is online
-
-{{< tabs >}}
-{{% tab name="Builder mode" %}}
-
-1. Go to the **CONFIGURE** tab of your machine.
-   Click the **+** (Create) button in the left side menu and select **Trigger**.
-
-2. Name the trigger and click **Create**.
-
-3. Select **Part is online** as the trigger **Type**.
-
-4. To add a notification method, add an entry to the **Webhooks** or **Alert options** sub-panels:
-
-To add an email notification for specific email addresses:
-
-1. Toggle **Email specific addresses** on and add the email addresses you wish to be notified whenever this trigger fires.
-1. Set the alert frequency (minimum time between notifications).
-
-To add an email notification for all machine owners:
-
-1. Toggle **Email all machine owners** on.
-1. Set the alert frequency (minimum time between notifications).
-
-To add a webhook notification:
-
-1.  Click **Add Webhook**.
-1.  Add the URL of your cloud function.
-1.  Set the alert frequency (minimum time between notifications).
-1.  Write your cloud function to process the [webhook](/data-ai/reference/triggers-configuration/#webhook-attributes).
-    Use your cloud function to process data or interact with any external API, including Twilio, PagerDuty, or Zapier.
-
-{{% /tab %}}
-{{% tab name="JSON mode" %}}
-
-Use the following template in your `components` JSON to configure the top-level `triggers` field:
-
-```json {class="line-numbers linkable-line-numbers"}
-"triggers": [
-  {
-    "name": "<trigger name>",
-    "event": {
-      "type": "part_online"
-    },
-    "notifications": [
-      {
-        "type": "<webhook|email>",
-        "value": "<webhook URL or email address or all_machine_owners>",
-        "seconds_between_notifications": <number of seconds>
-      }
-    ]
-  }
-]
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-For more information about triggers, see [Trigger configuration](/data-ai/reference/triggers-configuration/).
-
-### Part is offline
-
-{{< tabs >}}
-{{% tab name="Builder mode" %}}
-
-1. Go to the **CONFIGURE** tab of your machine.
-   Click the **+** (Create) button in the left side menu and select **Trigger**.
-
-2. Name the trigger and click **Create**.
-
-3. Select **Part is offline** as the trigger **Type**.
-
-4. Add **Webhooks** or **Emails** and configure the time between notifications.
-   For more information on webhooks, see [Webhook attributes](/data-ai/reference/triggers-configuration/#webhook-attributes).
-
-{{% /tab %}}
-{{% tab name="JSON mode" %}}
-
-Use the following template in your `components` JSON to configure the top-level `triggers` field:
-
-```json {class="line-numbers linkable-line-numbers"}
-"triggers": [
-  {
-    "name": "<trigger name>",
-    "event": {
-      "type": "part_offline"
-    },
-     "notifications": [
-      {
-        "type": "webhook|email",
-        "value": "<webhook URL or email address or all_machine_owners>",
-        "seconds_between_notifications": <number of seconds>
-      }
-     ]
-  }
-]
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
-For more information about triggers, see [Trigger configuration](/data-ai/reference/triggers-configuration/).
diff --git a/docs/manage/troubleshoot/monitor.md b/docs/manage/troubleshoot/monitor.md
deleted file mode 100644
index 02cf4f7310..0000000000
--- a/docs/manage/troubleshoot/monitor.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-linkTitle: "Monitor machine status"
-title: "Monitor machine status"
-weight: 10
-layout: "docs"
-type: "docs"
-description: "Monitor the status of all machines in an organization and investigate issues when needed."
----
-
-You can view all machines in an organization from a dashboard and access each machine from it.
-
-{{< table >}}
-{{% tablestep start=1 %}}
-**Monitor your fleet's parts statuses and synced data**
-
-You can monitor your machines from your **FLEET**'s [**ALL MACHINES** subtab](https://app.viam.com/fleet/machines).
-You can also monitor the amount of binary and tabular data your fleet has synced in the last 48 hours from the same dashboard.
-
-{{< imgproc src="/fleet/dashboard.png" alt="Fleet dashboard showing the machine parts, location, status, architecture and more" style="width:800px" resize="1200x" class="imgzoom shadow" >}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Investigate machine status**
-
-If you click on a machine part, you can get more information about the machine.
-At the top of the machine page, there is an indicator of the machine's status.
-Click on the **status** dropdown to open a menu with information about each {{< glossary_tooltip term_id="part" text="part" >}} of your machine.
-Once you connect to the `viam-server` instance on a part, this display includes its OS, Host, `viam-server` version, IP addresses, and what time it was last online or remote address (if live):
-
-{{<imgproc src="/fleet/app-usage/machine-page.png" resize="600x" declaredimensions=true  class="shadow" alt="The machine page with part menu expanded">}}
-
-{{% /tablestep %}}
-{{% tablestep %}}
-**Test your machines remotely**
-
-On a machine's [**CONTROL** tab](/manage/troubleshoot/teleoperate/default-interface/#web-ui), you can remotely operate the machine and test its resources.
-
-{{<gif webm_src="/fleet/control.webm" mp4_src="/fleet/control.mp4" alt="Using the control tab" max-width="800px" class="shadow">}}
-
-{{% /tablestep %}}
-{{< /table >}}
diff --git a/docs/manage/troubleshoot/teleoperate/_index.md b/docs/manage/troubleshoot/teleoperate/_index.md
deleted file mode 100644
index f1232d5aef..0000000000
--- a/docs/manage/troubleshoot/teleoperate/_index.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-linkTitle: "Teleoperate"
-title: "Teleoperate"
-weight: 30
-layout: "empty"
-type: "docs"
-empty_node: true
----
diff --git a/docs/manage/troubleshoot/teleoperate/custom-interface.md b/docs/manage/troubleshoot/teleoperate/custom-interface.md
deleted file mode 100644
index fdecef522c..0000000000
--- a/docs/manage/troubleshoot/teleoperate/custom-interface.md
+++ /dev/null
@@ -1,183 +0,0 @@
----
-title: "Teleoperate with a custom control interface"
-linkTitle: "Custom interface"
-weight: 25
-type: "docs"
-description: "Use a teleop workspace to create a custom control interface for operating a machine or visualizing and aggregating its data."
-tags: ["teleop", "fleet management", "control", "app"]
-languages: []
-viamresources: ["sensor", "camera", "movement sensor"]
-platformarea: ["viz", "data"]
-images: ["/how-tos/teleop/full-workspace.png"]
-level: "Intermediate"
-date: "2024-11-13"
-updated: "2025-09-10"
-cost: "0"
----
-
-You can remotely operate any configured machine and visualize and aggregate its data using a custom control interface.
-
-## Prerequisites
-
-{{% expand "A configured machine with teleoperable components" %}}
-
-Make sure your machine has at least one camera, movement sensor, sensor, base, arm, board, gantry, gripper, motor or servo.
-
-See [configure a machine](/operate/modules/configure-modules/) for more information.
-
-{{% /expand%}}
-
-### Create a workspace
-
-1. Navigate to the **FLEET** page's [**TELEOP** tab](https://app.viam.com/teleop).
-   Click **+ Create workspace**.
-
-1. Enter a unique name for your workspace in the top left of the page, replacing the placeholder `untitled-workplace` text.
-
-1. Use the **Select location** dropdown to select the location that contains the machine that you would like to visualize data from.
-
-1. Use the **Select machine** dropdown to select the machine that you would like to visualize data from.
-
-## Add a widget
-
-1. Click **Add widget** and select a widget type to create a new widget on your workspace.
-
-   See [widget types](/manage/troubleshoot/teleoperate/custom-interface/#widget-types) for more information about each type.
-
-1. To configure the widget, click the pencil icon in the top right of your widget:
-
-   {{<imgproc src="/services/data/visualize-widget-configure.png" alt="Click the pencil icon to configure your widget." style="width:500px" resize="1200x" class="imgzoom fill shadow" >}}
-
-You can mix and match multiple widgets to visualize many kinds of data collected by your machine:
-
-{{<imgproc src="/services/data/visualize-workspace.png" resize="1200x" style="width: 700px" class="fill imgzoom shadow" declaredimensions=true alt="Workspace containing.">}}
-
-To arrange widgets on your workspace, click and drag the grid icon in the top left of your widget:
-
-{{<imgproc src="/services/data/visualize-widget-move.png" alt="Click the grid icon to move a widget." style="width:500px" resize="1200x" class="imgzoom fill shadow" >}}
-
-## Widget types
-
-Viam provides the following types of widgets that you can customize to visualize data synced from your machines:
-
-### Actuation
-
-The actuation widget allows you to operate actuating components:
-
-{{<imgproc src="/services/data/visualize-widget-actuation.png" resize="800x" style="width: 500px" class="fill imgzoom shadow" declaredimensions=true alt="An actuation widget displaying servo controls.">}}
-
-To configure the actuation widget:
-
-1. Choose a type from the **Component type** dropdown.
-1. Choose a method from the **Method** dropdown.
-1. Choose a component from the **Actuating component name** dropdown.
-1. Click **Save**.
-
-### Camera stream
-
-The camera stream widget displays a live feed of the most recent image captured by a camera component:
-
-{{<imgproc src="/services/data/visualize-widget-camera.png" resize="800x" style="width: 500px" class="fill imgzoom shadow" declaredimensions=true alt="A camera widget displaying a live camera feed.">}}
-
-To configure the camera widget:
-
-1. Choose a camera from the **Camera name** dropdown.
-1. Select the **Refresh type**.
-1. Click **Save**.
-
-### GPS
-
-The GPS widget displays the current GPS location of any sensor that reports a position:
-
-{{<imgproc src="/services/data/visualize-widget-gps.png" resize="800x" style="width: 500px" class="fill imgzoom shadow" declaredimensions=true alt="A GPS widget displaying a live location.">}}
-
-To configure the camera widget:
-
-1. Choose a movement sensor from the **Movement sensor name** dropdown.
-1. Specify the **Refresh rate** in seconds.
-1. Choose to include Historic positions.
-1. Click **Save**.
-
-### Stat
-
-The stat widget displays the most recent reading recorded by any sensor that produces tabular data:
-
-{{<imgproc src="/services/data/visualize-widget-stat.png" resize="800x" style="width: 500px" class="fill imgzoom shadow" declaredimensions=true alt="A stat widget displaying a live sensor reading.">}}
-
-To configure the stat widget:
-
-1. Choose a sensor from the **Sensor name** dropdown.
-1. Select the reading you would like to display from the **Path** dropdown.
-1. Assign a title, a unit suffix, and a refresh rate.
-1. Click **Save**.
-
-### Table
-
-The table widget displays a grid of historic tabular data values. You can display multiple fields simultaneously in a single table.
-Each row in the table represents a separate historic reading; each column represents a field.
-
-{{<imgproc src="/services/data/visualize-widget-table.png" resize="800x" style="width: 500px" class="fill imgzoom shadow" declaredimensions=true alt="A table widget displaying a grid of sensor readings.">}}
-
-To configure the table widget, define the following attributes:
-
-1. From the **Resource name** dropdown, choose a sensor you would like to visualize.
-1. From the **Capture method** dropdown, choose a method of data capture (for example **Readings**).
-1. Specify the **Refetch rate** in seconds.
-1. Specify the **Time range** in seconds.
-
-1. Use a custom MQL aggregation pipeline stage (or series of stages) to transform your sensor data into a flat object where each field corresponds to a column for the table.
-   Consider the following sensor data, which contains information about air quality in a field named `readings`:
-
-   ```json
-   "data" {
-     "readings": {
-       "gas_resistance": 114978.66606781945,
-       "temperature": 22.96,
-       "pressure": 1016.18,
-       "humidity": 48.318
-     }
-   }
-   ```
-
-   To change the displayed names, use a `$project` stage:
-
-   ```mql
-   {
-     "$project": {
-       "Air Quality": "$data.readings.gas_resistance",
-       "Humidity": "$data.readings.humidity",
-       "Temperature": "$data.readings.temperature"
-     }
-   }
-   ```
-
-   For more information about MQL aggregation operators, see the [MongoDB documentation](https://www.mongodb.com/docs/manual/reference/mql/aggregation-stages/).
-
-1. Click **Save**.
-
-### Time series
-
-The time series widget creates a graph of tabular data. You can add multiple lines to the time series widget to compare multiple readings over the same time period:
-
-{{<imgproc src="/services/data/visualize-widget-time-series.png" resize="1000x" style="width: 500px" class="fill imgzoom shadow" declaredimensions=true alt="A time series widget displaying a live graph of sensor data over time.">}}
-
-To configure the time series widget, define the following attributes for each line in the time series:
-
-1. From the **Resource name** dropdown, choose a sensor you would like to visualize.
-1. From the **Capture method** dropdown, choose a method of data capture (for example **Readings**).
-1. In the **Title** field, enter a name for the line.
-1. From the **Path** dropdown, choose the field of data that this line should visualize.
-
-1. Use the other fields to customize the unit, duration, and other aspects of your visualization.
-
-1. The **Window method** allows you to aggregate sensor readings over specified time intervals instead of displaying raw data points.
-   Select a window method from the following options:
-
-   - **None**: shows raw data with the path specified with no aggregation
-   - **Count**: shows the number of readings within the window
-   - **Average**: calculates the average value throughout the window
-   - **Minimum**: shows the minimum value within the window
-   - **Maximum**: shows the maximum value within the window
-   - **Custom query**: shows the result of a custom MQL aggregation pipeline that you define
-
-1. Click **Save**.
diff --git a/docs/manage/troubleshoot/teleoperate/default-interface.md b/docs/manage/troubleshoot/teleoperate/default-interface.md
deleted file mode 100644
index 07351a59ac..0000000000
--- a/docs/manage/troubleshoot/teleoperate/default-interface.md
+++ /dev/null
@@ -1,61 +0,0 @@
----
-title: "Teleoperate with the default control interface"
-linkTitle: "Default interface"
-titleMustBeLong: true
-weight: 30
-type: "docs"
-description: "Use the control tab or the Viam mobile app to monitor and remotely operate your machines."
-tags: ["teleop", "fleet management", "control", "app"]
-languages: []
-viamresources: ["sensor", "camera", "movement sensor"]
-platformarea: ["viz", "data"]
-images: ["/how-tos/teleop/full-workspace.png"]
-level: "Intermediate"
-date: "2024-11-13"
-# updated: ""  # When the content was last entirely checked
-cost: "0"
-next: "/manage/troubleshoot/troubleshoot/"
-aliases:
-  - /fleet/control/
-  - /manage/app-usage/
----
-
-You can remotely control, test, and operate any configured machine using the default control interface
-
-## Web UI
-
-The **CONTROL** tab provides a control interface for each component and service that you have configured for your machine.
-
-For example, if you have configured a base with wheels, you can move your machine's with an arrow pad and control the base's speed by setting its power with a slider.
-If you have configured a camera component, a window in the **CONTROL** tab displays the camera output.
-
-{{<gif webm_src="/fleet/control.webm" mp4_src="/fleet/control.mp4" alt="Using the control tab" max-width="800px">}}
-
-You can also switch between different machine parts directly from the **CONTROL** tab and control the selected machine part.
-
-## Viam mobile app
-
-{{<gif webm_src="/fleet/mobile-app-control.webm" mp4_src="/fleet/mobile-app-control.mp4" alt="Using the control interface under the locations tab on the Viam mobile app" class="alignright" max-width="300px">}}
-
-Like the web UI, the [Viam mobile app](/manage/troubleshoot/teleoperate/default-interface/#viam-mobile-app) also allows you to test, monitor and remotely operate machines in your fleet.
-
-For example, you can view live camera feeds, adjust components' runtime parameters, and switch between controllable components.
-
-Additionally, the app allows you to:
-
-- see if your machines are online
-- [view a machine's logs](/manage/troubleshoot/troubleshoot/#check-logs)
-- [upload images from your phone to the cloud](/data-ai/capture-data/upload-other-data/#upload-images-with-the-viam-mobile-app)
-- [invite people to collaborate with you and modify access](/manage/troubleshoot/teleoperate/default-interface/#viam-mobile-app)
-
-<br>
-
-You can find the mobile app on the [App Store](https://apps.apple.com/vn/app/viam-robotics/id6451424162) and on [Google Play](https://play.google.com/store/apps/details?id=com.viam.viammobile&hl=en&gl=US).
-
-<a href="https://apps.apple.com/vn/app/viam-robotics/id6451424162" target="_blank">
-  <img src="/appstore.png" width="200px" alt="apple store icon" class="center-if-small" >
-</a>
-
-<a href="https://play.google.com/store/apps/details?id=com.viam.viammobile&hl=en&gl=US" target="_blank">
-  <img src="/googleplay.png" width="200px" alt="google play store icon" class="center-if-small" >
-</a>
diff --git a/docs/manage/troubleshoot/troubleshoot.md b/docs/manage/troubleshoot/troubleshoot.md
deleted file mode 100644
index 22525b56f1..0000000000
--- a/docs/manage/troubleshoot/troubleshoot.md
+++ /dev/null
@@ -1,304 +0,0 @@
----
-linkTitle: "Troubleshoot problems"
-title: "Troubleshoot problems"
-weight: 35
-layout: "docs"
-type: "docs"
-description: "A guide to troubleshooting a Viam-based machine or system of machines with fixes to common problems."
-date: "2025-01-07"
-# updated: ""  # When the content was last entirely checked
-aliases:
-  - /appendix/troubleshooting/
----
-
-If your machine is not working as expected, there are several steps you can take for debugging.
-Start by checking the machine logs.
-If that doesn't help, you can enable debug logs or `ssh` into the machine.
-
-For common errors see [Common Errors](/dev/tools/common-errors/).
-
-## Check logs
-
-### Machine shows as offline
-
-If your machine shows as offline on Viam, restart `viam-server` by running the command to start `viam-server` and adding the `-debug` option.
-
-To do this, you will need to know if you installed `viam-server` with `viam-agent` (most common) or manually.
-You can check this by seeing if `viam-agent` is running.
-Run the following command:
-
-```sh {class="command-line" data-prompt="$" data-output="2"}
-ps aux | grep viam-agent
-root      566431  0.5  0.2 1247148 20336 ?       Ssl  11:24   0:00 /opt/viam/bin/viam-agent --config /etc/viam.json
-```
-
-If you see a process running viam-agent, then you used `viam-agent` to install `viam-server`.
-If not follow the steps for the standalone version.
-
-{{< tabs >}}
-{{% tab name="Installed with viam-agent" %}}
-
-On Linux, you can query your logs with `journalctl`:
-
-```sh {class="command-line" data-prompt="$" data-output="2-10"}
-sudo journalctl --unit=viam-agent
-```
-
-Alternatively you can restart `viam-server` manually and write logs to a log file:
-
-1. First check where the `viam-server` binary is and where the machine cloud credentials file for your machine is:
-
-   ```sh {class="command-line" data-prompt="$" data-output="2"}
-   ps aux | grep viam-server
-   root      566219 83.6  1.1 1966984 88896 ?       Sl   11:17   0:02 /opt/viam/bin/viam-server -config /etc/viam.json
-   ```
-
-2. Stop `viam-agent`:
-
-   ```sh {class="command-line" data-prompt="$" data-output=""}
-   sudo systemctl stop viam-agent
-   ```
-
-3. Then run `viam-server` with the `-debug` option and pass in your machine cloud credentials file:
-
-   ```sh {class="command-line" data-prompt="$" data-output=""}
-   /opt/viam/bin/viam-server -debug -config /etc/viam.json -log-file logs.txt
-   ```
-
-4. Then check the logs file <FILE>logs.txt</FILE>.
-
-{{% /tab %}}
-{{% tab name="Manual" %}}
-
-{{< tabs >}}
-{{% tab name="Linux" %}}
-
-On Linux, you can query your logs with `journalctl`:
-
-```sh {class="command-line" data-prompt="$" data-output="2-10"}
-sudo journalctl --unit=viam-server
-```
-
-Alternatively you can restart `viam-server` and write logs to a log file by stopping the running `viam-server` instance, and restarting it with the `-logfile` option:
-
-1. First check where the `viam-server` binary is and where the machine cloud credentials file for your machine is:
-
-   ```sh {class="command-line" data-prompt="$" data-output="2"}
-   ps aux | grep viam-server
-   root       865  1.6  0.2  11612  2428 ?        Ssl  11:42   0:56 /usr/local/bin/viam-server -config /etc/viam.json
-   ```
-
-1. Stop the system service running `viam-server`:
-
-   ```sh {class="command-line" data-prompt="$" data-output=""}
-   sudo systemctl stop viam-server
-   ```
-
-1. Then run `viam-server` with the `-debug` and `-log-file` options and pass in your machine cloud credentials file:
-
-   ```sh {class="command-line" data-prompt="$" data-output=""}
-   sudo /usr/local/bin/viam-server -debug -config /etc/viam.json -log-file logs.txt
-   ```
-
-1. Then check the logs file <FILE>logs.txt</FILE>.
-
-{{% /tab %}}
-{{% tab name="macOS" %}}
-
-By default, `viam-server` writes logs to STDOUT and does not store them in a file on your machine.
-If you want to store your logs in a file, stop the running `viam-server` instance, and restart it with the `-logfile` option.
-
-1. First check where the `viam-server` binary is and where the machine cloud credentials file for your machine is:
-
-   ```sh {class="command-line" data-prompt="$" data-output="2-3"}
-   ps aux | grep viam-server
-   naomi             8738   1.1  0.3 412233296  50720 s000  S+    5:24pm   0:00.40 viam-server -config /Users/naomi/Downloads/viam-mac-main.json
-   ```
-
-1. Kill the running `viam-server` instance.
-1. Then run `viam-server` with the `-debug` and `-log-file` options and pass in your machine cloud credentials file:
-
-   ```sh {class="command-line" data-prompt="$" data-output=""}
-   viam-server -config ~/Downloads/viam.json -debug -log-file logs.txt
-   ```
-
-1. Then check the logs file <FILE>logs.txt</FILE>.
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{% /tab %}}
-{{< /tabs >}}
-
-{{< alert title="Note" color="note" >}}
-Be aware that while your machine is not able to connect to Viam, any changes to the machine's configuration that you make in the web UI will not reach your machine.
-{{< /alert >}}
-
-### Machine shows as online
-
-#### Check for errors on the CONFIGURE page
-
-Go to your machine's **CONFIGURE** page and check whether any configured components have a red exclamation symbol on their configuration card.
-If so click on the symbol or expand the **ERROR LOGS** panel.
-The expanded panel shows you errors produced by that resource.
-
-#### Check logs on the LOGS tab
-
-If your machine shows as online, go to the **LOGS** tab and check for errors or other information relevant to the issue.
-
-{{<gif webm_src="/fleet/log-filtering.webm" mp4_src="/fleet/log-filtering.mp4" alt="Filter logs by term of log level in the UI" max-width="800px">}}
-
-You can filter your logs by keyword, log levels and time.
-You can use a regular expression as your keyword.
-
-The default log level for `viam-server` and any running resources is `Info`.
-If you are not seeing helpful logs, you can try changing the log level to `Debug`.
-
-You can enable debug logs for all resources on a machine by adding `"debug": true` to the machine's JSON configuration:
-
-```json
-{
-  "debug": true,
-  "components": [{ ... }]
-}
-```
-
-If this produces too many logs, you can instead **enable debug logs** for individual resources using the **...** menu on each resource.
-You can also set the log level by configuring the `log` attribute in the machine configuration to match on patterns that capture the resources you are interested in.
-For example:
-
-```json
-"components": [ ... ]
-"log": [
-    {
-    "pattern": "rdk.components.arm",
-    "level": "debug",
-    }, {
-    "pattern": "rdk.services.*",
-    "level": "debug",
-    }, {
-    "pattern": "<module-name>",
-    "level": "debug",
-    }
-]
-```
-
-For more information on setting log levels see, [Logging](/operate/reference/viam-server/#logging).
-
-You may also find that not all logs you are expecting are displayed.
-By default, `viam-server` deduplicates log messages that are deemed noisy.
-To disable this behavior, see [Disable log deduplication](/operate/reference/viam-server/).
-
-To access logs from the commandline, use [`viam machines logs`](/dev/tools/cli/#machines-alias-robots-and-machine) on the command line or the [Machines API](/dev/reference/apis/robot/).
-
-### Advanced debugging for Go modules
-
-If you have a Go module that doesn't shut down properly or hangs during operation, you can get more information by sending a SIGQUIT signal to the process.
-Run the following command, replacing `<PID>` with your module's process identifier:
-
-```sh {class="command-line" data-prompt="$"}
-kill -3 <PID>
-```
-
-The process will dump a stack trace, visible in the `viam-server` logs, that shows:
-
-- All currently running goroutines and their states
-- Where execution is blocked or deadlocked
-- Internal state information that might not appear in regular logs
-
-{{% hiddencontent %}}
-
-### Verify module startup completion
-
-To verify if a module has successfully started, check the machine logs for specific startup messages:
-
-1. Go to your machine's **LOGS** tab.
-
-1. Look for log messages related to your module.
-1. You can filter the logs by typing the module name in the search box to focus only on messages related to your specific module.
-   When a module starts successfully, you'll see a sequence of log messages similar to:
-
-   ```sh {id="terminal-prompt" class="command-line" data-prompt="$"}
-   info rdk.module.manager           module/manager.go:XXX        Starting up module         module <module-name>
-   info rdk.module.manager           module/manager.go:XXX        Module successfully added  module <module-name>
-   info rdk.modmanager               modmanager/manager.go:xxx    Modules successfully added modules [<module-name>]
-   info rdk.resource_manager         impl/resource_manager.go:xxx Now configuring resource   resource <api-triplet>/<model-name>
-   info rdk.modmanager.<module-name> modmanager/manager.go:xxx    Adding resource to module  resource <model-name> module <module-name>
-   ```
-
-1. If you don't see a "successfully added" message or "adding resource to module," look for error messages that might indicate why the module failed to start completely.
-
-{{% /hiddencontent %}}
-
-## Capture machine telemetry data
-
-Some issues are due to overall system health.
-To rule out machine health as the root cause of your issues, [add a machine telemetry sensor](/manage/troubleshoot/alert/#add-performance-sensor) and [capture machine telemetry data with the data management service](/manage/troubleshoot/alert/#configure-data-management).
-
-## Use `viam-server` debug endpoints
-
-You can use [`pprof`](https://pkg.go.dev/net/http/pprof) to:
-
-- diagnose performance bottlenecks
-- investigate memory leaks
-- understand resource usage patterns
-- troubleshoot high CPU or memory usage
-
-To enable the pprof endpoints, set `enable_web_profile` to `true` in your machine configuration:
-
-```json
-{
-  "components": [...],
-  "services": [...],
-  "enable_web_profile": true
-}
-```
-
-For more information on advanced debugging endpoints, see [Advanced debug endpoints](/operate/reference/viam-server/debug-endpoints/).
-
-## Remote shell on the machine
-
-To remotely access your machine from your terminal:
-
-1. Add the [ViamShellDanger fragment](https://app.viam.com/fragment/b511adfa-80ab-4a70-9bd5-fbb14696b17e/json) to your machine.
-1. Once you have added the fragment, you can use the [Viam CLI](/dev/tools/cli/) to open a shell on the machine.
-
-   ```sh {class="command-line" data-prompt="$" data-output="2-10"}
-   viam machines part shell --organization=<org name> --location=<location name> --machine=<machine id>
-   ```
-
-1. You can [access the local log file](/operate/reference/viam-server/manage-viam-server/#view-viam-server-logs) on your machine if needed.
-
-1. If you need to copy files from your machine, use the [`viam machine part cp`](/dev/tools/cli/#machines-alias-robots-and-machine) command.
-
-## Restart your machine
-
-1. Navigate to your machine's page.
-1. Select the part status dropdown to the right of your machine's name on the top of the page.
-   {{<imgproc src="configure/machine-part-info.png" resize="500x" declaredimensions=true alt="machine cloud credentials button on the machine part info dropdown" class="shadow" >}}
-1. If you installed `viam-server` with `viam-agent` you will see a **Restart** button. Click it.
-   Both `viam-server` and `viam-agent` will restart.
-
-   If you do not see the **Restart** button, click the **...** menu on the right side of the machine part's card, and select **Restart part**.
-   If restarting the machine part does not resolve the issue, ssh into the machine and [stop and restart viam-server manually](/operate/reference/viam-server/manage-viam-server/#run-viam-server).
-
-It takes a few minutes for `viam-server` to shut down and restart.
-
-## Revert to earlier configuration
-
-Viam keeps a record of your configuration changes, allowing you to revert to earlier configurations if needed.
-To see the history of the configuration of a machine part, click on **History** on the **CONFIGURE** tab.
-
-{{<imgproc src="build/configure/history.png" resize="800x" declaredimensions=true alt="Configuration history for a machine part" class="shadow">}}
-
-To restore to an earlier version of your configuration, click the **Restore version** button next to the desired configuration.
-
-## Share a location with Viam support
-
-If you have additional questions on debugging your machine, reach out to us on our [Community Discord](https://discord.gg/viam).
-Please post the error message you received along with the steps you took that caused the issue and we'll see if we can help.
-
-If you request support, you may be asked to share your location with the Viam Support team.
-To do so, navigate to the location you need support with and click, **Add Viam support**.
-
-Once you have received support, you can remove Viam Support from your location by clicking **Remove Viam support**.
diff --git a/docs/monitor/_index.md b/docs/monitor/_index.md
new file mode 100644
index 0000000000..6828b37a7b
--- /dev/null
+++ b/docs/monitor/_index.md
@@ -0,0 +1,12 @@
+---
+linkTitle: "Monitor and operate"
+title: "Monitor and operate"
+weight: 220
+layout: "docs"
+type: "docs"
+no_list: true
+manualLink: "/monitor/overview/"
+description: "Monitor machine status, visualize data, set up alerts, teleoperate machines, and troubleshoot problems."
+aliases:
+  - /manage/troubleshoot/
+---
diff --git a/docs/monitor/alert.md b/docs/monitor/alert.md
new file mode 100644
index 0000000000..eb787df7bc
--- /dev/null
+++ b/docs/monitor/alert.md
@@ -0,0 +1,329 @@
+---
+linkTitle: "Set up alerts"
+title: "Set up alerts"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "Configure triggers to receive email or webhook notifications when machines need attention."
+aliases:
+  - /manage/troubleshoot/alert/
+  - /build/configure/webhooks/
+  - /build/configure/triggers/
+  - /configure/triggers/
+  - /how-tos/performance-metrics/
+  - /data/capture/performance-metrics/
+  - /services/data/capture/performance-metrics/
+---
+
+Configure triggers to receive email or webhook notifications when your machines need attention. Triggers fire when specific events occur, such as a sensor reading crossing a threshold, a machine going offline, or error logs appearing.
+
+## Types of alerts
+
+| Trigger type          | Fires when                               | Use case                                                     |
+| --------------------- | ---------------------------------------- | ------------------------------------------------------------ |
+| Telemetry sync        | Data syncs from a machine to the cloud   | Know when any data arrives                                   |
+| Conditional telemetry | Synced data meets a condition you define | CPU above 80%, temperature below freezing, battery under 20% |
+| Machine logs          | Error, warning, or info logs appear      | Catch errors without watching the LOGS tab                   |
+| Part online           | A machine part comes online              | Know when a machine reconnects after maintenance             |
+| Part offline          | A machine part goes offline              | Respond to unexpected disconnections                         |
+
+## Prerequisites
+
+{{% expand "A running machine connected to Viam." %}}
+
+{{% snippet "setup.md" %}}
+
+{{% /expand %}}
+
+## Alert on telemetry
+
+To alert on sensor data, you need three things: a sensor producing data, the data management service capturing and syncing that data, and a trigger that fires when the data arrives or meets a condition.
+
+### Add a performance sensor
+
+To monitor machine health metrics like CPU usage, memory, and temperature, add a performance metrics sensor.
+
+{{< tabs >}}
+{{% tab name="Linux" %}}
+
+On your machine's **CONFIGURE** page, click the **+** icon next to your machine part and select **Component or service**.
+Search for and add the `hwmonitor:cpu_monitor` model from the [`sbc-hwmonitor`](https://app.viam.com/module/rinzlerlabs/sbc-hwmonitor) module.
+
+You can add additional sensors for memory, temperature, and other metrics.
+See the [`sbc-hwmonitor` module page](https://app.viam.com/module/rinzlerlabs/sbc-hwmonitor) for the full list.
+
+{{% /tab %}}
+{{% tab name="macOS" %}}
+
+First install [`telegraf`](https://github.com/influxdata/telegraf):
+
+```sh {class="command-line" data-prompt="$"}
+brew install telegraf
+```
+
+On your machine's **CONFIGURE** page, click the **+** icon next to your machine part and select **Component**.
+Search for and add the [`viam-sensor:telegrafsensor` model](https://github.com/viam-modules/viam-telegraf-sensor).
+
+You can add additional sensors for other metrics.
+See the [`viam-telegraf-sensor` module page](https://app.viam.com/module/viam/viam-telegraf-sensor) for the full list.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Click **Save**, then click **Test** at the bottom of the sensor configuration card to verify readings are coming through.
+
+### Configure data capture
+
+1. On your sensor's configuration card, click the **Data Capture** button.
+1. If you see a "Data management service missing" banner, click
+   **Create data management service**, click **Save**, navigate back to
+   your sensor, and click the **Data Capture** button again.
+1. Select `Readings` from the **Method** dropdown and set the **Frequency** to `0.05` Hz (once every 20 seconds).
+1. Click **Save**.
+
+To verify data is syncing, click the **...** menu on the sensor card and select **View captured data**.
+Wait a minute for data to capture and sync, then refresh.
+
+### Configure the trigger
+
+{{< tabs >}}
+{{% tab name="Builder mode" %}}
+
+1. Go to the **CONFIGURE** tab.
+   Click **+** in the left sidebar and select **Trigger**.
+1. Enter a name and click **Create**.
+1. In the **Type** dropdown, choose:
+   - **Data has been synced to the cloud**: fires whenever data of the selected types syncs.
+   - **Conditional data ingestion**: fires when synced data meets a condition you define.
+     Choose the target component and method, then add a condition with a key, operator, and value.
+     For example, to alert when CPU usage exceeds 50%: select your cpu-monitor component, Readings method, key `cpu`, operator `greater than`, value `50`.
+1. Add notification methods:
+   - **Email specific addresses**: toggle on, add addresses, set alert frequency.
+   - **Email all machine owners**: toggle on, set alert frequency.
+   - **Webhook**: click **Add Webhook**, enter your cloud function URL, set alert frequency.
+     See [Trigger configuration](/reference/triggers/#webhook-attributes) for webhook payload details.
+1. Click **Save**.
+
+{{% /tab %}}
+{{% tab name="JSON mode" %}}
+
+Add a `triggers` field to your machine configuration:
+
+{{< tabs >}}
+{{% tab name="Telemetry sync" %}}
+
+```json {class="line-numbers linkable-line-numbers"}
+"triggers": [
+  {
+    "name": "trigger-1",
+    "event": {
+      "type": "part_data_ingested",
+      "data_ingested": {
+        "data_types": ["binary", "tabular", "file"]
+      }
+    },
+    "notifications": [
+      {
+        "type": "email",
+        "value": "you@example.com",
+        "seconds_between_notifications": 300
+      }
+    ]
+  }
+]
+```
+
+{{% /tab %}}
+{{% tab name="Conditional telemetry" %}}
+
+```json {class="line-numbers linkable-line-numbers"}
+"triggers": [
+  {
+    "name": "cpu-alert",
+    "event": {
+      "type": "conditional_data_ingested",
+      "conditional": {
+        "data_capture_method": "sensor:cpu-monitor:Readings",
+        "conditions": {
+          "evals": [
+            {
+              "operator": "gt",
+              "value": {
+                "cpu": 50
+              }
+            }
+          ]
+        }
+      }
+    },
+    "notifications": [
+      {
+        "type": "email",
+        "value": "you@example.com",
+        "seconds_between_notifications": 600
+      }
+    ]
+  }
+]
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Stop data capture
+
+If this is a test, stop data capture to avoid charges for syncing unwanted data.
+In the **Data capture** section of your sensor's configuration, toggle the switch to **Off** and click **Save**.
+
+## Alert on machine logs
+
+Configure a trigger that fires when machine logs of a specified level appear.
+Viam checks for matching logs once per hour.
+
+{{< tabs >}}
+{{% tab name="Builder mode" %}}
+
+1. Go to the **CONFIGURE** tab.
+   Click **+** in the left sidebar and select **Trigger**.
+1. Enter a name and click **Create**.
+1. Select **Conditional logs ingestion** as the trigger **Type**.
+1. Select the log levels to alert on: **Error**, **Warn**, or **Info**.
+1. Add notification methods (email or webhook) and set the alert frequency.
+1. Click **Save**.
+
+{{% /tab %}}
+{{% tab name="JSON mode" %}}
+
+```json {class="line-numbers linkable-line-numbers"}
+"triggers": [
+  {
+    "name": "error-log-alert",
+    "event": {
+      "type": "conditional_logs_ingested",
+      "log_levels": ["error", "warn"]
+    },
+    "notifications": [
+      {
+        "type": "email",
+        "value": "you@example.com"
+      }
+    ]
+  }
+]
+```
+
+The notification interval for log triggers is always one hour.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Alert on machine status
+
+### Part online
+
+{{< tabs >}}
+{{% tab name="Builder mode" %}}
+
+1. Go to the **CONFIGURE** tab.
+   Click **+** in the left sidebar and select **Trigger**.
+1. Enter a name and click **Create**.
+1. Select **Part is online** as the trigger **Type**.
+1. Add notification methods and set the alert frequency.
+1. Click **Save**.
+
+{{% /tab %}}
+{{% tab name="JSON mode" %}}
+
+```json {class="line-numbers linkable-line-numbers"}
+"triggers": [
+  {
+    "name": "machine-online",
+    "event": {
+      "type": "part_online"
+    },
+    "notifications": [
+      {
+        "type": "email",
+        "value": "you@example.com",
+        "seconds_between_notifications": 600
+      }
+    ]
+  }
+]
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Part offline
+
+{{< tabs >}}
+{{% tab name="Builder mode" %}}
+
+1. Go to the **CONFIGURE** tab.
+   Click **+** in the left sidebar and select **Trigger**.
+1. Enter a name and click **Create**.
+1. Select **Part is offline** as the trigger **Type**.
+1. Add notification methods and set the alert frequency.
+1. Click **Save**.
+
+{{% /tab %}}
+{{% tab name="JSON mode" %}}
+
+```json {class="line-numbers linkable-line-numbers"}
+"triggers": [
+  {
+    "name": "machine-offline",
+    "event": {
+      "type": "part_offline"
+    },
+    "notifications": [
+      {
+        "type": "email",
+        "value": "you@example.com",
+        "seconds_between_notifications": 300
+      }
+    ]
+  }
+]
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Viam uses a 60-second buffer before declaring a part offline.
+This prevents false alerts from brief network interruptions.
+
+## Manage alert frequency
+
+Every notification method has a `seconds_between_notifications` setting that controls the minimum time between consecutive alerts.
+If a trigger fires more frequently than this interval, Viam suppresses the extra notifications.
+
+Set this value based on how quickly you need to respond:
+
+- **Critical alerts** (machine offline, safety thresholds): 60-300 seconds
+- **Operational alerts** (elevated CPU, low battery): 300-600 seconds
+- **Informational alerts** (data sync confirmations): 3600 seconds or more
+
+Starting with a longer interval and shortening it as needed is better than starting short and dealing with notification noise.
+
+## Use the CLI
+
+You can also manage triggers from the command line:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part add-trigger --part <part-name-or-id>
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part delete-trigger --part <part-name-or-id> --name <trigger-name>
+```
+
+## Other alert types
+
+- For alerts based on data sync events (not tied to machine health), see [Trigger on data events](/data/trigger-on-data/).
+- For alerts when an ML model detects specific objects or classifications, see [Alert on detections](/vision/alert-on-detections/).
+- For full trigger configuration reference, see [Trigger configuration](/reference/triggers/).
diff --git a/docs/manage/manage/_index.md b/docs/monitor/dashboards/_index.md
similarity index 53%
rename from docs/manage/manage/_index.md
rename to docs/monitor/dashboards/_index.md
index 18a2a76c0a..bfe1f76c82 100644
--- a/docs/manage/manage/_index.md
+++ b/docs/monitor/dashboards/_index.md
@@ -1,10 +1,10 @@
 ---
-linkTitle: "Manage organization"
-weight: 30
+linkTitle: "Data dashboards"
+weight: 15
 layout: "empty"
 type: "docs"
 empty_node: true
 open_on_desktop: true
 header_only: true
-canonical: "/manage/manage/access/"
+canonical: "/monitor/dashboards/overview/"
 ---
diff --git a/docs/monitor/dashboards/create-dashboards.md b/docs/monitor/dashboards/create-dashboards.md
new file mode 100644
index 0000000000..798814e14d
--- /dev/null
+++ b/docs/monitor/dashboards/create-dashboards.md
@@ -0,0 +1,140 @@
+---
+linkTitle: "Create dashboards"
+title: "Create dashboards"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "Create a dashboard to visualize sensor data from machines across your organization."
+---
+
+Create a dashboard to visualize sensor data from machines across your organization. Dashboards display data through widgets that you configure to pull from specific sensors.
+
+Before you start, you need at least one machine with a sensor configured for [data capture](/data/capture-sync/capture-and-sync-data/) so there is data to visualize.
+
+## Create a dashboard
+
+1. Navigate to the [**FLEET** page](https://app.viam.com) and click the **dashboard** tab.
+1. Click **Create dashboard**.
+1. Enter a name for your dashboard, replacing the placeholder text.
+
+Only organization owners can create dashboards.
+
+## Add widgets
+
+Click **Add widget** and select a widget type.
+The widget appears in your dashboard layout.
+Click the pencil icon in the top right of the widget to configure it.
+
+To rearrange widgets, click and drag the grid icon in the top left of a widget.
+Drag the divider between widgets to resize them.
+
+For an explanation of each widget type and the query model behind them, see [Data dashboards overview](/monitor/dashboards/overview/).
+
+### GPS
+
+Displays the current location reported by a movement sensor on a map.
+
+1. Choose a movement sensor from the **Movement sensor name** dropdown.
+1. Set the **Refresh rate** in seconds.
+1. Click **Save**.
+
+### Stat
+
+Displays a computed value from a sensor. By default, this is the most recent reading, but you can apply windowing and aggregation to show values like the average temperature across your fleet over the last hour.
+
+1. Choose a sensor from the **Sensor name** dropdown.
+1. Select the reading to display from the **Path** dropdown.
+1. Set a title, unit suffix, and refresh rate.
+1. To aggregate data, configure a **Window method** and **Aggregation method**. See [The query model](/monitor/dashboards/overview/#the-query-model) for details on these options.
+1. Click **Save**.
+
+### Time series
+
+Displays a graph of sensor readings over time.
+You can add multiple lines to compare readings from different sensors or fields on the same graph.
+
+To configure each line:
+
+1. Choose a sensor from the **Resource name** dropdown.
+1. Choose a capture method (for example, **Readings**).
+1. Enter a title for the line.
+1. Select the data field from the **Path** dropdown.
+1. Set the unit, duration, and other display options.
+1. Select a **Window method** to aggregate readings over time intervals:
+   - **None**: raw data points
+   - **Count**: number of readings in each window
+   - **Average**: mean value in each window
+   - **Min**: lowest value in each window
+   - **Max**: highest value in each window
+   - **Sum**: total of all values in each window
+   - **Custom query**: a custom MQL aggregation pipeline (see [Custom queries](/monitor/dashboards/custom-queries/))
+1. Optionally select an **Aggregation method** to combine data across machines. The same methods are available: Average, Count, Min, Max, Sum, and Custom query. See [The query model](/monitor/dashboards/overview/#the-query-model) for details.
+1. Click **Save**.
+
+### Table
+
+Displays a grid of sensor readings.
+Each row is a reading and each column is a field.
+
+Tables support two display methods:
+
+**Columns** (no MQL required):
+
+1. Choose a sensor from the **Resource name** dropdown.
+1. Choose a capture method.
+1. Configure each column with its own data source and aggregation method.
+1. Click **Save**.
+
+**Custom query** (MQL):
+
+1. Choose a sensor from the **Resource name** dropdown.
+1. Choose a capture method.
+1. Set the refetch rate and time range in seconds.
+1. Write a custom MQL aggregation pipeline to transform your data into columns.
+
+   For example, given sensor data with nested readings:
+
+   ```json
+   {
+     "data": {
+       "readings": {
+         "temperature": 22.96,
+         "humidity": 48.318
+       }
+     }
+   }
+   ```
+
+   Use a `$project` stage to select and rename columns:
+
+   ```json
+   {
+     "$project": {
+       "Temperature": "$data.readings.temperature",
+       "Humidity": "$data.readings.humidity"
+     }
+   }
+   ```
+
+   Tables display a maximum of 10,000 rows.
+
+   For more on MQL aggregation, see the [MongoDB documentation](https://www.mongodb.com/docs/manual/reference/mql/aggregation-stages/).
+
+1. Click **Save**.
+
+## Filter dashboard data
+
+Use the filter bar at the top of a dashboard to scope which data the widgets display:
+
+- **Location**: show data from machines in a specific location.
+- **Machine**: show data from a specific machine.
+- **Fragment**: show data from machines that use a specific fragment.
+- **Timeframe**: set the time range for historical data. The default is the last hour. You can use relative times like `now-1h` or `now-30m`, or set absolute start and end times.
+
+Filters apply to all widgets in the dashboard.
+
+## Manage dashboards
+
+- **Rename**: click the dashboard name at the top of the page and edit it inline.
+- **Duplicate**: create a copy of the dashboard from the actions menu.
+- **Delete**: remove the dashboard from the actions menu. This cannot be undone.
diff --git a/docs/monitor/dashboards/custom-queries.md b/docs/monitor/dashboards/custom-queries.md
new file mode 100644
index 0000000000..c68fb9e6e1
--- /dev/null
+++ b/docs/monitor/dashboards/custom-queries.md
@@ -0,0 +1,149 @@
+---
+linkTitle: "Custom queries"
+title: "Custom dashboard queries"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "Write MQL aggregation pipelines to create advanced dashboard visualizations."
+---
+
+When the built-in window and aggregation methods are not enough, you can write custom MQL (MongoDB Query Language) aggregation pipelines to transform your data. Custom queries give you full control over how data is processed before it reaches a widget.
+
+For an explanation of the built-in methods and when you need custom queries, see [Data dashboards overview](/monitor/dashboards/overview/#when-you-need-custom-queries).
+
+## Where custom queries apply
+
+You can use a custom query as either the **window method** or the **aggregation method** (or both) on any time series, stat, or table widget. In the widget configuration panel, select **Custom query** from the method dropdown and enter your MQL pipeline stages.
+
+## Write a custom query
+
+Each custom query is one or more MQL aggregation pipeline stages. Each stage is a JSON object with a single key that is a MongoDB aggregation operator.
+
+For example, a `$group` stage that computes the average temperature per hour:
+
+```json
+{
+  "$group": {
+    "_id": { "$dateTrunc": { "date": "$time_received", "unit": "hour" } },
+    "value": { "$avg": "$data.readings.temperature" }
+  }
+}
+```
+
+You can chain multiple stages. Each stage receives the output of the previous stage.
+
+### Supported operators
+
+Custom queries support the following MQL aggregation pipeline stages:
+
+`$addFields`, `$bucket`, `$bucketAuto`, `$collStats`, `$count`, `$densify`, `$documents`, `$facet`, `$fill`, `$geoNear`, `$graphLookup`, `$group`, `$indexStats`, `$limit`, `$listSessions`, `$lookup`, `$match`, `$merge`, `$out`, `$planCacheStats`, `$project`, `$redact`, `$replaceRoot`, `$replaceWith`, `$sample`, `$search`, `$searchMeta`, `$set`, `$setWindowFields`, `$skip`, `$sort`, `$sortByCount`, `$unionWith`, `$unset`, `$unwind`, `$vectorSearch`
+
+For documentation on each operator, see the [MongoDB aggregation pipeline stages reference](https://www.mongodb.com/docs/manual/reference/mql/aggregation-stages/).
+
+### Output format
+
+For **time series** and **stat** widgets, your custom query must produce documents with this structure:
+
+```json
+{
+  "time": "<timestamp>",
+  "value": "<number>",
+  "robot_id": "<robot_id>"
+}
+```
+
+- `time`: a timestamp for the data point
+- `value`: the numeric value to display
+- `robot_id`: the machine that produced the data (used to distinguish lines in time series graphs)
+
+For **table** widgets, the output can be any structure. Each field in the output document becomes a column.
+
+## Examples
+
+### Rolling hourly average
+
+Compute the average temperature for each hour, per machine:
+
+```json
+{
+  "$group": {
+    "_id": {
+      "hour": { "$dateTrunc": { "date": "$time_received", "unit": "hour" } },
+      "robot_id": "$robot_id"
+    },
+    "value": { "$avg": "$data.readings.temperature" }
+  }
+}
+```
+
+```json
+{
+  "$project": {
+    "time": "$_id.hour",
+    "robot_id": "$_id.robot_id",
+    "value": 1,
+    "_id": 0
+  }
+}
+```
+
+### Rate of change
+
+Compute how fast a value is changing by comparing consecutive readings using `$setWindowFields`:
+
+```json
+{
+  "$setWindowFields": {
+    "partitionBy": "$robot_id",
+    "sortBy": { "time_received": 1 },
+    "output": {
+      "prev_value": {
+        "$shift": {
+          "output": "$data.readings.temperature",
+          "by": -1
+        }
+      },
+      "prev_time": {
+        "$shift": {
+          "output": "$time_received",
+          "by": -1
+        }
+      }
+    }
+  }
+}
+```
+
+```json
+{
+  "$project": {
+    "time": "$time_received",
+    "robot_id": 1,
+    "value": {
+      "$divide": [
+        { "$subtract": ["$data.readings.temperature", "$prev_value"] },
+        {
+          "$divide": [{ "$subtract": ["$time_received", "$prev_time"] }, 1000]
+        }
+      ]
+    }
+  }
+}
+```
+
+### Table with derived columns
+
+For a table widget, compute temperature in both Celsius and Fahrenheit:
+
+```json
+{
+  "$project": {
+    "Time": "$time_received",
+    "Celsius": "$data.readings.temperature",
+    "Fahrenheit": {
+      "$add": [{ "$multiply": ["$data.readings.temperature", 1.8] }, 32]
+    },
+    "Humidity": "$data.readings.humidity"
+  }
+}
+```
diff --git a/docs/monitor/dashboards/overview.md b/docs/monitor/dashboards/overview.md
new file mode 100644
index 0000000000..6717e94eca
--- /dev/null
+++ b/docs/monitor/dashboards/overview.md
@@ -0,0 +1,124 @@
+---
+linkTitle: "Overview"
+title: "Data dashboards"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Understand dashboard widget types, the windowing and aggregation query model, and how dashboards differ from teleop workspaces."
+---
+
+Dashboards and teleop workspaces both use widgets to display data from your machines. This page explains what each widget type does, how the query model behind them works, and where dashboards and teleop workspaces differ.
+
+For step-by-step instructions, see [Create dashboards](/monitor/dashboards/create-dashboards/). For custom MQL queries, see [Custom queries](/monitor/dashboards/custom-queries/).
+
+## Widget types
+
+Widgets are the building blocks of dashboards and teleop workspaces. Each widget type displays data in a different way.
+
+### GPS
+
+Displays a machine's location on a map using position data from a movement sensor. You select a movement sensor and a refresh rate. The map updates at the interval you specify.
+
+Use GPS widgets to track machine locations across a fleet, or to monitor a single machine's position over time.
+
+### Stat
+
+Displays a single value from a sensor, such as the current temperature or battery level.
+
+In **dashboards**, stat widgets support the full query model: you can apply windowing and aggregation to show computed values like the average temperature across all machines over the last hour. In **teleop workspaces**, stat widgets show only the most recent reading from the selected sensor.
+
+### Time series
+
+Displays a graph of sensor data over time. You can add multiple lines to the same graph to compare readings from different sensors or fields.
+
+Time series widgets support the full query model (windowing and aggregation) in both dashboards and teleop workspaces. You can graph raw data points or aggregate them into time windows to smooth out noise and reveal trends.
+
+### Table
+
+Displays sensor data in rows and columns. Each row represents a reading and each column represents a field.
+
+In **dashboards**, tables support two display methods:
+
+- **Columns**: configure each column independently with its own data source and aggregation. No MQL required.
+- **Custom query**: write an MQL aggregation pipeline to transform data into any column structure you need.
+
+In **teleop workspaces**, tables support custom queries only.
+
+### Actuation
+
+Displays controls for actuating components: motors, servos, bases, arms, grippers, and other components that accept commands.
+
+Available in **teleop workspaces only**. Dashboards are read-only and do not include actuation widgets.
+
+### Camera
+
+Displays a live camera feed.
+
+Available in **teleop workspaces only**. Dashboards do not include camera streams.
+
+## The query model
+
+Time series, stat, and table widgets do not just display raw sensor readings. They can transform data through two layers of processing: **windowing** and **aggregation**. Understanding these two layers is the key to building useful dashboards.
+
+### Windowing: group readings into time buckets
+
+Windowing divides your data into time buckets of a specified duration and computes a summary value for each bucket. For example, with a 1-hour window and the Average method, you get one averaged data point per hour instead of hundreds of raw readings.
+
+Available window methods:
+
+| Method       | What it computes                                      | Example use                                                       |
+| ------------ | ----------------------------------------------------- | ----------------------------------------------------------------- |
+| None         | No windowing. Returns raw data points sorted by time. | Viewing individual sensor readings.                               |
+| Count        | Number of readings in each time bucket.               | Checking whether a sensor is reporting at the expected frequency. |
+| Average      | Mean value in each bucket.                            | Smoothing noisy temperature data into hourly averages.            |
+| Min          | Lowest value in each bucket.                          | Finding the coldest temperature each hour.                        |
+| Max          | Highest value in each bucket.                         | Tracking peak CPU usage per hour.                                 |
+| Sum          | Total of all values in each bucket.                   | Counting total events per time window.                            |
+| Custom query | An MQL aggregation pipeline you define.               | Computing derived metrics like rate of change or percentiles.     |
+
+### Aggregation: combine across machines
+
+After windowing groups data into time buckets, aggregation combines data from multiple machines into a single result. This is how you answer questions like "what is the average temperature across all machines in the warehouse?"
+
+Available aggregation methods: Average, Count, Min, Max, Sum, and Custom query. These work the same way as the corresponding window methods but operate across machines instead of across time.
+
+Aggregation is optional. If you skip it, each machine's data appears as a separate line or value.
+
+### How the two layers work together
+
+Consider a fleet of 10 machines, each reporting temperature every 10 seconds:
+
+1. **Raw data**: 6 readings per minute per machine, so 60 readings per minute across the fleet.
+2. **After windowing** (Average, 1-hour window): 1 data point per hour per machine, so 10 data points per hour.
+3. **After aggregation** (Average): 1 data point per hour for the entire fleet.
+
+The same two-layer model applies to stat widgets (showing a single computed value) and table widgets using the columns display method.
+
+### When you need custom queries
+
+The built-in window and aggregation methods cover common cases. Use a custom query when you need to:
+
+- Compute derived values like rate of change, standard deviation, or percentiles
+- Filter or reshape data beyond what the built-in methods support
+- Join data from multiple fields into a single visualization
+- Apply conditional logic to your aggregation
+
+Custom queries use MongoDB's MQL aggregation pipeline syntax. For details on writing custom queries, see [Custom queries](/monitor/dashboards/custom-queries/).
+
+## Dashboards and teleop workspaces
+
+Dashboards and teleop workspaces serve different purposes and have different capabilities.
+
+|                 | Dashboard                                                                       | Teleop workspace                                         |
+| --------------- | ------------------------------------------------------------------------------- | -------------------------------------------------------- |
+| Purpose         | Monitor data trends across machines                                             | Control and monitor a specific machine                   |
+| Scope           | Organization-level, with filters for location, machine, fragment, and timeframe | Requires selecting a specific machine                    |
+| Widget types    | GPS, stat, time series, table                                                   | GPS, stat, time series, table, plus actuation and camera |
+| Control         | Read-only                                                                       | Can send commands to components                          |
+| Stat widget     | Supports windowing and aggregation                                              | Most recent reading only                                 |
+| Table widget    | Columns or custom query                                                         | Custom query only                                        |
+| Time series Sum | Supported                                                                       | Not available                                            |
+
+Use **dashboards** when you want to watch data from multiple machines or analyze trends over time. Use **teleop workspaces** when you need to interact with a specific machine or view its live camera feeds.
+
+To create a dashboard, see [Create dashboards](/monitor/dashboards/create-dashboards/). To create a teleop workspace, see [Teleop workspaces](/monitor/teleop-workspaces/).
diff --git a/docs/monitor/default-interface.md b/docs/monitor/default-interface.md
new file mode 100644
index 0000000000..aefc1908f4
--- /dev/null
+++ b/docs/monitor/default-interface.md
@@ -0,0 +1,71 @@
+---
+linkTitle: "Default control interface"
+title: "Default control interface"
+weight: 25
+layout: "docs"
+type: "docs"
+description: "Use the CONTROL tab or the Viam mobile app to remotely test and operate your machines."
+aliases:
+  - /manage/troubleshoot/teleoperate/default-interface/
+  - /fleet/control/
+  - /manage/app-usage/
+  - /monitor/teleoperate/
+---
+
+The CONTROL tab provides a ready-made interface for testing and operating any configured machine. Every component and service on the machine gets a control card with relevant controls and readouts. No code required.
+
+For a purpose-built operator interface with only the widgets you need, see [Teleop workspaces](/monitor/teleop-workspaces/). For a fully custom app with SDK access, see [Build apps](/build-apps/).
+
+## Web UI
+
+Navigate to your machine's page in the Viam app and click the **CONTROL** tab.
+
+Each configured component and service appears as a card. What you can do depends on the resource type:
+
+| Resource type      | What you can do                                          |
+| ------------------ | -------------------------------------------------------- |
+| Arm                | Move joints, set joint positions, read current positions |
+| Base               | Drive with an arrow pad, set speed with a power slider   |
+| Board              | Read and write GPIO pins, ADC/DAC values                 |
+| Button             | View button state, simulate press                        |
+| Camera             | View live feed, capture frames                           |
+| Encoder            | Read position and ticks                                  |
+| Gantry             | Move axes, read positions                                |
+| Gripper            | Open, close, stop                                        |
+| Input controller   | View button and axis states                              |
+| Motor              | Set power, set RPM, go to position, read position        |
+| Movement sensor    | Read position, orientation, velocity                     |
+| Power sensor       | Read voltage, current, power                             |
+| Sensor             | Read current values                                      |
+| Servo              | Set angle, read current angle                            |
+| Switch             | Toggle position                                          |
+| Generic component  | Send custom commands (DoCommand)                         |
+| Discovery service  | View discovery results                                   |
+| ML model service   | Run inference                                            |
+| Navigation service | View and set navigation goals                            |
+| SLAM service       | View map and pose                                        |
+| Vision service     | Run detections and classifications on camera feeds       |
+| Generic service    | Send custom commands (DoCommand)                         |
+
+You can switch between machine parts directly from the CONTROL tab using the part selector at the top.
+
+## Viam mobile app
+
+The Viam mobile app provides similar access from your phone:
+
+- See which machines are online
+- View live camera feeds
+- Adjust component settings
+- Switch between components
+- [View machine logs](/monitor/troubleshoot/#check-logs)
+- [Upload images from your phone to the cloud](/data/capture-sync/upload-other-data/)
+
+The mobile app is available on the [App Store](https://apps.apple.com/vn/app/viam-robotics/id6451424162) and [Google Play](https://play.google.com/store/apps/details?id=com.viam.viammobile&hl=en&gl=US).
+
+<a href="https://apps.apple.com/vn/app/viam-robotics/id6451424162" target="_blank">
+  <img src="/appstore.png" width="200px" alt="apple store icon" class="center-if-small" >
+</a>
+
+<a href="https://play.google.com/store/apps/details?id=com.viam.viammobile&hl=en&gl=US" target="_blank">
+  <img src="/googleplay.png" width="200px" alt="google play store icon" class="center-if-small" >
+</a>
diff --git a/docs/monitor/monitor.md b/docs/monitor/monitor.md
new file mode 100644
index 0000000000..1efc6a7959
--- /dev/null
+++ b/docs/monitor/monitor.md
@@ -0,0 +1,83 @@
+---
+linkTitle: "Monitor machine status"
+title: "Monitor machine status"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Check which machines are online, view part status, and inspect machine health across your fleet."
+aliases:
+  - /manage/troubleshoot/monitor/
+---
+
+Check the status of your machines from the Viam app, the mobile app, or the command line.
+
+## Check fleet status
+
+Navigate to the [**FLEET** page](https://app.viam.com/fleet/machines) and click the **machines** tab.
+The machines table shows every machine in your organization with its current status:
+
+- **Online** (green): the machine is connected and running.
+- **Offline** (red): the machine is not connected. The table shows when it was last online.
+- **Awaiting setup**: the machine has been created but has not yet connected to Viam.
+
+You can also see the amount of binary and tabular data your fleet has synced in the last 48 hours from this dashboard.
+
+## Inspect a specific machine
+
+Click a machine name to open its page.
+At the top of the page, the status indicator shows whether the machine is online or offline.
+
+Click the **status** dropdown to see details about each {{< glossary_tooltip term_id="part" text="part" >}} of your machine:
+
+- Operating system and architecture
+- Host information
+- `viam-server` version
+- IP addresses
+- Last online time (if offline) or remote address (if online)
+
+## Check resource health
+
+On a machine's **CONFIGURE** page, look for a red exclamation icon on any resource card.
+Click the icon or expand the **ERROR LOGS** panel to see errors produced by that resource.
+
+For more detailed debugging, see [Troubleshoot problems](/monitor/troubleshoot/).
+
+## Test a machine remotely
+
+On the [**CONTROL** tab](/monitor/default-interface/), you can remotely operate the machine and test each configured resource without writing code.
+
+## Use the command line
+
+Check machine status from the CLI:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines status --machine <machine-name-or-id>
+```
+
+Check a specific part:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part status --part <part-name-or-id>
+```
+
+List all parts on a machine:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part list --machine <machine-name-or-id>
+```
+
+Replace the placeholder values with your machine name or ID.
+You can find the machine name on the machine's page in the Viam app.
+To find the machine ID, click the **...** menu on the machine's page and select **Copy machine ID**.
+
+## Set up offline alerts
+
+To receive an email or webhook notification when a machine goes offline, configure a trigger.
+See [Set up alerts](/monitor/alert/).
+
+## Use the mobile app
+
+The [Viam mobile app](/monitor/default-interface/#viam-mobile-app) shows machine status from your phone.
+You can see which machines are online, view logs, and remotely operate components.
+
+The mobile app is available on the [App Store](https://apps.apple.com/vn/app/viam-robotics/id6451424162) and [Google Play](https://play.google.com/store/apps/details?id=com.viam.viammobile&hl=en&gl=US).
diff --git a/docs/monitor/overview.md b/docs/monitor/overview.md
new file mode 100644
index 0000000000..38888a1148
--- /dev/null
+++ b/docs/monitor/overview.md
@@ -0,0 +1,75 @@
+---
+linkTitle: "Overview"
+title: "Monitor and operate"
+weight: 1
+layout: "docs"
+type: "docs"
+description: "Monitor machine status, visualize data, set up alerts, teleoperate machines, and troubleshoot problems."
+---
+
+Your machines are running. Now you need to know what they're doing, get alerted when something needs attention, operate them remotely, and fix problems when they arise. This section covers the observability and operations tools that Viam provides for deployed machines.
+
+## Check machine status
+
+The fleet dashboard shows every machine in your organization with its current status: online, offline, or awaiting setup. You can see when each machine was last online, drill into individual machines to inspect part status and configuration, and check resource health.
+
+From the command line, `viam machines status` and `viam machines part status` provide the same information.
+
+See [Monitor machine status](/monitor/monitor/).
+
+## Visualize data with dashboards
+
+Dashboards let you visualize sensor data from machines across your organization. You add widgets (GPS maps, stat displays, time series graphs, and tables) and configure each one to pull data from a specific sensor and capture method. Filters scope the data by location, machine, fragment, or time range.
+
+Widgets support aggregation: you can compute averages, minimums, maximums, and counts over time windows, or write custom MongoDB aggregation queries for advanced transformations. A separate overview explains the query model and widget types in detail.
+
+See [Data dashboards](/monitor/dashboards/overview/).
+
+## Set up alerts
+
+Triggers send email or webhook notifications when specific events occur on your machines:
+
+- **Telemetry thresholds**: alert when a sensor reading (CPU usage, temperature, battery level) crosses a threshold.
+- **Machine status**: alert when a machine part comes online or goes offline.
+- **Log levels**: alert when error, warning, or info logs appear on a machine.
+
+You configure notification frequency to control how often alerts fire, which helps prevent alert fatigue as your fleet grows. Notifications can go to specific email addresses, all machine owners, or a webhook endpoint that integrates with services like PagerDuty, Twilio, or Zapier.
+
+For alerts based on data sync events, see [Trigger on data events](/data/trigger-on-data/). For alerts based on ML model detections, see [Alert on detections](/vision/alert-on-detections/).
+
+See [Set up alerts](/monitor/alert/).
+
+## Teleoperate machines
+
+You can remotely control and test any configured machine without writing code.
+
+The **default control interface** is the CONTROL tab on your machine's page in the Viam app. It provides a control card for every configured component and service: move bases, actuate arms and grippers, read sensors, view camera feeds, and test vision services. The Viam mobile app provides similar access from your phone.
+
+**Teleop workspaces** let you build custom operator interfaces with only the widgets you need for a specific task. You choose the widgets (camera feeds, sensor readouts, actuation controls, GPS maps) and arrange them into a focused view. This is useful when the full CONTROL tab shows more than the operator needs.
+
+See [Default control interface](/monitor/default-interface/) and [Teleop workspaces](/monitor/teleop-workspaces/).
+
+## Troubleshoot problems
+
+When something goes wrong, Viam provides a set of debugging tools you can use without physical access to the machine:
+
+- **Logs**: the LOGS tab shows machine logs filterable by level, keyword, time range, and resource. You can enable debug logging for individual resources or log name patterns without restarting.
+- **Remote shell**: access a terminal on the machine through the CLI (`viam machines part shell`) without setting up SSH tunnels.
+- **Debug endpoints**: enable pprof profiling and resource graph visualization for performance issues.
+- **Configuration history**: view and revert to previous configurations if a config change caused the problem.
+- **Diagnostics**: download FTDC (full-time diagnostic capture) data and OpenTelemetry traces for detailed analysis.
+
+See [Troubleshoot problems](/monitor/troubleshoot/).
+
+## What this section covers and what it does not
+
+This section covers tools for monitoring, operating, and debugging machines that are already configured and running.
+
+| If you need to...                              | See                                     |
+| ---------------------------------------------- | --------------------------------------- |
+| Set up a machine for the first time            | [Get started](/foundation/)             |
+| Configure components and services              | [Configure hardware](/hardware/)        |
+| Capture and sync data from sensors             | [Manage data](/data/)                   |
+| Train and deploy ML models                     | [Train ML models](/train/)              |
+| Build a custom web or mobile app with the SDKs | [Build apps](/operate/control/web-app/) |
+| Manage fleet deployment and provisioning       | [Fleet deployment](/fleet/)             |
diff --git a/docs/monitor/teleop-workspaces.md b/docs/monitor/teleop-workspaces.md
new file mode 100644
index 0000000000..b5f9635403
--- /dev/null
+++ b/docs/monitor/teleop-workspaces.md
@@ -0,0 +1,76 @@
+---
+linkTitle: "Teleop workspaces"
+title: "Teleop workspaces"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "Build custom operator interfaces with camera feeds, sensor readouts, and component controls."
+aliases:
+  - /manage/troubleshoot/teleoperate/custom-interface/
+  - /monitor/custom-interface/
+---
+
+Teleop workspaces let you build custom operator interfaces for specific tasks. Instead of seeing every resource on the CONTROL tab, you choose which widgets to display and arrange them into a focused view.
+
+For an explanation of widget types and capabilities, see [Data dashboards overview](/monitor/dashboards/overview/). For the full CONTROL tab with all resources, see [Default control interface](/monitor/default-interface/).
+
+## Prerequisites
+
+{{% expand "A configured machine with teleoperable components" %}}
+
+Your machine needs at least one camera, movement sensor, sensor, base, arm, board, gantry, gripper, motor, or servo.
+
+See [configure a machine](/operate/modules/configure-modules/) for more information.
+
+{{% /expand%}}
+
+## Create a workspace
+
+1. Navigate to the **FLEET** page and click the [**TELEOP** tab](https://app.viam.com/teleop).
+1. Click **+ Create workspace**.
+1. Enter a name for your workspace, replacing the placeholder text.
+1. Click **Select machine** and choose the machine you want to monitor and control.
+
+## Add widgets
+
+1. Click **Add widget** and select a widget type.
+1. Click the pencil icon in the top right of the widget to configure it.
+
+To rearrange widgets, click and drag the grid icon in the top left of a widget.
+
+### Available widget types
+
+Teleop workspaces support all the widget types that dashboards support (GPS, stat, time series, table), plus two additional types for real-time interaction:
+
+**Actuation**: control motors, servos, bases, arms, grippers, and other actuating components. Choose a component type, method, and component name.
+
+**Camera stream**: display a live feed from a camera component. Choose a camera and set the refresh type.
+
+For details on configuring GPS, stat, time series, and table widgets, see [Create dashboards](/monitor/dashboards/create-dashboards/). The configuration is the same, with these differences:
+
+- Stat widgets show the most recent reading only (no windowing or aggregation).
+- Table widgets support custom queries only (no column-based display).
+- Time series widgets do not support the Sum window method.
+
+For a full comparison, see the [dashboards and teleop workspaces table](/monitor/dashboards/overview/#dashboards-and-teleop-workspaces).
+
+## Design effective operator views
+
+A workspace is most useful when it shows only what the operator needs for their current task.
+
+For example, a warehouse robot inspection workspace might include:
+
+- A camera feed showing the robot's forward view
+- A base actuation widget for driving
+- A stat widget showing battery level
+- A GPS widget showing the robot's location
+
+An environmental monitoring workspace might include:
+
+- Time series graphs of temperature and humidity over the last 24 hours
+- A table showing the most recent readings from all sensors
+- A stat widget showing the current air quality index
+
+Start with fewer widgets and add more as you discover what the operator actually uses.
+
+If you need more control than widgets provide, you can [build a custom app](/build-apps/) with full SDK access using TypeScript, Flutter, Python, Go, or C++.
diff --git a/docs/monitor/troubleshoot.md b/docs/monitor/troubleshoot.md
new file mode 100644
index 0000000000..5e64e6f5ff
--- /dev/null
+++ b/docs/monitor/troubleshoot.md
@@ -0,0 +1,303 @@
+---
+linkTitle: "Troubleshoot problems"
+title: "Troubleshoot problems"
+weight: 40
+layout: "docs"
+type: "docs"
+description: "Debug a misbehaving machine using logs, remote shell access, debug endpoints, and configuration history."
+aliases:
+  - /manage/troubleshoot/troubleshoot/
+  - /appendix/troubleshooting/
+  - /dev/tools/common-errors/
+---
+
+When a machine is not working as expected, follow this debugging workflow: check logs, enable debug logging if needed, access the machine remotely, and if necessary use advanced diagnostics.
+
+For common errors and their solutions, see [Common Errors](/monitor/troubleshoot/).
+
+## Check logs
+
+### Machine shows as offline
+
+If your machine shows as offline in the Viam app, you need to check logs on the machine itself.
+
+First determine whether `viam-server` was installed with `viam-agent` (most common) or manually:
+
+```sh {class="command-line" data-prompt="$" data-output="2"}
+ps aux | grep viam-agent
+root      566431  0.5  0.2 1247148 20336 ?       Ssl  11:24   0:00 /opt/viam/bin/viam-agent --config /etc/viam.json
+```
+
+If you see a `viam-agent` process, you used `viam-agent` to install.
+
+{{< tabs >}}
+{{% tab name="Installed with viam-agent" %}}
+
+Query logs with `journalctl`:
+
+```sh {class="command-line" data-prompt="$"}
+sudo journalctl --unit=viam-agent
+```
+
+Or restart `viam-server` manually with debug logging to a file:
+
+1. Find the `viam-server` binary and config file paths:
+
+   ```sh {class="command-line" data-prompt="$" data-output="2"}
+   ps aux | grep viam-server
+   root      566219 83.6  1.1 1966984 88896 ?       Sl   11:17   0:02 /opt/viam/bin/viam-server -config /etc/viam.json
+   ```
+
+1. Stop `viam-agent`:
+
+   ```sh {class="command-line" data-prompt="$"}
+   sudo systemctl stop viam-agent
+   ```
+
+1. Run `viam-server` with debug logging:
+
+   ```sh {class="command-line" data-prompt="$"}
+   /opt/viam/bin/viam-server -debug -config /etc/viam.json -log-file logs.txt
+   ```
+
+1. Check the log file for errors.
+
+{{% /tab %}}
+{{% tab name="Manual install (Linux)" %}}
+
+Query logs with `journalctl`:
+
+```sh {class="command-line" data-prompt="$"}
+sudo journalctl --unit=viam-server
+```
+
+Or restart with debug logging:
+
+1. Stop the system service:
+
+   ```sh {class="command-line" data-prompt="$"}
+   sudo systemctl stop viam-server
+   ```
+
+1. Run with debug logging:
+
+   ```sh {class="command-line" data-prompt="$"}
+   sudo /usr/local/bin/viam-server -debug -config /etc/viam.json -log-file logs.txt
+   ```
+
+1. Check the log file for errors.
+
+{{% /tab %}}
+{{% tab name="Manual install (macOS)" %}}
+
+By default, `viam-server` writes logs to STDOUT.
+To capture logs to a file:
+
+1. Stop the running `viam-server` instance.
+1. Restart with debug logging:
+
+   ```sh {class="command-line" data-prompt="$"}
+   viam-server -config ~/Downloads/viam.json -debug -log-file logs.txt
+   ```
+
+1. Check the log file for errors.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+{{< alert title="Note" color="note" >}}
+While your machine cannot connect to Viam, configuration changes you make in the app will not reach the machine.
+{{< /alert >}}
+
+### Machine shows as online
+
+#### Check for errors on the CONFIGURE page
+
+Go to your machine's **CONFIGURE** page and look for a red exclamation icon on any resource card.
+Click the icon or expand the **ERROR LOGS** panel to see resource-specific errors.
+
+#### Check logs on the LOGS tab
+
+Go to the **LOGS** tab and look for errors.
+
+You can filter logs by:
+
+- **Level**: Error, Warn, Info, Debug
+- **Keyword**: full text search (supports regular expressions)
+- **Time range**: set start and end times, or use live mode to stream logs in real time
+- **Resource**: filter by a specific component or service name
+
+The default log level is `Info`.
+If you are not seeing helpful logs, enable debug logging.
+
+#### Enable debug logging
+
+**For all resources on the machine**, add `"debug": true` to the JSON configuration:
+
+```json
+{
+  "debug": true,
+  "components": [{ ... }]
+}
+```
+
+**For individual resources**, click the **...** menu on the resource's configuration card and select **Enable debug logs**.
+
+**For resources matching a pattern**, configure the `log` field in the machine configuration:
+
+```json
+"log": [
+  {
+    "pattern": "rdk.components.arm",
+    "level": "debug"
+  },
+  {
+    "pattern": "rdk.services.*",
+    "level": "debug"
+  }
+]
+```
+
+For more on log configuration, see [Logging](/operate/reference/viam-server/#logging).
+
+By default, `viam-server` deduplicates log messages that repeat within a one-minute window.
+To disable this, see [Disable log deduplication](/operate/reference/viam-server/).
+
+#### Access logs from the command line
+
+```sh {class="command-line" data-prompt="$"}
+viam machines logs --machine <machine-name-or-id> --levels error,warn
+```
+
+Stream logs in real time:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part logs --part <part-name-or-id> --tail
+```
+
+Filter by keyword and time range:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines logs --machine <machine-name-or-id> --keyword "motor" --start 2026-04-07T10:00:00Z --end 2026-04-07T11:00:00Z
+```
+
+## Remote shell access
+
+Access a terminal on the machine without setting up SSH tunnels:
+
+1. Add the [ViamShellDanger fragment](https://app.viam.com/fragment/b511adfa-80ab-4a70-9bd5-fbb14696b17e/json) to your machine.
+1. Open a shell:
+
+   ```sh {class="command-line" data-prompt="$"}
+   viam machines part shell --part <part-name-or-id>
+   ```
+
+1. Copy files from the machine:
+
+   ```sh {class="command-line" data-prompt="$"}
+   viam machines part cp --part <part-name-or-id> -r machine:/path/to/files ~/Downloads/
+   ```
+
+1. Tunnel to a specific port on the machine:
+
+   ```sh {class="command-line" data-prompt="$"}
+   viam machines part tunnel --part <part-name-or-id> --local-port 8080 --destination-port 8080
+   ```
+
+## Debug endpoints
+
+For performance issues, enable pprof profiling endpoints:
+
+```json
+{
+  "components": [],
+  "services": [],
+  "enable_web_profile": true
+}
+```
+
+This exposes endpoints for CPU profiling, memory allocation analysis, goroutine blocking analysis, and execution tracing.
+
+The `/debug/graph` endpoint renders an SVG visualization of the machine's resource dependency graph.
+
+For details, see [Debug Endpoints](/operate/reference/viam-server/debug-endpoints/).
+
+## Diagnostics
+
+### FTDC
+
+FTDC (full-time diagnostic capture) continuously records machine metrics in a compressed binary format: resource counts, WebRTC connection stats, data manager upload stats, and more.
+
+Download FTDC data from a machine:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part get-ftdc --part <part-name-or-id> ./diagnostics/
+```
+
+Parse and analyze FTDC data locally:
+
+```sh {class="command-line" data-prompt="$"}
+viam parse-ftdc --path ./diagnostics/ftdc-data
+```
+
+### Traces
+
+If tracing is enabled in your machine configuration, you can download and analyze OpenTelemetry traces:
+
+```sh {class="command-line" data-prompt="$"}
+viam traces get-remote --part <part-name-or-id> ./traces/
+```
+
+Print traces to the console:
+
+```sh {class="command-line" data-prompt="$"}
+viam traces print-remote --part <part-name-or-id>
+```
+
+Import traces into an OTLP-compatible tool (such as Jaeger):
+
+```sh {class="command-line" data-prompt="$"}
+viam traces import-remote --part <part-name-or-id> --endpoint localhost:4317
+```
+
+## Restart a machine
+
+1. Navigate to your machine's page.
+1. Click the part status dropdown to the right of your machine's name.
+1. If your machine was installed with `viam-agent`, click **Restart**.
+   Both `viam-server` and `viam-agent` will restart.
+
+   If you do not see a **Restart** button, click the **...** menu on the machine part card and select **Restart part**.
+
+It takes a few minutes for `viam-server` to shut down and restart.
+
+From the command line:
+
+```sh {class="command-line" data-prompt="$"}
+viam machines part restart --part <part-name-or-id>
+```
+
+## Revert to an earlier configuration
+
+Viam keeps a record of your configuration changes.
+To see the history, click **History** on the **CONFIGURE** tab.
+
+To restore an earlier version, click the **Restore version** button next to the desired configuration.
+
+## Advanced debugging for Go modules
+
+If a Go module hangs or does not shut down properly, send a SIGQUIT signal to get a stack trace:
+
+```sh {class="command-line" data-prompt="$"}
+kill -3 <PID>
+```
+
+The process dumps a stack trace to the `viam-server` logs showing all goroutines and where execution is blocked.
+
+## Get support
+
+If you cannot resolve the issue, reach out on the [Community Discord](https://discord.gg/viam).
+Post the error message along with what you were doing when it occurred.
+
+If asked, you can share your location with the Viam Support team by navigating to your location and clicking **Add Viam support**.
+Remove access after receiving support by clicking **Remove Viam support**.
diff --git a/docs/motion-planning/3d-scene/_index.md b/docs/motion-planning/3d-scene/_index.md
new file mode 100644
index 0000000000..bd64c4883c
--- /dev/null
+++ b/docs/motion-planning/3d-scene/_index.md
@@ -0,0 +1,82 @@
+---
+linkTitle: "3D scene"
+title: "3D scene"
+weight: 35
+layout: "docs"
+type: "docs"
+no_list: true
+description: "Visualize your machine's frame system, geometries, and point clouds in an interactive 3D view."
+---
+
+The **3D scene** tab on your machine's page in the [Viam app](https://app.viam.com) renders your machine's frame system as an interactive 3D visualization.
+You can inspect how components are positioned relative to each other, verify that obstacle geometry covers your workspace correctly, view live point clouds from depth cameras, and measure distances between points in the scene.
+
+The 3D scene tab reads your machine's configuration and, when the machine is online, connects to it for live data.
+Everything you see in the scene maps directly to your frame system configuration: each component's frame appears as a set of coordinate axes positioned according to its translation and orientation relative to its parent frame.
+
+## The interface
+
+The 3D scene tab has four main areas:
+
+**3D viewport** (center): The main rendering area.
+You can orbit, pan, and zoom to view your frame system from any angle.
+Components appear as labeled coordinate axes, with attached geometries rendered as translucent shapes.
+Point clouds from cameras render as colored point sets.
+An XY grid provides spatial reference.
+
+**Tree view** (left sidebar): A hierarchical list of every entity in the scene, matching your frame system's parent-child structure.
+Click an entity to select it.
+The tree shows the same hierarchy you configured: world frame at the root, with components nested under their parent frames.
+
+**Details panel** (right, appears when you select an entity): Shows the selected entity's spatial properties:
+
+- **World position** (mm) and **world orientation** (degrees): the entity's absolute position and orientation in the world frame.
+- **Parent frame**: which frame this entity is a child of.
+- **Local position** (mm) and **local orientation** (degrees): position and orientation relative to the parent frame. These correspond directly to the `translation` and `orientation` values in your frame configuration.
+- **Geometry**: type (box, sphere, or capsule) and dimensions in mm, if a geometry is attached.
+
+The details panel also has a **copy** button that exports the full pose and geometry data as JSON, and a **zoom to object** button that centers the camera on the selected entity.
+
+**Toolbar** (top): Controls for camera mode, transform tools, and specialized tools:
+
+- **Perspective/Orthographic toggle** (`C`): switch between perspective view (depth perception) and orthographic view (no foreshortening, useful for checking alignment).
+
+## Navigation controls
+
+| Action                   | Mouse             | Keyboard             |
+| ------------------------ | ----------------- | -------------------- |
+| Orbit (rotate view)      | Right-click drag  | Arrow keys           |
+| Pan                      | Middle-click drag |                      |
+| Zoom                     | Scroll wheel      | `R` (in) / `F` (out) |
+| Move camera              |                   | `W`/`A`/`S`/`D`      |
+| Select entity            | Left-click        |                      |
+| Deselect                 | Click empty space | `Escape`             |
+| Toggle camera mode       |                   | `C`                  |
+| Toggle entity visibility |                   | `H`                  |
+
+## Settings
+
+Click the gear icon to open the settings panel.
+Settings are organized into tabs:
+
+- **Pointclouds**: set default point size and color, enable or disable point cloud display per camera.
+- **Scene**: toggle the grid, axis labels, hover detail tooltips, and line thickness.
+- **Widgets**: show or hide the floating camera feed and arm position widgets.
+
+The **camera widget** displays a live camera feed from a selected robot camera alongside the 3D view.
+The **arm positions widget** shows current joint angles and end-effector pose for arm components.
+
+## File import
+
+You can drag and drop PCD or PLY files directly onto the 3D viewport to load external point cloud data into the scene.
+This is useful for loading saved SLAM maps or point cloud captures for comparison with your live frame system.
+
+## How-to guides
+
+{{< cards >}}
+{{% card link="/motion-planning/3d-scene/debug-motion-plan/" noimage="true" %}}
+{{% card link="/motion-planning/3d-scene/calibrate-frame-offsets/" noimage="true" %}}
+{{% card link="/motion-planning/3d-scene/verify-point-cloud-alignment/" noimage="true" %}}
+{{% card link="/motion-planning/3d-scene/set-up-obstacle-avoidance/" noimage="true" %}}
+{{% card link="/motion-planning/3d-scene/edit-frames/" noimage="true" %}}
+{{< /cards >}}
diff --git a/docs/motion-planning/3d-scene/calibrate-frame-offsets.md b/docs/motion-planning/3d-scene/calibrate-frame-offsets.md
new file mode 100644
index 0000000000..254b524c18
--- /dev/null
+++ b/docs/motion-planning/3d-scene/calibrate-frame-offsets.md
@@ -0,0 +1,79 @@
+---
+linkTitle: "Calibrate frame offsets"
+title: "Calibrate frame offsets"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "Verify and adjust the spatial relationship between components using the 3D scene and measurement tool."
+---
+
+When you configure a camera mounted on an arm or a sensor attached to a base, the frame system needs the exact translation and orientation between the two components.
+Small errors in these offsets cause the arm to reach for objects in the wrong place or the point cloud to misalign with the physical workspace.
+The 3D scene tab lets you visually verify these offsets and use the measurement tool to check distances.
+
+## Prerequisites
+
+- A machine with at least two components that have frames configured (for example, an arm and a camera).
+- Physical measurements of the distances between components.
+
+## Verify frame offsets
+
+### 1. Open the 3D scene tab
+
+Navigate to your machine in the [Viam app](https://app.viam.com) and click the **3D scene** tab.
+
+### 2. Select each component and check its position
+
+Click a component in the tree view.
+The details panel shows:
+
+- **Local position**: the translation from the parent frame, in mm. This is what you configured.
+- **World position**: the absolute position in the world frame, computed from the chain of parent transforms.
+
+Compare the local position values to your physical measurements.
+If the camera is 50 mm to the right and 100 mm above the arm's wrist joint, the local position should reflect that.
+
+### 3. Use the measurement tool
+
+The measurement tool calculates the distance between two points in the scene.
+
+1. Activate the measurement tool from the toolbar.
+2. Click a point on the first component (for example, the arm's end effector frame origin).
+3. Click a point on the second component (for example, the camera frame origin).
+
+The tool displays the distance in mm.
+Compare this to your physical measurement.
+If the values disagree, adjust the translation in the frame configuration.
+
+You can constrain the measurement to a single axis (X, Y, or Z) to isolate which component of the offset is wrong.
+
+### 4. Check orientation alignment
+
+Select a component and look at its coordinate axes in the 3D view.
+The axes should match the physical orientation of the component:
+
+- A camera's Z axis (blue) typically points forward along the optical axis.
+- An arm's coordinate system follows the manufacturer's convention.
+
+If the axes are rotated relative to what you expect, adjust the orientation values in the frame configuration.
+The details panel shows the orientation as an orientation vector (x, y, z, theta in degrees).
+
+### 5. Verify with a point cloud
+
+If the component is a depth camera, enable its point cloud in the settings panel.
+The point cloud should align with the physical objects in your workspace.
+
+If the point cloud appears shifted or rotated relative to where objects actually are, the camera's frame offset or orientation is wrong.
+See [Verify point cloud alignment](/motion-planning/3d-scene/verify-point-cloud-alignment/) for more on working with point clouds.
+
+## Iterative adjustment
+
+Frame calibration is often iterative:
+
+1. Measure physically.
+2. Enter the values in the frame configuration.
+3. Check the result in the 3D scene.
+4. Adjust and repeat until the scene matches reality.
+
+For high-precision applications, use the camera calibration procedure to compute intrinsic parameters before adjusting frame offsets.
+See [Calibrate a camera for motion planning](/motion-planning/camera-calibration/).
diff --git a/docs/motion-planning/3d-scene/debug-motion-plan.md b/docs/motion-planning/3d-scene/debug-motion-plan.md
new file mode 100644
index 0000000000..387b52064e
--- /dev/null
+++ b/docs/motion-planning/3d-scene/debug-motion-plan.md
@@ -0,0 +1,69 @@
+---
+linkTitle: "Debug a motion plan"
+title: "Debug a motion plan"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Use the 3D scene to diagnose why a motion plan failed or produced unexpected results."
+---
+
+When a motion plan fails with a collision error or produces a path that does not look right, the 3D scene tab lets you see exactly what the planner sees: the arm's kinematic model, the obstacle geometry, and the frame positions that define the workspace.
+Most motion planning failures come down to one of a few problems that are immediately visible in 3D.
+
+## Prerequisites
+
+- A machine with an arm or gantry configured and at least one frame defined.
+- A motion plan that is failing or producing unexpected results.
+
+## Diagnose the problem
+
+### 1. Open the 3D scene tab
+
+Navigate to your machine in the [Viam app](https://app.viam.com) and click the **3D scene** tab.
+The scene loads your current frame system configuration.
+
+If your machine is online, the scene also connects to it for live pose data.
+If your machine is offline, the scene still renders the configured frame positions.
+
+### 2. Check frame positions
+
+Click through components in the tree view and verify that each one appears where you expect it in 3D space.
+Common problems:
+
+- **Component in the wrong location**: the translation values in the frame configuration do not match the physical setup. The details panel shows the local position in mm relative to the parent frame. Compare these to your physical measurements.
+- **Component with wrong orientation**: the arm base is rotated 90 degrees, or a camera is pointing the wrong direction. Check the local orientation values in the details panel.
+- **Wrong parent frame**: a component is attached to the wrong parent, placing it in an unexpected part of the scene. Check the parent frame field in the details panel.
+
+### 3. Check obstacle geometry
+
+Obstacles appear as translucent shapes in the scene.
+Verify that:
+
+- Every physical obstacle in your workspace has a corresponding geometry in the scene.
+- Each geometry covers the actual physical object. If a box geometry is too small, the planner will find paths that clip the real obstacle.
+- Geometries are positioned correctly. A table surface defined at `z: 0` when the arm base is at `z: 500` will not protect against table collisions.
+
+If obstacles are missing or misplaced, see [Set up obstacle avoidance](/motion-planning/3d-scene/set-up-obstacle-avoidance/).
+
+### 4. Look for impossible targets
+
+If the motion plan target is outside the arm's reach or inside an obstacle, the planner cannot find a path.
+Use the details panel to check the world position of the arm's end effector and compare it to your target pose.
+
+If the target is inside an obstacle geometry, either move the target or adjust the obstacle definition.
+
+### 5. Check for self-collision geometry
+
+Some arm models include collision geometry for each link.
+If a motion plan fails with a self-collision error, open the 3D scene to see whether the arm's own link geometries overlap in certain configurations.
+This can happen when wrist joints are commanded to positions that bring adjacent links too close together.
+
+## Common causes of motion plan failures
+
+| Symptom                       | Likely cause                                  | What to check in 3D scene                                                  |
+| ----------------------------- | --------------------------------------------- | -------------------------------------------------------------------------- |
+| "no valid path found"         | Target unreachable or blocked by obstacles    | Is the target inside an obstacle? Is it within the arm's reach?            |
+| Collision error               | Obstacle geometry intersects the planned path | Are obstacles positioned correctly? Are they the right size?               |
+| Path goes through the table   | Table obstacle missing or too small           | Is there a geometry covering the table surface? Does it extend far enough? |
+| Arm takes an unexpected route | Obstacles force the planner to go around      | Are there obstacles you did not intend to add? Is geometry oversized?      |
+| Self-collision error          | Arm links collide with each other             | Do link geometries overlap in the failing configuration?                   |
diff --git a/docs/motion-planning/3d-scene/edit-frames.md b/docs/motion-planning/3d-scene/edit-frames.md
new file mode 100644
index 0000000000..096a77058d
--- /dev/null
+++ b/docs/motion-planning/3d-scene/edit-frames.md
@@ -0,0 +1,91 @@
+---
+linkTitle: "Edit frames visually"
+title: "Edit frames visually"
+weight: 50
+layout: "docs"
+type: "docs"
+description: "Add, edit, and delete frames and geometries directly in the 3D scene instead of editing JSON configuration."
+---
+
+{{< alert title="Preview feature" color="note" >}}
+Visual frame editing is currently behind a feature flag and may not be enabled for your organization.
+The interface and behavior described here may change before general availability.
+{{< /alert >}}
+
+When visual frame editing is enabled, the 3D scene tab becomes a configuration tool: you can add frames to components, reposition them by editing coordinates in the details panel, change parent frames, and attach or modify geometry, all without editing JSON directly.
+Changes you make in the 3D scene are written back to your machine's configuration and saved when you click **Save** in the app.
+
+## Prerequisites
+
+- Visual frame editing enabled for your organization (feature flag: `ENABLE_EDIT_FRAME_IN_VIZ_TAB`).
+- A machine with at least one component configured.
+
+## Add a frame to a component
+
+Components that do not yet have a frame configured appear in the **Add frames** panel.
+
+1. Open the 3D scene tab.
+2. Look for the **Add frames** panel. It lists components that do not have frames.
+3. Select a component from the dropdown.
+4. Click **Add frame**.
+
+The component appears in the scene at the world frame origin with default values (zero translation, identity orientation, no geometry).
+You can then reposition it using the details panel.
+
+## Edit a frame's position and orientation
+
+1. Select the component in the tree view or by clicking it in the 3D viewport.
+2. In the details panel, the **local position** and **local orientation** fields are editable input fields (rather than read-only values).
+3. Edit the position values (x, y, z in mm) to set the translation relative to the parent frame.
+4. Edit the orientation values (x, y, z, theta in degrees) to set the orientation as an orientation vector.
+
+Changes appear immediately in the 3D viewport as you type.
+The values you enter here correspond directly to the `translation` and `orientation` fields in the frame JSON configuration.
+
+## Change a frame's parent
+
+1. Select the component.
+2. In the details panel, the **parent frame** field is a dropdown instead of a read-only label.
+3. Select the new parent frame from the dropdown.
+
+The component moves in the scene to reflect its new position relative to the new parent.
+All children of this frame move with it.
+
+## Add or change geometry
+
+1. Select the component.
+2. In the details panel, find the **geometry** section.
+3. Click one of the geometry type buttons: **None**, **Box**, **Sphere**, or **Capsule**.
+4. If you selected a geometry type, dimension fields appear:
+   - **Box**: x, y, z dimensions in mm.
+   - **Sphere**: radius (r) in mm.
+   - **Capsule**: radius (r) and length (l) in mm.
+5. Enter the dimensions. The geometry renders in the scene as you type.
+
+To remove a geometry, click **None**.
+
+## Delete a frame
+
+1. Select the component.
+2. In the details panel, click **Delete frame** at the bottom of the actions section.
+
+This removes the frame configuration from the component.
+The component disappears from the 3D scene but remains in your machine configuration (it just no longer has a spatial position in the frame system).
+
+## Save your changes
+
+Changes made in the 3D scene are held locally until you save.
+The app shows an unsaved changes indicator when you have pending edits.
+Click **Save** in the machine configuration header to write all changes to your machine's configuration.
+
+If you navigate away without saving, your changes are lost.
+
+## When to use visual editing
+
+Visual frame editing is most useful when:
+
+- You are setting up a new frame system and want to see the result as you go, rather than configuring JSON and then checking the 3D scene.
+- You need to make small adjustments to frame positions and want immediate visual feedback.
+- You are adding geometry to components and want to see whether the shapes cover the physical objects correctly.
+
+For bulk configuration changes, complex orientation values, or frames that reference components on different machine parts, editing the JSON configuration directly may be more efficient.
diff --git a/docs/motion-planning/3d-scene/set-up-obstacle-avoidance.md b/docs/motion-planning/3d-scene/set-up-obstacle-avoidance.md
new file mode 100644
index 0000000000..390a41772c
--- /dev/null
+++ b/docs/motion-planning/3d-scene/set-up-obstacle-avoidance.md
@@ -0,0 +1,83 @@
+---
+linkTitle: "Set up obstacle avoidance"
+title: "Set up obstacle avoidance"
+weight: 40
+layout: "docs"
+type: "docs"
+description: "Visualize and adjust obstacle geometry so the motion planner routes around physical objects."
+---
+
+The motion planner needs to know where physical objects are in your workspace to plan collision-free paths.
+You define obstacles as geometries (boxes, spheres, or capsules) positioned in the frame system.
+The 3D scene tab lets you see exactly how these geometries cover your workspace, so you can verify that the planner has an accurate picture before you run a motion plan.
+
+## Prerequisites
+
+- A machine with an arm or gantry configured.
+- At least a basic frame system configured (arm frame and world frame).
+- Physical objects in the workspace that the arm needs to avoid.
+
+## Visualize existing obstacles
+
+### 1. Open the 3D scene tab
+
+Navigate to your machine in the [Viam app](https://app.viam.com) and click the **3D scene** tab.
+
+### 2. Identify obstacles in the scene
+
+Obstacle geometries appear as translucent shapes.
+Each geometry is positioned according to its frame configuration: its location is defined by a translation and orientation relative to a parent frame.
+
+Click an obstacle in the scene or the tree view to see its details:
+
+- **Geometry type**: box, sphere, or capsule.
+- **Dimensions**: size in mm (for example, x/y/z for a box, radius for a sphere, radius and length for a capsule).
+- **Position**: where the geometry's center is located.
+- **Parent frame**: which frame the geometry is attached to.
+
+### 3. Compare geometry to physical objects
+
+Orbit the scene to view obstacles from different angles.
+Check that:
+
+- Each geometry fully covers the physical object it represents. A box that is too narrow leaves a gap the arm could pass through.
+- Geometries are not larger than necessary. Oversized obstacles restrict the planner's solution space and can make valid targets unreachable.
+- The geometry center is at the physical object's center. A table surface geometry should be centered at the table surface height, not at the floor.
+
+## Add or adjust obstacles
+
+Obstacles are defined in the motion service configuration or passed as a `WorldState` parameter to `Move` requests.
+For static obstacles (tables, walls, posts), define them in the configuration so they persist across motion plans.
+
+See [Define obstacles](/motion-planning/obstacles/) for the full configuration reference, including JSON examples for each geometry type.
+
+After changing obstacle configuration, return to the 3D scene tab to verify the changes.
+The scene reflects the current saved configuration.
+
+## Choose the right geometry type
+
+| Physical object  | Recommended geometry | Notes                                                                                 |
+| ---------------- | -------------------- | ------------------------------------------------------------------------------------- |
+| Table or shelf   | Box                  | Match the surface dimensions. Include thickness if the arm could approach from below. |
+| Post or column   | Capsule              | Set the radius to match the column width, length to match the height.                 |
+| Round obstacle   | Sphere               | Use the bounding radius. Simple and fast for collision checking.                      |
+| Wall or barrier  | Box                  | Use a thin box with large x and z dimensions.                                         |
+| Irregular object | Box (oversized)      | Use the bounding box of the object. Oversizing is safer than undersizing.             |
+
+## Verify coverage
+
+After defining obstacles, run through this checklist in the 3D scene:
+
+1. **Orbit to each workspace boundary.** Can the arm reach past the obstacle geometry into the physical object? If yes, the geometry needs to be larger.
+2. **Check the floor and ceiling.** If the arm can reach the floor, add a floor plane geometry. Same for ceiling-mounted setups.
+3. **Check between obstacles.** Narrow gaps between geometries that the arm cannot physically fit through should be closed by extending one or both geometries.
+4. **Move the arm to known-good targets.** If a target that should be reachable is blocked by obstacle geometry, the geometry is oversized or mispositioned.
+
+## Dynamic obstacles
+
+Static obstacles defined in configuration cover fixed objects in the workspace.
+For objects that move (a person, a moving conveyor, another robot), you can pass obstacle geometry at runtime in the `WorldState` parameter of the `Move` request.
+Dynamic obstacles use the same geometry types (box, sphere, capsule) and appear in the 3D scene when passed to the motion planner.
+
+Pair a vision service with a camera to detect obstacles at runtime and feed them into the motion planner as dynamic obstacles.
+See the [motion service API reference](/motion-planning/reference/) for details on obstacle detectors.
diff --git a/docs/motion-planning/3d-scene/verify-point-cloud-alignment.md b/docs/motion-planning/3d-scene/verify-point-cloud-alignment.md
new file mode 100644
index 0000000000..a9b963ad27
--- /dev/null
+++ b/docs/motion-planning/3d-scene/verify-point-cloud-alignment.md
@@ -0,0 +1,64 @@
+---
+linkTitle: "Verify point cloud alignment"
+title: "Verify point cloud alignment"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "Display a depth camera's point cloud in the 3D scene to verify that the data aligns with your frame system and workspace geometry."
+aliases:
+  - /motion-planning/3d-scene/inspect-point-clouds/
+---
+
+Depth cameras produce point clouds: sets of 3D points representing the surfaces visible to the camera.
+The 3D scene tab can display these point clouds in the context of your frame system, so you can verify that the camera is producing good data and that the data aligns with your workspace geometry.
+
+If the point cloud does not align with the physical objects in your workspace, either the camera's frame offset is wrong or the camera itself has a problem.
+Catching this early prevents issues with vision pipelines, object detection, SLAM, and motion planning that depend on accurate spatial data.
+
+## Prerequisites
+
+- A machine with a depth camera configured and producing point cloud data.
+- The camera must support the `GetPointCloud` method (check the camera's `supports_pcd` property).
+- A frame configured for the camera with translation and orientation values that reflect its physical mounting position.
+
+## Steps
+
+### 1. Open the 3D scene tab
+
+Navigate to your machine in the [Viam app](https://app.viam.com) and click the **3D scene** tab.
+Your machine must be online for live point cloud data.
+
+### 2. Enable point cloud display
+
+Open the settings panel (gear icon) and go to the **Pointclouds** tab.
+You will see a list of cameras on your machine that support point clouds.
+Enable the toggle for each camera you want to display.
+
+You can also configure:
+
+- **Point size**: how large each point renders in the scene. Increase this if points are hard to see; decrease it for denser clouds.
+- **Default color**: the color used for points that do not have color data from the camera.
+
+### 3. Check spatial alignment
+
+The point cloud renders in the scene positioned according to the camera's frame in your frame system.
+If the frame configuration is correct, the point cloud should align with physical objects in your workspace:
+
+- Flat surfaces (tables, walls) appear as planes of points at the correct height and position relative to other components.
+- Objects appear as clusters of points at the expected distances from the camera.
+- The floor should appear at the expected height relative to the world frame.
+
+If the point cloud appears shifted, rotated, or in an unexpected location, the camera's frame offset or orientation is likely wrong.
+See [Calibrate frame offsets](/motion-planning/3d-scene/calibrate-frame-offsets/).
+
+### 4. Check data quality
+
+If the point cloud is in the right place but the data looks wrong, look for common depth camera issues:
+
+- **Gaps or holes**: areas where the camera cannot measure depth (reflective surfaces, transparent objects, surfaces at extreme angles).
+- **Noise at edges**: depth values that jump between foreground and background at object boundaries.
+- **Range limitations**: points missing beyond the camera's maximum depth range.
+- **Sparse data**: too few points to be useful. Check the camera's resolution and depth mode settings.
+
+Data quality problems are camera issues, not frame system issues.
+Adjust the camera's configuration, mounting angle, or lighting conditions to address them.
diff --git a/docs/motion-planning/_index.md b/docs/motion-planning/_index.md
new file mode 100644
index 0000000000..2d2452dcaa
--- /dev/null
+++ b/docs/motion-planning/_index.md
@@ -0,0 +1,105 @@
+---
+linkTitle: "Motion planning"
+title: "Motion Planning"
+weight: 160
+layout: "docs"
+type: "docs"
+no_list: true
+noedit: true
+open_on_desktop: true
+overview: true
+description: "Plan and execute collision-free movements for robot arms and gantries."
+notoc: true
+# Aliases stripped — /operate/mobility/ and /operate/mobility/motion-concepts/
+# still exist on new-docs-site. Add back when those pages are deleted.
+---
+
+Your robot arm needs to move from one position to another without colliding with
+the table, the walls, or itself. Motion planning computes collision-free paths
+through 3D space, taking into account the arm's kinematic model, the workspace
+geometry, and any constraints on how the arm should move.
+
+Viam's motion planning system handles this automatically. You define the spatial
+layout of your workspace (the frame system), describe what obstacles exist, and
+tell the arm where to go. The motion planner finds a safe path and executes it.
+
+This section covers motion planning for arms, gantries, and other kinematic
+chains. For GPS-based autonomous navigation with mobile bases, see
+[Navigation](/navigation/).
+
+## How It Works
+
+Motion planning in Viam connects several pieces:
+
+1. **Frame system**: a coordinate tree that tracks where every component is in
+   space. The frame system lets you specify target positions in any frame and
+   translates between them automatically.
+
+2. **Kinematic model**: a description of the arm's joints and links that tells
+   the planner what configurations are physically possible.
+
+3. **Obstacles**: geometry (boxes, spheres, capsules) that define regions the
+   arm must avoid.
+
+4. **Constraints**: rules about how the arm should move between poses, such as
+   keeping the end effector on a straight line or maintaining its orientation.
+
+5. **Motion service**: the service that takes all of the above and computes a
+   collision-free path from the current pose to the target pose.
+
+## Get Started
+
+Set up the spatial model for your workspace, then use the how-to guides to move
+your hardware.
+
+### Understand your workspace
+
+{{< cards >}}
+{{% card link="/motion-planning/frame-system/" noimage="true" %}}
+{{% card link="/motion-planning/obstacles/" noimage="true" %}}
+{{% card link="/motion-planning/camera-calibration/" noimage="true" %}}
+{{< /cards >}}
+
+### Configure your frame system
+
+{{< cards >}}
+{{% card link="/motion-planning/frame-system-how-to/arm-gripper-camera/" noimage="true" %}}
+{{% card link="/motion-planning/frame-system-how-to/arm-fixed-camera/" noimage="true" %}}
+{{% card link="/motion-planning/frame-system-how-to/mobile-base-sensors/" noimage="true" %}}
+{{% card link="/motion-planning/frame-system-how-to/mobile-base-arm/" noimage="true" %}}
+{{< /cards >}}
+
+### Visualize and debug your workspace
+
+{{< cards >}}
+{{% card link="/motion-planning/3d-scene/" noimage="true" %}}
+{{% card link="/motion-planning/3d-scene/debug-motion-plan/" noimage="true" %}}
+{{% card link="/motion-planning/3d-scene/calibrate-frame-offsets/" noimage="true" %}}
+{{% card link="/motion-planning/3d-scene/verify-point-cloud-alignment/" noimage="true" %}}
+{{% card link="/motion-planning/3d-scene/set-up-obstacle-avoidance/" noimage="true" %}}
+{{% card link="/motion-planning/3d-scene/edit-frames/" noimage="true" %}}
+{{< /cards >}}
+
+### Plan and execute motion
+
+{{< cards >}}
+{{% card link="/motion-planning/motion-how-to/move-arm-to-pose/" noimage="true" %}}
+{{% card link="/motion-planning/motion-how-to/move-arm-with-constraints/" noimage="true" %}}
+{{% card link="/motion-planning/motion-how-to/avoid-obstacles/" noimage="true" %}}
+{{% card link="/motion-planning/motion-how-to/move-gantry/" noimage="true" %}}
+{{< /cards >}}
+
+### Manipulation
+
+{{< cards >}}
+{{% card link="/motion-planning/motion-how-to/pick-an-object/" noimage="true" %}}
+{{% card link="/motion-planning/motion-how-to/place-an-object/" noimage="true" %}}
+{{< /cards >}}
+
+### Understand the internals
+
+{{< cards >}}
+{{% card link="/motion-planning/constraints/" noimage="true" %}}
+{{% card link="/motion-planning/reference/algorithms/" noimage="true" %}}
+{{% card link="/motion-planning/reference/" noimage="true" %}}
+{{< /cards >}}
diff --git a/docs/motion-planning/camera-calibration.md b/docs/motion-planning/camera-calibration.md
new file mode 100644
index 0000000000..561dc8b326
--- /dev/null
+++ b/docs/motion-planning/camera-calibration.md
@@ -0,0 +1,256 @@
+---
+linkTitle: "Camera Calibration"
+title: "Calibrate a Camera for Motion Planning"
+weight: 60
+layout: "docs"
+type: "docs"
+description: "Compute camera intrinsic and distortion parameters for accurate 2D-to-3D projection."
+aliases:
+  - /work-cell-layout/calibrate-camera-to-robot/
+  - /build/work-cell-layout/calibrate-camera-to-robot/
+---
+
+A camera captures 2D images, but your robot operates in 3D space. To convert
+pixel coordinates into real-world positions (for example, to tell the arm
+where an object is) you need to know the camera's intrinsic parameters. These
+parameters describe how the camera projects 3D space onto its 2D sensor: the
+focal length, the principal point (optical center), and the lens distortion
+characteristics.
+
+Without accurate intrinsics, every 2D-to-3D conversion will be wrong. Detected
+objects will appear shifted, depth estimates will be inaccurate, and the arm will
+miss its targets.
+
+## Concepts
+
+### Camera intrinsic parameters
+
+| Parameter   | Description                                               |
+| ----------- | --------------------------------------------------------- |
+| `fx`        | Focal length in the x direction (pixels)                  |
+| `fy`        | Focal length in the y direction (pixels)                  |
+| `ppx`       | Principal point x coordinate (pixels), the optical center |
+| `ppy`       | Principal point y coordinate (pixels), the optical center |
+| `width_px`  | Image width in pixels                                     |
+| `height_px` | Image height in pixels                                    |
+
+### Distortion parameters
+
+| Parameter | Description                              |
+| --------- | ---------------------------------------- |
+| `rk1`     | First radial distortion coefficient      |
+| `rk2`     | Second radial distortion coefficient     |
+| `rk3`     | Third radial distortion coefficient      |
+| `tp1`     | First tangential distortion coefficient  |
+| `tp2`     | Second tangential distortion coefficient |
+
+Radial distortion causes barrel or pincushion effects. Tangential distortion
+occurs when the lens is not perfectly parallel to the sensor.
+
+### Eye-in-hand vs eye-to-hand
+
+- **Eye-in-hand**: camera mounted on the robot arm. Frame parent is the arm.
+  Moves with the arm.
+- **Eye-to-hand**: camera on a fixed mount. Frame parent is the world frame.
+  Stays stationary.
+
+The calibration process is the same for both. Only the frame configuration
+differs.
+
+## Steps
+
+### 1. Print a calibration target
+
+Print a standard chessboard calibration pattern (at least 8x6 inner corners).
+Mount it on a flat, rigid surface. Measure the square size with a ruler.
+
+### 2. Capture calibration images
+
+Take 10-15 images of the chessboard from various positions and angles using
+the **CONTROL** tab in the Viam app.
+
+Guidelines:
+
+- Cover the entire field of view (center, corners, edges)
+- Vary the distance from closest to farthest working range
+- Tilt the chessboard 15-30 degrees in different directions
+- The full chessboard must be visible in every image
+- Avoid shadows, glare, and motion blur
+
+### 3. Run the calibration script
+
+Download [`cameraCalib.py`](https://github.com/viam-labs/camera-calibration/blob/main/cameraCalib.py)
+from the [camera-calibration repository](https://github.com/viam-labs/camera-calibration),
+then run it:
+
+```sh
+pip3 install numpy opencv-python
+python3 cameraCalib.py YOUR_PICTURES_DIRECTORY
+```
+
+A successful calibration produces output like:
+
+```json
+{
+  "intrinsic_parameters": {
+    "fx": 939.27,
+    "fy": 940.29,
+    "ppx": 320.61,
+    "ppy": 239.14,
+    "width_px": 640,
+    "height_px": 480
+  },
+  "distortion_parameters": {
+    "rk1": 0.0465,
+    "rk2": 0.8003,
+    "rk3": -5.408,
+    "tp1": -0.000009,
+    "tp2": -0.002829
+  }
+}
+```
+
+The reprojection error should be less than 1.0 pixel. Above 2.0 indicates
+poor calibration. Retake images.
+
+### 4. Add parameters to camera config
+
+```json
+{
+  "name": "my-camera",
+  "api": "rdk:component:camera",
+  "model": "webcam",
+  "attributes": {
+    "video_path": "video0",
+    "width_px": 640,
+    "height_px": 480,
+    "intrinsic_parameters": {
+      "fx": 939.27,
+      "fy": 940.29,
+      "ppx": 320.61,
+      "ppy": 239.14,
+      "width_px": 640,
+      "height_px": 480
+    },
+    "distortion_parameters": {
+      "rk1": 0.0465,
+      "rk2": 0.8003,
+      "rk3": -5.408,
+      "tp1": -0.000009,
+      "tp2": -0.002829
+    }
+  }
+}
+```
+
+### 5. Configure the camera frame
+
+**Eye-in-hand (camera mounted on the arm):**
+
+```json
+{
+  "parent": "my-arm",
+  "translation": { "x": 50, "y": 0, "z": 80 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 1, "z": 0, "th": -30 }
+  }
+}
+```
+
+**Eye-to-hand (camera on a fixed mount):**
+
+```json
+{
+  "parent": "world",
+  "translation": { "x": 500, "y": 300, "z": 800 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 180 }
+  }
+}
+```
+
+### 6. Verify calibration accuracy
+
+Place an object at a measured position. Use `TransformPose` to convert the
+detected position from camera frame to world frame and compare.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.proto.common import PoseInFrame, Pose
+
+detected_in_camera = PoseInFrame(
+    reference_frame="my-camera",
+    pose=Pose(x=50, y=30, z=400)
+)
+
+detected_in_world = await machine.transform_pose(detected_in_camera, "world")
+print("Detected position in world frame:")
+print(f"  x={detected_in_world.pose.x:.1f} mm")
+print(f"  y={detected_in_world.pose.y:.1f} mm")
+print(f"  z={detected_in_world.pose.z:.1f} mm")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+detectedInCamera := referenceframe.NewPoseInFrame("my-camera",
+    spatialmath.NewPoseFromPoint(r3.Vector{X: 50, Y: 30, Z: 400}))
+
+detectedInWorld, err := machine.TransformPose(ctx, detectedInCamera, "world", nil)
+if err != nil {
+    logger.Fatal(err)
+}
+
+pt := detectedInWorld.Pose().Point()
+fmt.Printf("Detected position in world frame:\n")
+fmt.Printf("  x=%.1f mm\n", pt.X)
+fmt.Printf("  y=%.1f mm\n", pt.Y)
+fmt.Printf("  z=%.1f mm\n", pt.Z)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+If the computed position is within 10-20 mm of the measured position at a
+working distance of 500-1000 mm, your calibration is good.
+
+## Troubleshooting
+
+{{< expand "Calibration script fails to find chessboard corners" >}}
+
+- Verify the chessboard is fully visible in every image.
+- Check lighting. Shadows and glare prevent corner detection.
+- Ensure the chessboard is flat, not curled.
+- Verify the expected pattern size matches your chessboard.
+
+{{< /expand >}}
+
+{{< expand "3D positions are consistently offset" >}}
+
+- Check the camera frame translation. Measure the physical offset and update.
+- Check the camera frame orientation. A tilted camera needs the tilt reflected.
+- Verify the parent frame is correct (arm vs world).
+
+{{< /expand >}}
+
+{{< expand "Accuracy varies with distance" >}}
+
+- Depth errors grow with distance for all depth cameras.
+- Re-run calibration with more images at your target working distance.
+- Check the camera's specified depth range.
+
+{{< /expand >}}
+
+## What's Next
+
+- [Define Your Frame System](/motion-planning/frame-system/): configure
+  component frames for spatial reasoning.
+- [Define Obstacles](/motion-planning/obstacles/): add collision geometry using
+  calibrated camera data.
+- [Move an Arm to a Target Pose](/motion-planning/motion-how-to/move-arm-to-pose/):
+  use calibrated positions to plan arm movements.
diff --git a/docs/motion-planning/constraints.md b/docs/motion-planning/constraints.md
new file mode 100644
index 0000000000..5cf7e156f2
--- /dev/null
+++ b/docs/motion-planning/constraints.md
@@ -0,0 +1,241 @@
+---
+linkTitle: "Constraints"
+title: "Configure Motion Constraints"
+weight: 40
+layout: "docs"
+type: "docs"
+description: "Restrict how the arm moves between poses using linear, orientation, and collision constraints."
+aliases:
+  - /reference/services/motion/constraints/
+  - /services/motion/constraints/
+  - /mobility/motion/constraints/
+---
+
+By default, the motion planner finds any collision-free path from the current
+pose to the target pose. The path may curve, twist, or take the end effector
+through any orientation along the way. For many tasks this is fine, but some
+tasks require the arm to move in a specific way:
+
+- Carrying a cup of water requires the end effector to stay level.
+- Welding a seam requires the tool to follow a straight line.
+- Moving near obstacles may require relaxing collision checking between specific
+  frame pairs.
+
+Constraints let you specify these rules. The motion planner only returns paths
+that satisfy all constraints.
+
+## Constraint types
+
+Viam supports four constraint types. You can combine multiple constraints in a
+single motion request.
+
+### LinearConstraint
+
+Forces the end effector to stay close to a straight line between the start and
+goal poses. Use this for straight-line tool paths.
+
+| Parameter                    | Type             | Description                                                                                 |
+| ---------------------------- | ---------------- | ------------------------------------------------------------------------------------------- |
+| `line_tolerance_mm`          | float (optional) | Maximum deviation from the straight line, in millimeters. Only checked when greater than 0. |
+| `orientation_tolerance_degs` | float (optional) | Maximum orientation deviation during motion, in degrees. Only checked when greater than 0.  |
+
+When `line_tolerance_mm` is set, the planner checks that the end effector stays
+within that distance of the line segment connecting start and goal positions.
+When `orientation_tolerance_degs` is set, the planner checks that the end
+effector orientation stays within that angular distance of either the start or
+goal orientation.
+
+### OrientationConstraint
+
+Forces the end effector to maintain a consistent orientation throughout the
+motion. Use this when the end effector must stay level or keep a fixed
+orientation (for example, carrying a liquid).
+
+| Parameter                    | Type             | Description                                                                  |
+| ---------------------------- | ---------------- | ---------------------------------------------------------------------------- |
+| `orientation_tolerance_degs` | float (optional) | Maximum orientation deviation, in degrees. Only checked when greater than 0. |
+
+The planner checks that the current orientation stays within the specified
+tolerance of whichever is closer: the start orientation or the goal orientation.
+This allows smooth transitions when start and goal have different orientations.
+
+### PseudolinearConstraint
+
+Like LinearConstraint but uses proportional tolerances instead of fixed values.
+The actual tolerance scales with the distance between start and goal.
+
+| Parameter                      | Type             | Description                                                                                         |
+| ------------------------------ | ---------------- | --------------------------------------------------------------------------------------------------- |
+| `line_tolerance_factor`        | float (optional) | Proportional factor. Actual tolerance = factor x distance(start, goal).                             |
+| `orientation_tolerance_factor` | float (optional) | Proportional factor for orientation. Actual tolerance = factor x orientation_distance(start, goal). |
+
+Use this when you want the constraint to adapt to the length of the motion. A
+short move gets a tight tolerance; a long move gets a proportionally larger one.
+
+### CollisionSpecification
+
+Allows specific pairs of frames to collide during planning. By default, the
+planner rejects any path where any two frames collide. CollisionSpecification
+lets you whitelist specific pairs.
+
+| Parameter | Type                | Description                                          |
+| --------- | ------------------- | ---------------------------------------------------- |
+| `allows`  | list of frame pairs | Each entry has `frame1` and `frame2` (string names). |
+
+This is useful when:
+
+- A gripper is expected to contact the object it is picking up.
+- Two components are physically close and their simplified collision geometries
+  overlap, but the real components do not collide.
+
+Frame names support hierarchical matching: specifying `"my-arm"` matches all
+sub-geometries of the arm (such as `my-arm:upper_arm_link`,
+`my-arm:forearm_link`).
+
+## Using constraints in code
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.services.motion import MotionClient
+from viam.proto.service.motion import Constraints, LinearConstraint, OrientationConstraint
+from viam.proto.common import PoseInFrame, Pose
+
+motion_service = MotionClient.from_robot(machine, "builtin")
+
+# Keep the end effector on a straight line with a level orientation
+constraints = Constraints(
+    linear_constraint=[
+        LinearConstraint(
+            line_tolerance_mm=5.0,
+        )
+    ],
+    orientation_constraint=[
+        OrientationConstraint(
+            orientation_tolerance_degs=5.0,
+        )
+    ]
+)
+
+destination = PoseInFrame(
+    reference_frame="world",
+    pose=Pose(x=300, y=200, z=400, o_x=0, o_y=0, o_z=-1, theta=0)
+)
+
+await motion_service.move(
+    component_name="my-arm",
+    destination=destination,
+    constraints=constraints
+)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+import (
+    motionpb "go.viam.com/api/service/motion/v1"
+    "go.viam.com/rdk/services/motion"
+)
+
+motionService, err := motion.FromRobot(machine, "builtin")
+if err != nil {
+    logger.Fatal(err)
+}
+
+lineTolerance := float32(5.0)
+orientTolerance := float32(5.0)
+
+constraints := &motionpb.Constraints{
+    LinearConstraint: []*motionpb.LinearConstraint{
+        {
+            LineToleranceMm: &lineTolerance,
+        },
+    },
+    OrientationConstraint: []*motionpb.OrientationConstraint{
+        {
+            OrientationToleranceDegs: &orientTolerance,
+        },
+    },
+}
+
+// Pass constraints in the Move request
+_, err = motionService.Move(ctx, motion.MoveReq{
+    ComponentName: "my-arm",
+    Destination:   destination,
+    Constraints:   constraints,
+})
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Allowing specific collisions
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.proto.service.motion import (
+    Constraints, CollisionSpecification
+)
+
+# Allow the gripper to contact the target object
+collision_spec = CollisionSpecification(
+    allows=[
+        CollisionSpecification.AllowedFrameCollisions(
+            frame1="my-gripper",
+            frame2="target-object"
+        )
+    ]
+)
+
+constraints = Constraints(
+    collision_specification=[collision_spec]
+)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+constraints := &motionpb.Constraints{
+    CollisionSpecification: []*motionpb.CollisionSpecification{
+        {
+            Allows: []*motionpb.CollisionSpecification_AllowedFrameCollisions{
+                {
+                    Frame1: "my-gripper",
+                    Frame2: "target-object",
+                },
+            },
+        },
+    },
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Performance considerations
+
+Constraints make the planner's job harder. The planner must check each candidate
+path segment against all constraints, and constrained solutions are harder to
+find than unconstrained ones.
+
+- **Tight tolerances** (small `line_tolerance_mm` or `orientation_tolerance_degs`)
+  increase planning time and may cause the planner to fail if no path exists
+  within the tolerance.
+- **Start with larger tolerances** and tighten only as needed. A 10 mm linear
+  tolerance is easier to satisfy than a 1 mm tolerance.
+- **Combining constraints** multiplies the difficulty. Use the minimum set of
+  constraints required for your task.
+
+## What's Next
+
+- [Move an Arm with Constraints](/motion-planning/motion-how-to/move-arm-with-constraints/):
+  practical examples of constrained motion.
+- [Motion Planning Algorithms](/motion-planning/reference/algorithms/): how the planner
+  searches for constrained paths.
+- [Define Obstacles](/motion-planning/obstacles/): define the geometry the
+  planner uses for collision checking.
diff --git a/docs/motion-planning/frame-system-how-to/_index.md b/docs/motion-planning/frame-system-how-to/_index.md
new file mode 100644
index 0000000000..3e5586c5ac
--- /dev/null
+++ b/docs/motion-planning/frame-system-how-to/_index.md
@@ -0,0 +1,17 @@
+---
+linkTitle: "Frame How-Tos"
+title: "Frame System How-Tos"
+weight: 15
+layout: "docs"
+type: "docs"
+description: "Configure the frame system for common hardware setups."
+---
+
+Choose the guide that matches your hardware setup.
+
+{{< cards >}}
+{{% card link="/motion-planning/frame-system-how-to/arm-gripper-camera/" noimage="true" %}}
+{{% card link="/motion-planning/frame-system-how-to/arm-fixed-camera/" noimage="true" %}}
+{{% card link="/motion-planning/frame-system-how-to/mobile-base-sensors/" noimage="true" %}}
+{{% card link="/motion-planning/frame-system-how-to/mobile-base-arm/" noimage="true" %}}
+{{< /cards >}}
diff --git a/docs/motion-planning/frame-system-how-to/arm-fixed-camera.md b/docs/motion-planning/frame-system-how-to/arm-fixed-camera.md
new file mode 100644
index 0000000000..c382e3b671
--- /dev/null
+++ b/docs/motion-planning/frame-system-how-to/arm-fixed-camera.md
@@ -0,0 +1,171 @@
+---
+linkTitle: "Arm with Fixed External Camera"
+title: "Arm with Fixed External Camera"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "Configure frames for a table-mounted arm with a camera mounted separately, such as overhead or on a tripod."
+---
+
+In this setup, the arm and camera are both positioned independently in the workspace.
+The camera is mounted overhead, on a tripod, or at some other fixed location rather than on the arm itself.
+This is common for vision-guided pick-and-place tasks where the camera needs to observe the entire workspace from a fixed vantage point.
+
+## Frame hierarchy
+
+```text
+world
+├── my-arm
+│   └── my-gripper (attached to arm)
+├── my-camera (overhead or tripod-mounted)
+└── table-surface
+```
+
+The key difference from a wrist-mounted camera setup is that the camera is a child of the world frame, not the arm.
+The camera frame stays fixed in space when the arm moves.
+
+## Steps
+
+### 1. Choose your world frame
+
+Pick a fixed, easy-to-measure point in your workspace.
+A table corner works well for this setup because you need to measure distances to both the arm base and the camera position from the same reference point.
+
+Mark the origin physically so you can take consistent measurements to both the arm and the camera.
+
+### 2. Add a frame to the arm
+
+In the [Viam app](https://app.viam.com), navigate to your machine and click the **CONFIGURE** tab.
+Find your arm component and click the **Frame** button.
+
+Measure the distance from your world frame origin to the arm base along each axis.
+For an arm base 300 mm to the right and 250 mm forward from a table corner:
+
+```json
+{
+  "parent": "world",
+  "translation": { "x": 300, "y": 250, "z": 0 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  }
+}
+```
+
+Click **Save**.
+
+### 3. Add a frame to the gripper
+
+Find your gripper component and click the **Frame** button.
+Set the parent to the arm:
+
+```json
+{
+  "parent": "my-arm",
+  "translation": { "x": 0, "y": 0, "z": 0 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  }
+}
+```
+
+If you have an adapter plate between the arm and gripper, set the z translation to the plate height in millimeters.
+
+Click **Save**.
+
+### 4. Add a frame to the fixed camera
+
+Find your camera component and click the **Frame** button.
+The camera's parent is `"world"`, not the arm.
+
+Measure the camera's position relative to your world frame origin.
+You need to measure in all three axes: left/right (x), forward/backward (y), and height (z).
+
+**Overhead camera example:**
+For a camera mounted 200 mm to the right, 300 mm forward, and 800 mm above the world frame origin:
+
+```json
+{
+  "parent": "world",
+  "translation": { "x": 200, "y": 300, "z": 800 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 1, "y": 0, "z": 0, "th": 180 }
+  }
+}
+```
+
+The orientation `(1, 0, 0), 180` rotates the camera frame 180 degrees around the x axis.
+This is appropriate for an overhead camera pointing straight down, because it flips the z axis to point downward.
+
+**Tripod-mounted camera at an angle:**
+For a camera on a tripod 500 mm to the left, 600 mm forward, and 700 mm above the origin, tilted 45 degrees downward:
+
+```json
+{
+  "parent": "world",
+  "translation": { "x": -500, "y": 600, "z": 700 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 1, "y": 0, "z": 0, "th": -45 }
+  }
+}
+```
+
+A negative angle around the x axis tilts the camera's view downward from the horizontal.
+
+Click **Save**.
+
+### 5. Verify axis directions
+
+Go to the **CONTROL** tab and jog the arm in small increments along each axis to confirm that +x, +y, and +z match your physical setup.
+If any axis is wrong, adjust the arm's orientation in the **CONFIGURE** tab.
+
+### 6. Visualize the frame system
+
+1. Navigate to the **3D SCENE** tab in the Viam app.
+2. Verify that the arm and camera frames appear as separate branches from the world frame.
+3. Confirm that the camera frame stays fixed when the arm moves.
+4. Check that the positions and orientations match your physical workspace.
+
+### 7. Verify with TransformPose
+
+Use `TransformPose` to verify the relationship between the camera and arm frames.
+Place an object at a known position visible to the camera, then transform that position from the camera frame to the world frame.
+The result should match the object's measured position in the workspace.
+
+For details on the TransformPose API, see [Frame system: TransformPose](/motion-planning/frame-system/#transformpose).
+
+## Troubleshooting
+
+{{< expand "Camera frame moves when the arm moves" >}}
+
+The camera's `parent` field is set to the arm instead of `"world"`.
+Change the parent to `"world"` so the camera frame remains fixed in space.
+
+{{< /expand >}}
+
+{{< expand "Overhead camera orientation looks wrong in the visualizer" >}}
+
+For a camera pointing straight down, the rotation should be 180 degrees around the x axis: `"value": { "x": 1, "y": 0, "z": 0, "th": 180 }`.
+This flips the camera's z axis to point downward.
+If the camera is rotated in the horizontal plane as well (not aligned with the x or y axis), you may need to combine rotations or use a different orientation type.
+
+{{< /expand >}}
+
+{{< expand "Transformed coordinates are consistently offset" >}}
+
+Double-check your physical measurements from the world frame origin to the camera.
+Small measurement errors accumulate, so measure carefully.
+If you are using a table corner as the world frame, make sure you are measuring from the same corner consistently.
+
+{{< /expand >}}
+
+## What's Next
+
+{{< cards >}}
+{{% card link="/motion-planning/motion-how-to/move-arm-to-pose/" noimage="true" %}}
+{{% card link="/motion-planning/obstacles/" noimage="true" %}}
+{{% card link="/motion-planning/camera-calibration/" noimage="true" %}}
+{{< /cards >}}
diff --git a/docs/motion-planning/frame-system-how-to/arm-gripper-camera.md b/docs/motion-planning/frame-system-how-to/arm-gripper-camera.md
new file mode 100644
index 0000000000..c61635eb06
--- /dev/null
+++ b/docs/motion-planning/frame-system-how-to/arm-gripper-camera.md
@@ -0,0 +1,208 @@
+---
+linkTitle: "Arm with Gripper and Wrist Camera"
+title: "Arm with Gripper and Wrist Camera"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Configure frames for a table-mounted arm with an attached gripper and wrist-mounted camera."
+---
+
+This is the most common manipulation setup: a table-mounted arm with a gripper on the end effector and a camera mounted on the arm near the gripper.
+The camera moves with the arm, giving you a consistent view of whatever the arm is reaching for.
+This guide walks you through configuring the frame system for this hardware arrangement.
+
+## Frame hierarchy
+
+```text
+world
+├── my-arm
+│   ├── my-gripper (attached to arm)
+│   └── my-camera (mounted on arm)
+└── table-surface
+```
+
+The arm is a direct child of the world frame.
+The gripper and camera are both children of the arm, so they move with the arm automatically as it changes position.
+
+## Steps
+
+### 1. Choose your world frame
+
+Pick a fixed point in your workspace that is easy to measure from.
+For a table-mounted arm, the arm base or a table corner are good choices.
+
+If you choose the arm base as the world frame origin, the arm's translation offset will be `(0, 0, 0)`.
+If you choose a table corner, you will need to measure the distance from that corner to the arm base.
+
+Mark your chosen origin physically so you can take consistent measurements.
+
+### 2. Add a frame to the arm
+
+In the [Viam app](https://app.viam.com), navigate to your machine and click the **CONFIGURE** tab.
+Find your arm component and click the **Frame** button.
+
+If the arm base is your world frame origin:
+
+```json
+{
+  "parent": "world",
+  "translation": { "x": 0, "y": 0, "z": 0 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  }
+}
+```
+
+If the world frame origin is at a table corner and the arm base is 300 mm to the right and 250 mm forward from that corner:
+
+```json
+{
+  "parent": "world",
+  "translation": { "x": 300, "y": 250, "z": 0 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  }
+}
+```
+
+Click **Save** after adding the frame.
+
+### 3. Verify axis directions
+
+Before adding more frames, confirm that the arm's coordinate axes match your expectations.
+
+1. Go to the **CONTROL** tab and find your arm.
+2. Use the arm's **TEST** panel to jog the end effector in small increments along each axis.
+3. Command a move in the +z direction and observe which way the arm moves physically. If +z moves the arm up, the z axis matches the standard convention.
+4. Repeat for +x and +y.
+
+If an axis points the wrong way, adjust the `orientation` field in the arm's frame.
+For example, if the arm's +x points opposite to your intended +x, rotate 180 degrees around the z axis:
+
+```json
+{
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 180 }
+  }
+}
+```
+
+### 4. Add a frame to the gripper
+
+Find your gripper component in the **CONFIGURE** tab and click the **Frame** button.
+
+If the gripper attaches directly to the arm's end effector with no adapter plate, use a zero offset:
+
+```json
+{
+  "parent": "my-arm",
+  "translation": { "x": 0, "y": 0, "z": 0 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  }
+}
+```
+
+If the gripper is mounted through an adapter plate or flange that adds height, set the z translation to the adapter height in millimeters.
+For example, with a 50 mm adapter plate:
+
+```json
+{
+  "parent": "my-arm",
+  "translation": { "x": 0, "y": 0, "z": 50 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  }
+}
+```
+
+Click **Save**.
+
+### 5. Add a frame to the wrist camera
+
+Find your camera component in the **CONFIGURE** tab and click the **Frame** button.
+
+The camera's parent is the arm, not the world frame.
+Measure the offset from the arm's end effector to the camera's optical center.
+For a camera mounted 30 mm to the side and 60 mm above the end effector:
+
+```json
+{
+  "parent": "my-arm",
+  "translation": { "x": 0, "y": 30, "z": 60 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  }
+}
+```
+
+If the camera is tilted downward (for example, angled 30 degrees toward the gripper), add a rotation around the x axis:
+
+```json
+{
+  "parent": "my-arm",
+  "translation": { "x": 0, "y": 30, "z": 60 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 1, "y": 0, "z": 0, "th": -30 }
+  }
+}
+```
+
+Click **Save**.
+
+### 6. Visualize the frame system
+
+1. Navigate to the **3D SCENE** tab in the Viam app.
+2. The viewer renders all configured frames in 3D space. Each frame appears as a set of colored axes (red = x, green = y, blue = z).
+3. Verify that the gripper and camera frames are attached to the arm and move with it.
+4. Check that the positions and orientations match your physical setup.
+
+If a frame appears in the wrong position, return to the **CONFIGURE** tab and adjust the translation or orientation values.
+
+### 7. Verify with TransformPose
+
+Use the `TransformPose` API to confirm that the frame system computes correct transforms between frames.
+Express the camera's origin `(0, 0, 0)` in the camera frame and transform it to the world frame.
+The result should match the physical position of the camera.
+
+For details on the TransformPose API, see [Frame system: TransformPose](/motion-planning/frame-system/#transformpose).
+
+## Troubleshooting
+
+{{< expand "Gripper or camera frame does not move with the arm" >}}
+
+Check that the `parent` field is set to your arm's component name (for example, `"my-arm"`), not `"world"`.
+If the parent is `"world"`, the frame stays fixed in space when the arm moves.
+
+{{< /expand >}}
+
+{{< expand "Camera image appears rotated or flipped" >}}
+
+The camera's orientation in the frame system must match its physical mounting orientation.
+If the camera is mounted upside down, add a 180-degree rotation around the z axis.
+If the image is mirrored, check whether you need to rotate around the x or y axis.
+
+{{< /expand >}}
+
+{{< expand "Gripper offset seems wrong after adding an adapter plate" >}}
+
+Measure the adapter plate height from the arm's mounting flange to the gripper's mounting flange.
+Use this measurement as the z translation.
+If the adapter plate also offsets the gripper laterally, include x and y values as well.
+
+{{< /expand >}}
+
+## What's Next
+
+{{< cards >}}
+{{% card link="/motion-planning/motion-how-to/move-arm-to-pose/" noimage="true" %}}
+{{% card link="/motion-planning/obstacles/" noimage="true" %}}
+{{% card link="/motion-planning/reference/kinematics/" noimage="true" %}}
+{{< /cards >}}
diff --git a/docs/motion-planning/frame-system-how-to/mobile-base-arm.md b/docs/motion-planning/frame-system-how-to/mobile-base-arm.md
new file mode 100644
index 0000000000..7cd6b82a08
--- /dev/null
+++ b/docs/motion-planning/frame-system-how-to/mobile-base-arm.md
@@ -0,0 +1,215 @@
+---
+linkTitle: "Mobile Base with Arm"
+title: "Mobile Base with Arm"
+weight: 40
+layout: "docs"
+type: "docs"
+description: "Configure frames for a mobile base with a mounted arm, gripper, and sensors."
+---
+
+This setup combines a mobile base with a mounted arm, gripper, and sensors.
+The arm is a child of the base, so the entire arm subtree (including the gripper and any wrist-mounted camera) moves with the base as it navigates.
+Navigation sensors like a front camera and LIDAR are also mounted on the base.
+
+## Frame hierarchy
+
+```text
+world
+└── my-base
+    ├── my-arm (mounted on base)
+    │   ├── my-gripper
+    │   └── wrist-camera
+    ├── nav-camera (front-facing)
+    └── my-lidar
+```
+
+The base is a child of the world frame.
+The arm is a child of the base, and the gripper and wrist camera are children of the arm.
+Navigation sensors are children of the base.
+When the base moves, every frame in the tree moves with it.
+When the arm moves, only the arm, gripper, and wrist camera frames update.
+
+## Steps
+
+### 1. Choose your world frame
+
+For a mobile base, the world frame origin is typically the center of the base.
+All component positions are defined relative to this center point.
+
+### 2. Add a frame to the base
+
+In the [Viam app](https://app.viam.com), navigate to your machine and click the **CONFIGURE** tab.
+Find your base component and click the **Frame** button.
+
+```json
+{
+  "parent": "world",
+  "translation": { "x": 0, "y": 0, "z": 0 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  }
+}
+```
+
+Click **Save**.
+
+### 3. Add a frame to the arm
+
+Find your arm component and click the **Frame** button.
+The arm's parent is the base, not the world frame.
+
+Measure the offset from the center of the base to the arm's mounting point.
+For an arm mounted 100 mm forward of center and 200 mm above the base center:
+
+```json
+{
+  "parent": "my-base",
+  "translation": { "x": 0, "y": 100, "z": 200 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  }
+}
+```
+
+If the arm is mounted off-center to one side, include an x offset as well.
+
+Click **Save**.
+
+### 4. Add frames to the gripper and wrist camera
+
+Both the gripper and wrist camera are children of the arm.
+
+**Gripper** (attached directly to the end effector):
+
+```json
+{
+  "parent": "my-arm",
+  "translation": { "x": 0, "y": 0, "z": 0 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  }
+}
+```
+
+If there is an adapter plate between the arm and gripper, set the z translation to the plate height.
+
+**Wrist camera** (mounted on the arm, offset from the end effector):
+
+```json
+{
+  "parent": "my-arm",
+  "translation": { "x": 0, "y": 30, "z": 60 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  }
+}
+```
+
+Adjust the translation values to match the camera's actual mounting position relative to the arm's end effector.
+If the camera is tilted, add a rotation. For example, tilted 30 degrees downward:
+
+```json
+{
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 1, "y": 0, "z": 0, "th": -30 }
+  }
+}
+```
+
+Click **Save** after adding each frame.
+
+### 5. Add frames to navigation sensors
+
+Navigation sensors are children of the base, not the arm.
+
+**Front-facing navigation camera:**
+
+```json
+{
+  "parent": "my-base",
+  "translation": { "x": 0, "y": 200, "z": 120 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  }
+}
+```
+
+**LIDAR mounted on top of the base:**
+
+```json
+{
+  "parent": "my-base",
+  "translation": { "x": 0, "y": 0, "z": 150 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  }
+}
+```
+
+Adjust translation values to match your sensor mounting positions.
+
+Click **Save** after adding each frame.
+
+### 6. Visualize and verify
+
+1. Navigate to the **3D SCENE** tab in the Viam app.
+2. Verify that the arm, gripper, and wrist camera form a subtree under the base.
+3. Verify that navigation sensors are direct children of the base.
+4. Jog the arm using the **CONTROL** tab and confirm that only the arm subtree (arm, gripper, wrist camera) updates, while the base and navigation sensors stay in place.
+5. Check that all positions and orientations match your physical setup.
+
+### 7. Verify with TransformPose
+
+Use `TransformPose` to verify the full chain of transforms.
+For example, transform the wrist camera's origin from the camera frame to the world frame.
+The result should account for the base-to-arm offset, the arm's current joint positions, and the arm-to-camera offset.
+
+For details on the TransformPose API, see [Frame system: TransformPose](/motion-planning/frame-system/#transformpose).
+
+## Troubleshooting
+
+{{< expand "Arm frame does not move with the base" >}}
+
+Check that the arm's `parent` field is set to the base component name (for example, `"my-base"`), not `"world"`.
+If the arm's parent is `"world"`, moving the base will leave the arm frame behind.
+
+{{< /expand >}}
+
+{{< expand "Gripper position is wrong after base moves" >}}
+
+The gripper's parent should be the arm, not the base.
+The chain should be: world -> base -> arm -> gripper.
+If the gripper's parent is the base, its position will not account for the arm's joint positions.
+
+{{< /expand >}}
+
+{{< expand "Navigation camera and wrist camera report conflicting object positions" >}}
+
+These cameras have different parents (base and arm respectively), so their raw coordinates are in different reference frames.
+Always use `TransformPose` to convert positions to a common frame (such as the world frame) before comparing them.
+Also verify that each camera's translation and orientation offsets are accurate.
+
+{{< /expand >}}
+
+{{< expand "Arm subtree shifts unexpectedly when base rotates" >}}
+
+This is expected behavior. When the base rotates, the arm's position in the world frame changes because the arm is mounted on the base.
+If the shift seems incorrect, check the arm's translation offset from the base.
+An arm mounted off-center will trace a larger arc when the base rotates.
+
+{{< /expand >}}
+
+## What's Next
+
+{{< cards >}}
+{{% card link="/motion-planning/motion-how-to/move-arm-to-pose/" noimage="true" %}}
+{{% card link="/motion-planning/obstacles/" noimage="true" %}}
+{{% card link="/motion-planning/reference/kinematics/" noimage="true" %}}
+{{< /cards >}}
diff --git a/docs/motion-planning/frame-system-how-to/mobile-base-sensors.md b/docs/motion-planning/frame-system-how-to/mobile-base-sensors.md
new file mode 100644
index 0000000000..14042340ef
--- /dev/null
+++ b/docs/motion-planning/frame-system-how-to/mobile-base-sensors.md
@@ -0,0 +1,177 @@
+---
+linkTitle: "Mobile Base with Sensors"
+title: "Mobile Base with Sensors"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "Configure frames for a mobile base with mounted cameras and LIDAR sensors."
+---
+
+This setup covers a mobile base with sensors mounted on it, such as LIDAR, front-facing cameras, and rear-facing cameras.
+These sensors are used for navigation, SLAM, and obstacle detection.
+All sensors are children of the base frame, so their positions update automatically as the base moves through the environment.
+
+## Frame hierarchy
+
+```text
+world
+└── my-base
+    ├── my-lidar (mounted on top)
+    ├── front-camera (front-facing)
+    └── rear-camera (rear-facing)
+```
+
+The base is a child of the world frame.
+All sensors are children of the base, so the entire sensor subtree moves with the base.
+
+## Steps
+
+### 1. Choose your world frame
+
+For a mobile base, the world frame origin is typically the center of the base itself.
+The frame system tracks the base's position as it moves, so the world frame serves as the fixed reference that the base moves through.
+
+You do not need to mark a physical location for the world frame origin in the environment.
+Instead, all sensor positions are defined relative to the center of the base.
+
+### 2. Add a frame to the base
+
+In the [Viam app](https://app.viam.com), navigate to your machine and click the **CONFIGURE** tab.
+Find your base component and click the **Frame** button.
+
+Since the world frame origin is at the base center, the translation is zero:
+
+```json
+{
+  "parent": "world",
+  "translation": { "x": 0, "y": 0, "z": 0 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  }
+}
+```
+
+Click **Save**.
+
+### 3. Add a frame to the LIDAR
+
+Find your LIDAR component and click the **Frame** button.
+Measure the offset from the center of the base to the LIDAR's sensor origin.
+
+For a LIDAR mounted on top of the base, centered horizontally and 150 mm above the base center:
+
+```json
+{
+  "parent": "my-base",
+  "translation": { "x": 0, "y": 0, "z": 150 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  }
+}
+```
+
+If the LIDAR is offset forward or to one side, include x and y values.
+For example, a LIDAR mounted 50 mm forward of center and 150 mm above:
+
+```json
+{
+  "parent": "my-base",
+  "translation": { "x": 0, "y": 50, "z": 150 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  }
+}
+```
+
+Click **Save**.
+
+### 4. Add frames to the cameras
+
+Find each camera component and click the **Frame** button.
+Measure the offset from the base center to each camera's mounting position.
+
+**Front-facing camera:**
+For a camera mounted at the front of the base, 200 mm forward and 120 mm above the base center:
+
+```json
+{
+  "parent": "my-base",
+  "translation": { "x": 0, "y": 200, "z": 120 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  }
+}
+```
+
+The default orientation has the camera looking along the +y axis (forward).
+If your camera's optical axis does not align with the base's forward direction, adjust the orientation accordingly.
+
+**Rear-facing camera:**
+For a camera mounted at the back of the base, 200 mm backward and 120 mm above the base center, facing backward:
+
+```json
+{
+  "parent": "my-base",
+  "translation": { "x": 0, "y": -200, "z": 120 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 180 }
+  }
+}
+```
+
+The 180-degree rotation around the z axis points the camera backward (along -y).
+
+Click **Save** after adding each camera frame.
+
+### 5. Visualize and verify
+
+1. Navigate to the **3D SCENE** tab in the Viam app.
+2. Verify that all sensor frames appear as children of the base.
+3. Check that sensor positions match their physical mounting locations relative to the base center.
+4. Confirm that camera orientations point in the correct directions (forward for the front camera, backward for the rear camera).
+
+If any frame appears in the wrong position or orientation, return to the **CONFIGURE** tab and adjust the values.
+
+### 6. Verify with TransformPose
+
+Use `TransformPose` to confirm the relationships between sensor frames and the base frame.
+For example, transform the front camera's origin `(0, 0, 0)` from the camera frame to the base frame.
+The result should match the camera's measured offset from the base center.
+
+For details on the TransformPose API, see [Frame system: TransformPose](/motion-planning/frame-system/#transformpose).
+
+## Troubleshooting
+
+{{< expand "LIDAR data does not align with camera data" >}}
+
+Check that both the LIDAR and camera frames have the correct translation offsets from the base.
+Even small errors in the offsets can cause the two data sources to disagree about object positions.
+Verify by placing an object at a known distance and checking that both sensors report consistent positions after frame transformation.
+
+{{< /expand >}}
+
+{{< expand "Front and rear camera frames overlap in the visualizer" >}}
+
+Make sure the y translations have opposite signs. The front camera should have a positive y offset and the rear camera a negative y offset (or vice versa, depending on your axis convention).
+Also verify that the rear camera has a 180-degree rotation to face backward.
+
+{{< /expand >}}
+
+{{< expand "Sensor frames are not updating as the base moves" >}}
+
+Confirm that each sensor's `parent` field is set to the base component name (for example, `"my-base"`), not `"world"`.
+Frames parented to the world stay fixed in space.
+
+{{< /expand >}}
+
+## What's Next
+
+{{< cards >}}
+{{% card link="/motion-planning/frame-system-how-to/mobile-base-arm/" noimage="true" %}}
+{{% card link="/motion-planning/obstacles/" noimage="true" %}}
+{{< /cards >}}
diff --git a/docs/motion-planning/frame-system.md b/docs/motion-planning/frame-system.md
new file mode 100644
index 0000000000..21cd80d109
--- /dev/null
+++ b/docs/motion-planning/frame-system.md
@@ -0,0 +1,211 @@
+---
+linkTitle: "Frame System"
+title: "Frame System"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Build a unified coordinate tree so all components agree on where things are in physical space."
+aliases:
+  - /work-cell-layout/define-your-frame-system/
+  - /build/work-cell-layout/define-your-frame-system/
+  - /operate/mobility/move-arm/frame-how-to/
+  - /reference/services/frame-system/
+  - /services/frame-system/
+  - /mobility/frame-system/
+  - /services/frame-system/frame-config/
+  - /mobility/frame-system/frame-config/
+  - /reference/services/frame-system/frame-config/
+---
+
+When your robot has multiple components such as: an arm, a camera, a gripper
+each component reports positions in its own local coordinate system. A camera sees an object at pixel (320, 240), but the arm needs to know the object's
+position in three-dimensional space relative to its own base. Without a unified spatial model, you cannot translate between these coordinate systems.
+
+The frame system solves this by storing the position and orientation of every
+component in a single, consistent coordinate tree. You define where each
+component sits relative to its parent, and Viam computes the transforms between
+any two frames automatically. Once the frame system is configured, you can ask
+questions like "where is this point in my camera frame, expressed in world
+coordinates?" with a single API call.
+
+Getting the frame system right is a prerequisite for motion planning, obstacle
+avoidance, and any task where multiple components need to agree on where things
+are in physical space.
+
+## Concepts
+
+### The world frame
+
+The world frame is the fixed root reference point for your entire frame system.
+You choose what physical location it corresponds to, for example: the corner of a table, the center of a work surface, or the base of an arm. You do not explicitly
+configure the world frame itself. Instead, you define it implicitly by
+configuring other frames relative to it.
+
+Pick a point that is easy to measure from and that will not move. For a
+table-mounted arm, the arm base or a table corner are good choices. For a mobile
+robot, the center of the base is typical.
+
+### Parent-child hierarchy
+
+Each component's frame has a parent frame. The parent defaults to the world
+frame if you do not specify one. When you attach a camera to an arm, you set the
+camera's frame parent to the arm. This means the camera's position is defined
+relative to the arm's end, and when the arm moves, the camera frame moves with
+it automatically.
+
+The hierarchy forms a tree rooted at the world frame:
+
+```text
+world
+├── my-arm
+│   ├── my-gripper (attached to arm)
+│   └── my-camera (mounted on arm)
+├── my-sensor (mounted on table)
+└── table-surface
+```
+
+### Parent to an intermediate arm link
+
+If you mount a component on an intermediate link of an arm rather than on the
+end effector, set the parent to `<arm-name>:<link-name>`. The link name is the
+`id` of a link in the arm's kinematic model. For example, if you have an arm
+named `my-arm` with a UR5e kinematic model and you strap a camera to the
+forearm, set the camera's parent to `my-arm:forearm_link`.
+
+```json
+{
+  "parent": "my-arm:forearm_link",
+  "translation": { "x": 0, "y": 0, "z": 30 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  }
+}
+```
+
+The motion service plans around components attached to intermediate links the
+same way it plans for components attached to the arm's end effector. To find
+the link names for an arm, inspect its kinematic model file or run
+`viam machines part motion print-config` and look for frames under the arm's name.
+
+### Translation
+
+Translation is the offset in millimeters from the parent frame's origin to the
+component's origin. It is specified as an (x, y, z) vector:
+
+- **x**: right/left offset
+- **y**: forward/backward offset
+- **z**: up/down offset
+
+The exact meaning of each axis depends on the parent frame's orientation. If the
+parent is the world frame with the standard orientation, +z points up.
+
+### Orientation
+
+Orientation describes how a component's axes are rotated relative to its parent
+frame. Viam supports several orientation formats:
+
+| Type           | Fields             | Description                                       |
+| -------------- | ------------------ | ------------------------------------------------- |
+| `ov_degrees`   | `x, y, z, th`      | Orientation vector (axis) with angle in degrees   |
+| `ov_radians`   | `x, y, z, th`      | Orientation vector (axis) with angle in radians   |
+| `euler_angles` | `roll, pitch, yaw` | Rotation around x, y, z axes (radians)            |
+| `axis_angles`  | `x, y, z, th`      | Rotation axis (unit vector) with angle in radians |
+| `quaternion`   | `w, x, y, z`       | Unit quaternion (auto-normalized)                 |
+
+The default orientation is `ov_degrees` with values `(0, 0, 1), 0`, which means
+the component's axes are aligned with its parent frame. The orientation vector
+(x, y, z) defines the axis of rotation, and `th` defines the rotation angle
+around that axis. The axis must be a non-zero vector (the code normalizes it
+internally).
+
+For a detailed reference on orientation vectors, see
+[Orientation Vectors](/motion-planning/reference/orientation-vectors/).
+
+### Geometry
+
+Each frame can optionally include collision geometry. This is a simple shape that
+approximates the component's physical footprint. The motion planner uses these
+shapes to avoid collisions. Supported types:
+
+- **box**: defined by x, y, z dimensions in mm
+- **sphere**: defined by a radius in mm
+- **capsule**: defined by a radius and length in mm
+
+Geometry is centered on the frame's origin by default. You can add a
+`translation` offset and `orientation` offset within the geometry config to shift
+it relative to the frame.
+
+For detailed information about obstacle geometry, see
+[Define Obstacles](/motion-planning/obstacles/).
+
+## TransformPose
+
+`TransformPose` is a method on the machine client that converts a pose from one reference frame to another.
+You provide a source pose with its reference frame, a destination frame name, and the frame system computes the transform using the configured hierarchy and current joint positions.
+
+For example, to find where a camera's origin is in the world frame:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.proto.common import PoseInFrame, Pose
+
+# Express the camera's origin (0,0,0) in its own frame
+camera_origin = PoseInFrame(
+    reference_frame="my-camera",
+    pose=Pose(x=0, y=0, z=0, o_x=0, o_y=0, o_z=1, theta=0)
+)
+
+# Transform to the world frame
+world_pose = await machine.transform_pose(camera_origin, "world")
+print(f"Camera in world: x={world_pose.pose.x}, y={world_pose.pose.y}, z={world_pose.pose.z}")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+baseOrigin := referenceframe.NewPoseInFrame("my-camera", spatialmath.NewZeroPose())
+worldPose, err := machine.TransformPose(context.Background(), baseOrigin, "world", nil)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+The optional `supplemental_transforms` parameter lets you include additional frame relationships that are not part of the stored configuration.
+This is useful for dynamic frames, such as an object detected by a camera whose position is known relative to the camera but not configured in the frame system.
+
+Common uses:
+
+- **Verify frame configuration**: transform a component's origin to the world frame and check that the result matches its physical position.
+- **Convert detections**: transform a point detected in a camera frame to world coordinates so an arm can reach it.
+- **Compare across frames**: when two components report positions in different frames, transform both to a common frame before comparing.
+
+## Verify with the CLI
+
+You can inspect your frame system from the command line without writing code:
+
+```sh
+# Print the frame system configuration
+viam machines part motion print-config --part "my-machine-main"
+
+# Print the current pose of every component relative to world
+viam machines part motion print-status --part "my-machine-main"
+```
+
+If a component's pose looks wrong, check the translation and orientation values
+in its frame configuration. For details on all CLI motion commands, see
+[Motion Service Configuration](/motion-planning/reference/motion-service/#cli-commands).
+
+## What's next
+
+Configure the frame system for your hardware setup:
+
+{{< cards >}}
+{{% card link="/motion-planning/frame-system-how-to/arm-gripper-camera/" noimage="true" %}}
+{{% card link="/motion-planning/frame-system-how-to/arm-fixed-camera/" noimage="true" %}}
+{{% card link="/motion-planning/frame-system-how-to/mobile-base-sensors/" noimage="true" %}}
+{{% card link="/motion-planning/frame-system-how-to/mobile-base-arm/" noimage="true" %}}
+{{< /cards >}}
diff --git a/docs/motion-planning/motion-how-to/_index.md b/docs/motion-planning/motion-how-to/_index.md
new file mode 100644
index 0000000000..f7c01966a2
--- /dev/null
+++ b/docs/motion-planning/motion-how-to/_index.md
@@ -0,0 +1,18 @@
+---
+linkTitle: "Motion How-Tos"
+title: "Motion Planning How-Tos"
+weight: 100
+layout: "docs"
+type: "docs"
+description: "Task-oriented guides for moving arms, gantries, and other kinematic chains."
+---
+
+{{< cards >}}
+{{% card link="/motion-planning/motion-how-to/move-arm-to-pose/" noimage="true" %}}
+{{% card link="/motion-planning/motion-how-to/move-arm-with-constraints/" noimage="true" %}}
+{{% card link="/motion-planning/motion-how-to/avoid-obstacles/" noimage="true" %}}
+{{% card link="/motion-planning/motion-how-to/move-gantry/" noimage="true" %}}
+{{% card link="/motion-planning/motion-how-to/pick-an-object/" noimage="true" %}}
+{{% card link="/motion-planning/motion-how-to/place-an-object/" noimage="true" %}}
+{{% card link="/motion-planning/motion-how-to/monitor-plan-execution/" noimage="true" %}}
+{{< /cards >}}
diff --git a/docs/motion-planning/motion-how-to/avoid-obstacles.md b/docs/motion-planning/motion-how-to/avoid-obstacles.md
new file mode 100644
index 0000000000..f3d9351999
--- /dev/null
+++ b/docs/motion-planning/motion-how-to/avoid-obstacles.md
@@ -0,0 +1,151 @@
+---
+linkTitle: "Avoid Obstacles"
+title: "Plan Collision-Free Paths"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "Configure obstacles and plan motion paths that avoid collisions."
+---
+
+Your arm needs to reach a target while avoiding the table it's mounted on,
+walls, equipment, or objects placed in the workspace. This guide shows how to
+set up a complete obstacle environment and verify collision avoidance.
+
+## Prerequisites
+
+- [Frame system](/motion-planning/frame-system/) configured
+- [Obstacles concept](/motion-planning/obstacles/) understood
+
+## Steps
+
+### 1. Define your workspace obstacles
+
+Build a `WorldState` that models the significant obstacles in your workspace.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.proto.common import (
+    Pose, Vector3, RectangularPrism, Capsule,
+    Geometry, GeometriesInFrame, WorldState
+)
+
+# Table
+table = Geometry(
+    center=Pose(x=0, y=0, z=-20),
+    box=RectangularPrism(dims_mm=Vector3(x=800, y=600, z=40)),
+    label="table"
+)
+
+# Back wall
+wall = Geometry(
+    center=Pose(x=0, y=400, z=500),
+    box=RectangularPrism(dims_mm=Vector3(x=1200, y=20, z=1000)),
+    label="back-wall"
+)
+
+# Support post
+post = Geometry(
+    center=Pose(x=300, y=0, z=200),
+    capsule=Capsule(radius_mm=25, length_mm=400),
+    label="support-post"
+)
+
+obstacles = GeometriesInFrame(
+    reference_frame="world",
+    geometries=[table, wall, post]
+)
+world_state = WorldState(obstacles=[obstacles])
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+obstacles := make([]spatialmath.Geometry, 0)
+
+table, _ := spatialmath.NewBox(
+    spatialmath.NewPose(r3.Vector{X: 0, Y: 0, Z: -20},
+        &spatialmath.OrientationVectorDegrees{OX: 0, OY: 0, OZ: 1, Theta: 0}),
+    r3.Vector{X: 800, Y: 600, Z: 40}, "table")
+obstacles = append(obstacles, table)
+
+wall, _ := spatialmath.NewBox(
+    spatialmath.NewPose(r3.Vector{X: 0, Y: 400, Z: 500},
+        &spatialmath.OrientationVectorDegrees{OX: 0, OY: 0, OZ: 1, Theta: 0}),
+    r3.Vector{X: 1200, Y: 20, Z: 1000}, "back-wall")
+obstacles = append(obstacles, wall)
+
+post, _ := spatialmath.NewCapsule(
+    spatialmath.NewPose(r3.Vector{X: 300, Y: 0, Z: 200},
+        &spatialmath.OrientationVectorDegrees{OX: 0, OY: 0, OZ: 1, Theta: 0}),
+    25, 400, "support-post")
+obstacles = append(obstacles, post)
+
+obstaclesInFrame := referenceframe.NewGeometriesInFrame(
+    referenceframe.World, obstacles)
+worldState, _ := referenceframe.NewWorldState(
+    []*referenceframe.GeometriesInFrame{obstaclesInFrame}, nil)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 2. Move with obstacle avoidance
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.services.motion import MotionClient
+from viam.proto.common import PoseInFrame, Pose
+
+motion_service = MotionClient.from_robot(machine, "builtin")
+
+destination = PoseInFrame(
+    reference_frame="world",
+    pose=Pose(x=300, y=200, z=400, o_x=0, o_y=0, o_z=-1, theta=0)
+)
+
+await motion_service.move(
+    component_name="my-arm",
+    destination=destination,
+    world_state=world_state
+)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+_, err = motionService.Move(ctx, motion.MoveReq{
+    ComponentName: "my-arm",
+    Destination:   destination,
+    WorldState:    worldState,
+})
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 3. Test collision avoidance
+
+Place a test obstacle directly between the arm and the target. The arm should
+take an indirect path around it.
+
+Then remove the obstacle and move again. The arm should take a more direct path.
+
+### 4. Add static geometry to frames
+
+For permanent obstacles, add geometry directly to component frames in the
+**CONFIGURE** tab instead of using WorldState. This way the planner always
+accounts for them without code changes.
+
+See [Define Obstacles](/motion-planning/obstacles/) for the full configuration
+reference.
+
+## What's Next
+
+- [Move an Arm to a Target Pose](/motion-planning/motion-how-to/move-arm-to-pose/)
+- [Pick an Object](/motion-planning/motion-how-to/pick-an-object/)
diff --git a/docs/motion-planning/motion-how-to/monitor-plan-execution.md b/docs/motion-planning/motion-how-to/monitor-plan-execution.md
new file mode 100644
index 0000000000..e5f4bccc92
--- /dev/null
+++ b/docs/motion-planning/motion-how-to/monitor-plan-execution.md
@@ -0,0 +1,173 @@
+---
+linkTitle: "Monitor Execution"
+title: "Monitor and Control Plan Execution"
+weight: 70
+layout: "docs"
+type: "docs"
+description: "Track plan status, retrieve plan details, and stop executing plans."
+---
+
+You need to monitor whether a motion plan is still executing, check if it
+succeeded or failed, or cancel it mid-execution.
+
+## Important limitation
+
+The builtin motion service does **not** support `GetPlan`, `ListPlanStatuses`,
+or `StopPlan`. These methods return "not supported" errors. They are only
+available from motion service implementations that support `MoveOnMap` or
+`MoveOnGlobe` (typically provided by modules or the navigation service).
+
+If you are using the builtin motion service with `Move()` for arms and gantries,
+the `Move()` call blocks until the motion completes or fails. You do not need
+to poll for status.
+
+## Methods (when supported)
+
+### GetPlan
+
+Retrieves the plan being executed or most recently executed for a component.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.services.motion import MotionClient
+
+motion_service = MotionClient.from_robot(machine, "my-motion-service")
+
+response = await motion_service.get_plan(
+    component_name="my-base",
+)
+plan_status = response.current_plan_with_status.status
+print(f"Plan state: {plan_status.state}")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+response, err := motionService.PlanHistory(ctx, motion.PlanHistoryReq{
+    ComponentName: "my-base",
+})
+if err != nil {
+    logger.Fatal(err)
+}
+fmt.Printf("Plan state: %v\n", response[0].StatusHistory[0].State)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### ListPlanStatuses
+
+Lists all active and recently completed plans.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+statuses = await motion_service.list_plan_statuses()
+for s in statuses:
+    print(f"Component: {s.component_name}, "
+          f"State: {s.status.state}")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+statuses, err := motionService.ListPlanStatuses(ctx, motion.ListPlanStatusesReq{})
+if err != nil {
+    logger.Fatal(err)
+}
+for _, s := range statuses {
+    fmt.Printf("Component: %s, State: %v\n", s.ComponentName, s.Status.State)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Plan states:
+
+| State         | Meaning                                |
+| ------------- | -------------------------------------- |
+| `IN_PROGRESS` | Plan is currently executing.           |
+| `STOPPED`     | Plan was stopped by a `StopPlan` call. |
+| `SUCCEEDED`   | Plan completed successfully.           |
+| `FAILED`      | Plan failed during execution.          |
+
+### StopPlan
+
+Cancels an executing plan for a component.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+await motion_service.stop_plan(
+    component_name="my-base",
+)
+print("Plan stopped")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+err = motionService.StopPlan(ctx, motion.StopPlanReq{
+    ComponentName: "my-base",
+})
+if err != nil {
+    logger.Fatal(err)
+}
+fmt.Println("Plan stopped")
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## For builtin Move() calls
+
+Since `Move()` blocks, handle errors directly:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+try:
+    await motion_service.move(
+        component_name="my-arm",
+        destination=destination,
+        world_state=world_state
+    )
+    print("Motion succeeded")
+except Exception as e:
+    print(f"Motion failed: {e}")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+_, err = motionService.Move(ctx, motion.MoveReq{
+    ComponentName: "my-arm",
+    Destination:   destination,
+    WorldState:    worldState,
+})
+if err != nil {
+    fmt.Printf("Motion failed: %v\n", err)
+} else {
+    fmt.Println("Motion succeeded")
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## What's Next
+
+- [Motion Service Configuration](/motion-planning/reference/motion-service/):
+  full configuration reference including DoCommand options.
+- [Motion Service API](/motion-planning/reference/api/):
+  complete API reference.
diff --git a/docs/motion-planning/motion-how-to/move-arm-to-pose.md b/docs/motion-planning/motion-how-to/move-arm-to-pose.md
new file mode 100644
index 0000000000..88709e18c2
--- /dev/null
+++ b/docs/motion-planning/motion-how-to/move-arm-to-pose.md
@@ -0,0 +1,277 @@
+---
+linkTitle: "Move Arm to Pose"
+title: "Move an Arm to a Target Pose"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Use the motion service to move a robot arm to a position in 3D space."
+aliases:
+  - /operate/mobility/move-arm/
+  - /operate/mobility/move-arm/arm-motion/
+  - /operate/mobility/move-arm/arm-no-code/
+  - /how-tos/move-robot-arm/
+  - /tutorials/motion/accessing-and-moving-robot-arm/
+  - /tutorials/motion/
+  - /tutorials/services/plan-motion-with-arm-gripper/
+---
+
+You have a robot arm and need to move it to a specific position and orientation
+in 3D space. The motion service computes a collision-free path from the arm's
+current pose to the target, taking into account the frame system, kinematics,
+and any defined obstacles.
+
+## Prerequisites
+
+- A running machine connected to Viam with an arm component configured
+- [Frame system](/motion-planning/frame-system/) configured for the arm
+- (Optional) [Obstacles](/motion-planning/obstacles/) defined for collision
+  avoidance
+
+## Steps
+
+### 1. Connect and get the motion service
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.robot.client import RobotClient
+from viam.services.motion import MotionClient
+from viam.proto.common import PoseInFrame, Pose
+
+machine = await RobotClient.at_address(
+    "<MACHINE-ADDRESS>",
+    RobotClient.Options.with_api_key(
+        api_key="<API-KEY>",
+        api_key_id="<API-KEY-ID>"
+    )
+)
+
+motion_service = MotionClient.from_robot(machine, "builtin")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+import (
+    "go.viam.com/rdk/services/motion"
+    "go.viam.com/rdk/referenceframe"
+    "go.viam.com/rdk/spatialmath"
+    "github.com/golang/geo/r3"
+)
+
+motionService, err := motion.FromRobot(machine, "builtin")
+if err != nil {
+    logger.Fatal(err)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 2. Define the target pose
+
+A pose specifies position (x, y, z in mm) and orientation. The `reference_frame`
+determines which coordinate system the pose is expressed in.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+# Move to a position 300mm right, 200mm forward, 400mm up
+# Orientation: end effector pointing straight down
+destination = PoseInFrame(
+    reference_frame="world",
+    pose=Pose(x=300, y=200, z=400, o_x=0, o_y=0, o_z=-1, theta=0)
+)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+// Move to a position 300mm right, 200mm forward, 400mm up
+// Orientation: end effector pointing straight down
+destination := referenceframe.NewPoseInFrame("world",
+    spatialmath.NewPose(
+        r3.Vector{X: 300, Y: 200, Z: 400},
+        &spatialmath.OrientationVectorDegrees{OX: 0, OY: 0, OZ: -1, Theta: 0},
+    ))
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 3. Move the arm
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+await motion_service.move(
+    component_name="my-arm",
+    destination=destination,
+)
+print("Arm moved to target pose")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+_, err = motionService.Move(ctx, motion.MoveReq{
+    ComponentName: "my-arm",
+    Destination:   destination,
+})
+if err != nil {
+    logger.Fatal(err)
+}
+fmt.Println("Arm moved to target pose")
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 4. Move with obstacle avoidance
+
+Pass a `WorldState` with obstacles to plan collision-free paths.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.proto.common import (
+    Vector3, RectangularPrism, Geometry,
+    GeometriesInFrame, WorldState
+)
+
+# Define a table obstacle
+table = Geometry(
+    center=Pose(x=0, y=0, z=-20),
+    box=RectangularPrism(dims_mm=Vector3(x=800, y=600, z=40)),
+    label="table"
+)
+
+obstacles = GeometriesInFrame(
+    reference_frame="world",
+    geometries=[table]
+)
+world_state = WorldState(obstacles=[obstacles])
+
+await motion_service.move(
+    component_name="my-arm",
+    destination=destination,
+    world_state=world_state
+)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+tableOrigin := spatialmath.NewPose(
+    r3.Vector{X: 0, Y: 0, Z: -20},
+    &spatialmath.OrientationVectorDegrees{OX: 0, OY: 0, OZ: 1, Theta: 0},
+)
+table, _ := spatialmath.NewBox(tableOrigin,
+    r3.Vector{X: 800, Y: 600, Z: 40}, "table")
+
+obstaclesInFrame := referenceframe.NewGeometriesInFrame(
+    referenceframe.World, []spatialmath.Geometry{table})
+worldState, _ := referenceframe.NewWorldState(
+    []*referenceframe.GeometriesInFrame{obstaclesInFrame}, nil)
+
+_, err = motionService.Move(ctx, motion.MoveReq{
+    ComponentName: "my-arm",
+    Destination:   destination,
+    WorldState:    worldState,
+})
+if err != nil {
+    logger.Fatal(err)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 5. Verify the result
+
+Read the arm's current pose after moving to confirm it reached the target:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.components.arm import Arm
+
+arm = Arm.from_robot(machine, "my-arm")
+current_pose = await arm.get_end_position()
+print(f"Current position: x={current_pose.x:.1f}, "
+      f"y={current_pose.y:.1f}, z={current_pose.z:.1f}")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+import "go.viam.com/rdk/components/arm"
+
+myArm, err := arm.FromRobot(machine, "my-arm")
+if err != nil {
+    logger.Fatal(err)
+}
+currentPose, err := myArm.EndPosition(ctx, nil)
+if err != nil {
+    logger.Fatal(err)
+}
+pt := currentPose.Point()
+fmt.Printf("Current position: x=%.1f, y=%.1f, z=%.1f\n",
+    pt.X, pt.Y, pt.Z)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Test from the command line
+
+You can move the arm and check poses without writing code:
+
+```sh
+# Check the arm's current pose
+viam machines part motion get-pose --part "my-machine-main" --component "my-arm"
+
+# Move the arm to a new position (only specified values change)
+viam machines part motion set-pose --part "my-machine-main" --component "my-arm" \
+  --x 300 --y 200 --z 400
+```
+
+## Troubleshooting
+
+{{< expand "Move fails with 'no path found'" >}}
+
+- Check that the target pose is reachable (within the arm's workspace).
+- If using obstacles, verify they don't block all possible paths.
+- Check joint limits in the kinematics model.
+- Try a simpler target pose (closer to current position) to isolate the issue.
+
+{{< /expand >}}
+
+{{< expand "Arm moves to wrong position" >}}
+
+- Verify the `reference_frame` in your destination. A pose in `"world"` frame
+  and the same pose in `"my-arm"` frame are different positions.
+- Check the frame system configuration. Incorrect translations or orientations
+  shift the target.
+- Read the arm's position before and after to see what actually changed.
+
+{{< /expand >}}
+
+## What's Next
+
+- [Move with Constraints](/motion-planning/motion-how-to/move-arm-with-constraints/):
+  keep the end effector on a straight line or at a fixed orientation.
+- [Avoid Obstacles](/motion-planning/motion-how-to/avoid-obstacles/):
+  detailed obstacle configuration for complex workspaces.
+- [Pick an Object](/motion-planning/motion-how-to/pick-an-object/):
+  combine motion planning with vision and gripper control.
diff --git a/docs/motion-planning/motion-how-to/move-arm-with-constraints.md b/docs/motion-planning/motion-how-to/move-arm-with-constraints.md
new file mode 100644
index 0000000000..e33bc0b5ec
--- /dev/null
+++ b/docs/motion-planning/motion-how-to/move-arm-with-constraints.md
@@ -0,0 +1,213 @@
+---
+linkTitle: "Move with Constraints"
+title: "Move an Arm with Motion Constraints"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "Move an arm along a straight line or with a fixed orientation using motion constraints."
+aliases:
+  - /tutorials/services/constrain-motion/
+---
+
+You need the arm to move in a controlled way, such as following a straight line for
+welding, keeping the end effector level to carry a cup of water, or both. Without
+constraints, the planner finds any collision-free path, which may curve or tilt
+the end effector unpredictably.
+
+## Prerequisites
+
+- A running machine with an arm and [frame system](/motion-planning/frame-system/) configured
+- Familiarity with [Move Arm to Pose](/motion-planning/motion-how-to/move-arm-to-pose/)
+
+## Steps
+
+### 1. Move in a straight line
+
+Use a `LinearConstraint` to keep the end effector within a tolerance of the
+direct line between start and goal.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.services.motion import MotionClient
+from viam.proto.service.motion import Constraints, LinearConstraint
+from viam.proto.common import PoseInFrame, Pose
+
+motion_service = MotionClient.from_robot(machine, "builtin")
+
+constraints = Constraints(
+    linear_constraint=[
+        LinearConstraint(line_tolerance_mm=5.0)
+    ]
+)
+
+destination = PoseInFrame(
+    reference_frame="world",
+    pose=Pose(x=400, y=200, z=300, o_x=0, o_y=0, o_z=-1, theta=0)
+)
+
+await motion_service.move(
+    component_name="my-arm",
+    destination=destination,
+    constraints=constraints
+)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+import motionpb "go.viam.com/api/service/motion/v1"
+
+lineTolerance := float32(5.0)
+constraints := &motionpb.Constraints{
+    LinearConstraint: []*motionpb.LinearConstraint{
+        {LineToleranceMm: &lineTolerance},
+    },
+}
+
+_, err = motionService.Move(ctx, motion.MoveReq{
+    ComponentName: "my-arm",
+    Destination:   destination,
+    Constraints:   constraints,
+})
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 2. Maintain end effector orientation
+
+Use an `OrientationConstraint` to keep the end effector level (or at any
+fixed orientation) throughout the motion.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.proto.service.motion import OrientationConstraint
+
+constraints = Constraints(
+    orientation_constraint=[
+        OrientationConstraint(orientation_tolerance_degs=5.0)
+    ]
+)
+
+await motion_service.move(
+    component_name="my-arm",
+    destination=destination,
+    constraints=constraints
+)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+orientTolerance := float32(5.0)
+constraints := &motionpb.Constraints{
+    OrientationConstraint: []*motionpb.OrientationConstraint{
+        {OrientationToleranceDegs: &orientTolerance},
+    },
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 3. Combine constraints
+
+You can apply both linear and orientation constraints simultaneously.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+# Straight line, level orientation
+constraints = Constraints(
+    linear_constraint=[
+        LinearConstraint(line_tolerance_mm=5.0)
+    ],
+    orientation_constraint=[
+        OrientationConstraint(orientation_tolerance_degs=3.0)
+    ]
+)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+lineTol := float32(5.0)
+orientTol := float32(3.0)
+constraints := &motionpb.Constraints{
+    LinearConstraint: []*motionpb.LinearConstraint{
+        {LineToleranceMm: &lineTol},
+    },
+    OrientationConstraint: []*motionpb.OrientationConstraint{
+        {OrientationToleranceDegs: &orientTol},
+    },
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 4. Use proportional tolerances
+
+`PseudolinearConstraint` scales the tolerance with the motion distance. Useful
+when the same code handles both short and long moves.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.proto.service.motion import PseudolinearConstraint
+
+constraints = Constraints(
+    pseudolinear_constraint=[
+        PseudolinearConstraint(
+            line_tolerance_factor=0.1,
+            orientation_tolerance_factor=0.1
+        )
+    ]
+)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+lineFactor := float32(0.1)
+orientFactor := float32(0.1)
+constraints := &motionpb.Constraints{
+    PseudolinearConstraint: []*motionpb.PseudolinearConstraint{
+        {
+            LineToleranceFactor:        &lineFactor,
+            OrientationToleranceFactor: &orientFactor,
+        },
+    },
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Tips
+
+- **Start with larger tolerances** (10-20 mm, 10-15 degrees) and tighten
+  only as needed. Tight constraints increase planning time and failure rate.
+- **Constraints combine with obstacles.** If obstacles block the straight-line
+  path, the planner may fail because it cannot satisfy both the linear
+  constraint and the obstacle avoidance requirement.
+- **Orientation constraints check against both start and goal.** The planner
+  ensures the current orientation stays within tolerance of whichever endpoint
+  is closer.
+
+## What's Next
+
+- [Configure Motion Constraints](/motion-planning/constraints/):
+  full reference for all four constraint types.
+- [Plan Collision-Free Paths](/motion-planning/motion-how-to/avoid-obstacles/):
+  combine constraints with obstacle avoidance.
diff --git a/docs/motion-planning/motion-how-to/move-gantry.md b/docs/motion-planning/motion-how-to/move-gantry.md
new file mode 100644
index 0000000000..375d5cfafe
--- /dev/null
+++ b/docs/motion-planning/motion-how-to/move-gantry.md
@@ -0,0 +1,120 @@
+---
+linkTitle: "Move a Gantry"
+title: "Move a Gantry"
+weight: 40
+layout: "docs"
+type: "docs"
+description: "Control gantry axes directly or plan complex gantry motion."
+aliases:
+  - /operate/mobility/move-gantry/
+---
+
+You have a gantry (a Cartesian robot with linear axes) and need to move it to
+specific positions. You can either control axes directly with the gantry API
+or use the motion service for planned, collision-aware movement.
+
+## Direct axis control
+
+Use the gantry component API for simple, direct movements.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.components.gantry import Gantry
+
+gantry = Gantry.from_robot(machine, "my-gantry")
+
+# Read current position (mm for each axis)
+positions = await gantry.get_position()
+print(f"Current positions: {positions}")
+
+# Read axis lengths
+lengths = await gantry.get_lengths()
+print(f"Axis lengths: {lengths}")
+
+# Move to a specific position
+await gantry.move_to_position(positions=[200, 300, 100])
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+import "go.viam.com/rdk/components/gantry"
+
+myGantry, err := gantry.FromRobot(machine, "my-gantry")
+if err != nil {
+    logger.Fatal(err)
+}
+
+positions, err := myGantry.Position(ctx, nil)
+if err != nil {
+    logger.Fatal(err)
+}
+fmt.Printf("Current positions: %v\n", positions)
+
+lengths, err := myGantry.Lengths(ctx, nil)
+if err != nil {
+    logger.Fatal(err)
+}
+fmt.Printf("Axis lengths: %v\n", lengths)
+
+err = myGantry.MoveToPosition(ctx, []float64{200, 300, 100}, nil)
+if err != nil {
+    logger.Fatal(err)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Motion-planned movement
+
+For complex paths or collision avoidance, use the motion service.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.services.motion import MotionClient
+from viam.proto.common import PoseInFrame, Pose
+
+motion_service = MotionClient.from_robot(machine, "builtin")
+
+destination = PoseInFrame(
+    reference_frame="world",
+    pose=Pose(x=200, y=300, z=100, o_x=0, o_y=0, o_z=1, theta=0)
+)
+
+await motion_service.move(
+    component_name="my-gantry",
+    destination=destination,
+)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+destination := referenceframe.NewPoseInFrame("world",
+    spatialmath.NewPose(
+        r3.Vector{X: 200, Y: 300, Z: 100},
+        &spatialmath.OrientationVectorDegrees{OX: 0, OY: 0, OZ: 1, Theta: 0},
+    ))
+
+_, err = motionService.Move(ctx, motion.MoveReq{
+    ComponentName: "my-gantry",
+    Destination:   destination,
+})
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## What's Next
+
+- [Move Arm to Pose](/motion-planning/motion-how-to/move-arm-to-pose/):
+  similar workflow for robot arms.
+- [Define Obstacles](/motion-planning/obstacles/):
+  add obstacle geometry for collision avoidance.
diff --git a/docs/motion-planning/motion-how-to/pick-an-object.md b/docs/motion-planning/motion-how-to/pick-an-object.md
new file mode 100644
index 0000000000..000ef5115d
--- /dev/null
+++ b/docs/motion-planning/motion-how-to/pick-an-object.md
@@ -0,0 +1,188 @@
+---
+linkTitle: "Pick an Object"
+title: "Pick an Object"
+weight: 50
+layout: "docs"
+type: "docs"
+description: "Detect, localize, and grasp an object with a robot arm and gripper."
+---
+
+You need to pick up an object from a workspace. This requires detecting the
+object with a camera, determining its 3D position, planning a collision-free
+approach path, and controlling the gripper to grasp it.
+
+## Prerequisites
+
+- Arm with [frame system](/motion-planning/frame-system/) and
+  [kinematics](/motion-planning/reference/kinematics/) configured
+- Gripper configured as a component
+- Camera [calibrated](/motion-planning/camera-calibration/) and registered
+  in the frame system
+- Vision service configured for object detection
+- [Obstacles](/motion-planning/obstacles/) defined (at minimum, the table)
+
+## Steps
+
+### 1. Detect and localize the object
+
+Use a vision service to detect the object in 2D, then transform its position
+to the world frame.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.services.vision import VisionClient
+from viam.proto.common import PoseInFrame, Pose
+
+vision = VisionClient.from_robot(machine, "my-detector")
+
+# Get detections from the camera
+detections = await vision.get_detections_from_camera("my-camera")
+if not detections:
+    print("No objects detected")
+    exit()
+
+target = detections[0]
+print(f"Detected: {target.class_name} ({target.confidence:.2f})")
+
+# For 3D localization, use GetObjectPointClouds
+objects = await vision.get_object_point_clouds("my-camera")
+if objects:
+    obj = objects[0]
+    # The center of the first geometry is the object's position
+    # in the camera's reference frame
+    center = obj.geometries.geometries[0].center
+    obj_in_camera = PoseInFrame(
+        reference_frame="my-camera",
+        pose=Pose(x=center.x, y=center.y, z=center.z)
+    )
+    # Transform to world frame
+    obj_in_world = await machine.transform_pose(obj_in_camera, "world")
+    print(f"Object position in world: "
+          f"x={obj_in_world.pose.x:.1f}, "
+          f"y={obj_in_world.pose.y:.1f}, "
+          f"z={obj_in_world.pose.z:.1f}")
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 2. Plan approach and pre-grasp pose
+
+Move the arm to a position above the object (pre-grasp pose) before descending
+to grasp.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.services.motion import MotionClient
+motion_service = MotionClient.from_robot(machine, "builtin")
+
+# Pre-grasp: 100mm above the object, end effector pointing down
+pre_grasp = PoseInFrame(
+    reference_frame="world",
+    pose=Pose(
+        x=obj_in_world.pose.x,
+        y=obj_in_world.pose.y,
+        z=obj_in_world.pose.z + 100,
+        o_x=0, o_y=0, o_z=-1, theta=0
+    )
+)
+
+await motion_service.move(
+    component_name="my-arm",
+    destination=pre_grasp,
+    world_state=world_state
+)
+print("At pre-grasp position")
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 3. Open gripper and descend
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.components.gripper import Gripper
+
+gripper = Gripper.from_robot(machine, "my-gripper")
+
+# Open gripper
+await gripper.open()
+
+# Descend to grasp position
+grasp_pose = PoseInFrame(
+    reference_frame="world",
+    pose=Pose(
+        x=obj_in_world.pose.x,
+        y=obj_in_world.pose.y,
+        z=obj_in_world.pose.z,
+        o_x=0, o_y=0, o_z=-1, theta=0
+    )
+)
+
+await motion_service.move(
+    component_name="my-arm",
+    destination=grasp_pose,
+    world_state=world_state
+)
+print("At grasp position")
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 4. Grasp and lift
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+# Close gripper to grasp
+grabbed = await gripper.grab()
+if grabbed:
+    print("Object grasped")
+else:
+    print("Grasp failed")
+
+# Lift the object
+lift_pose = PoseInFrame(
+    reference_frame="world",
+    pose=Pose(
+        x=obj_in_world.pose.x,
+        y=obj_in_world.pose.y,
+        z=obj_in_world.pose.z + 200,
+        o_x=0, o_y=0, o_z=-1, theta=0
+    )
+)
+
+await motion_service.move(
+    component_name="my-arm",
+    destination=lift_pose,
+    world_state=world_state
+)
+print("Object lifted")
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Tips
+
+- Use `CollisionSpecification` constraints to allow the gripper to contact the
+  target object during the grasp phase.
+- Add a small offset to the grasp height to account for measurement uncertainty.
+- After grasping, re-verify with the gripper's `is_moving` or force feedback
+  before proceeding.
+
+## What's Next
+
+- [Place an Object](/motion-planning/motion-how-to/place-an-object/):
+  move the grasped object to a target location.
+- [Configure Motion Constraints](/motion-planning/constraints/):
+  use CollisionSpecification to allow gripper-object contact.
diff --git a/docs/motion-planning/motion-how-to/place-an-object.md b/docs/motion-planning/motion-how-to/place-an-object.md
new file mode 100644
index 0000000000..bc8c4cb6b7
--- /dev/null
+++ b/docs/motion-planning/motion-how-to/place-an-object.md
@@ -0,0 +1,116 @@
+---
+linkTitle: "Place an Object"
+title: "Place an Object"
+weight: 60
+layout: "docs"
+type: "docs"
+description: "Move a grasped object to a target location and release it."
+---
+
+You have an object in the gripper and need to place it at a specific location.
+This involves planning a collision-free path to the placement pose, descending
+to the surface, releasing, and retreating.
+
+## Prerequisites
+
+- Object already grasped (see [Pick an Object](/motion-planning/motion-how-to/pick-an-object/))
+- Placement location known in world coordinates
+
+## Steps
+
+### 1. Move to pre-place position
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+# Pre-place: above the target location
+pre_place = PoseInFrame(
+    reference_frame="world",
+    pose=Pose(
+        x=500, y=0, z=200,
+        o_x=0, o_y=0, o_z=-1, theta=0
+    )
+)
+
+await motion_service.move(
+    component_name="my-arm",
+    destination=pre_place,
+    world_state=world_state
+)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 2. Descend to placement surface
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+# Place: at the surface.
+# Set z to the height of the placement surface in your workspace.
+# For example, if you detected the target location, use its z coordinate.
+SURFACE_HEIGHT = 50  # mm — adjust for your setup
+place_pose = PoseInFrame(
+    reference_frame="world",
+    pose=Pose(
+        x=500, y=0, z=SURFACE_HEIGHT,
+        o_x=0, o_y=0, o_z=-1, theta=0
+    )
+)
+
+await motion_service.move(
+    component_name="my-arm",
+    destination=place_pose,
+    world_state=world_state
+)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 3. Release and retreat
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+# Open gripper to release
+await gripper.open()
+print("Object placed")
+
+# Retreat: lift straight up
+retreat_pose = PoseInFrame(
+    reference_frame="world",
+    pose=Pose(
+        x=500, y=0, z=200,
+        o_x=0, o_y=0, o_z=-1, theta=0
+    )
+)
+
+await motion_service.move(
+    component_name="my-arm",
+    destination=retreat_pose,
+    world_state=world_state
+)
+print("Retreated from placement")
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Tips
+
+- Use `OrientationConstraint` during descent to keep the object level.
+- The retreat path should go straight up to avoid disturbing the placed object.
+- After releasing, the object becomes a potential obstacle. Update your
+  `WorldState` if the arm needs to move near the placement location again.
+
+## What's Next
+
+- [Pick an Object](/motion-planning/motion-how-to/pick-an-object/):
+  the pick half of the pick-and-place workflow.
+- [Monitor Plan Execution](/motion-planning/motion-how-to/monitor-plan-execution/):
+  track plan status during execution.
diff --git a/docs/motion-planning/obstacles.md b/docs/motion-planning/obstacles.md
new file mode 100644
index 0000000000..ca3e311851
--- /dev/null
+++ b/docs/motion-planning/obstacles.md
@@ -0,0 +1,365 @@
+---
+linkTitle: "Obstacles"
+title: "Define Obstacles"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "Define collision geometry so the motion planner computes safe, collision-free paths."
+aliases:
+  - /work-cell-layout/define-obstacles/
+  - /build/work-cell-layout/define-obstacles/
+  - /operate/mobility/define-obstacles/
+  - /operate/mobility/define-dynamic-obstacles/
+  - /operate/mobility/define-geometry/
+  - /operate/mobility/move-arm/configure-additional/
+  - /services/frame-system/nested-frame-config/
+  - /mobility/frame-system/nested-frame-config/
+  - /reference/services/frame-system/nested-frame-config/
+---
+
+A robot arm that does not know about its surroundings will plan the shortest path
+to a target position, even if that path goes through a table, a wall, or another
+piece of equipment. Without obstacle definitions, the motion planner has no way
+to know that certain regions of space are occupied by physical objects.
+
+By defining obstacles (tables, walls, posts, equipment, and other fixtures in
+your workspace) you give the motion planner the information it needs to plan
+collision-free paths. The planner routes the arm around obstacles, and if no
+collision-free path exists, it returns an error rather than commanding a
+dangerous motion.
+
+## Concepts
+
+### Geometry types
+
+Viam supports five geometry types for defining obstacles. The three primitives
+are the most commonly used:
+
+| Type        | JSON `type` | Config fields                          | Best for                                      |
+| ----------- | ----------- | -------------------------------------- | --------------------------------------------- |
+| **Box**     | `"box"`     | `x`, `y`, `z` (dimensions in mm)       | Tables, walls, shelves, rectangular equipment |
+| **Sphere**  | `"sphere"`  | `r` (radius in mm)                     | Balls, rounded objects, keep-out zones        |
+| **Capsule** | `"capsule"` | `r` (radius in mm), `l` (length in mm) | Posts, pipes, cylindrical objects             |
+| **Point**   | `"point"`   | (none, position only)                  | Single points in space                        |
+| **Mesh**    | `"mesh"`    | `mesh_data`, `mesh_content_type`       | Complex shapes from STL/PLY files             |
+
+Each geometry has a center point (pose) that defines where it sits in space. The
+pose is relative to a reference frame, typically the world frame. Geometry
+configs also support `translation` and `orientation` offsets to shift the shape
+relative to the frame origin.
+
+You do not need to model every surface detail of an obstacle. Approximate shapes
+that fully enclose the real object are safer and work better with the motion
+planner.
+
+Capsule validation: the length must be at least twice the radius. If length
+equals exactly twice the radius, Viam creates a sphere instead.
+
+### Static vs dynamic obstacles
+
+**Static obstacles** are permanent fixtures in your workspace. You configure
+them by adding geometry to a component's frame configuration in the Viam app.
+They are always present and do not require code changes. Examples: the table
+the arm is mounted on, walls, permanent fixtures.
+
+**Dynamic obstacles** are objects that you define at runtime and pass to the
+motion service through WorldState. They can change between calls. Examples: a box
+that was just placed on the table, a temporary keep-out zone, objects detected
+by a vision system.
+
+Both types use the same geometry primitives.
+
+### WorldState
+
+WorldState is the container that holds obstacle and transform information passed
+to the motion service at call time. It contains:
+
+- **obstacles**: a list of `GeometriesInFrame`, where each entry specifies a
+  reference frame and one or more geometries in that frame
+- **transforms**: supplemental frame transforms that augment the frame system
+  for this call only
+
+You construct a WorldState in your code and pass it to the `Move` call.
+
+### Keep-out zones
+
+A keep-out zone is a region of space where the robot should never enter. Define
+it the same way as any other obstacle, as a box, sphere, or capsule positioned
+in the workspace. The motion planner treats it identically to a physical
+obstacle.
+
+### Collision buffer
+
+The builtin motion service uses a collision buffer (default: 150 mm) that adds
+clearance around obstacles during planning. The planner avoids paths that come
+within this buffer distance of any obstacle geometry.
+
+## Steps
+
+### 1. Add geometry to a component frame
+
+For permanent fixtures, add geometry directly to a component's frame
+configuration.
+
+**Example: a table under the arm.**
+
+1. Go to [app.viam.com](https://app.viam.com) and navigate to your machine.
+2. Click the **CONFIGURE** tab.
+3. Add a new component to represent the table obstacle (or add the geometry to
+   an existing component's frame).
+4. Configure the frame with a geometry:
+
+```json
+{
+  "parent": "world",
+  "translation": { "x": 0, "y": 0, "z": -20 },
+  "orientation": {
+    "type": "ov_degrees",
+    "value": { "x": 0, "y": 0, "z": 1, "th": 0 }
+  },
+  "geometry": {
+    "type": "box",
+    "x": 800,
+    "y": 600,
+    "z": 40
+  }
+}
+```
+
+This defines a table as a box 800 mm wide, 600 mm deep, and 40 mm thick. The
+center of the box is at z = -20 mm (20 mm below the world frame origin), so
+the top surface of the 40 mm thick table aligns with z = 0.
+
+Click **Save**. The table geometry is now part of the frame system and the
+motion planner will avoid it automatically.
+
+### 2. Define obstacles programmatically with WorldState
+
+For obstacles that change at runtime, build a WorldState in your code.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.proto.common import (
+    Pose, Vector3, RectangularPrism, Capsule, Sphere,
+    Geometry, GeometriesInFrame, WorldState
+)
+
+# Define a table as a box
+table_origin = Pose(x=-202.5, y=-546.5, z=-19.0)
+table_dims = Vector3(x=635.0, y=1271.0, z=38.0)
+table_obstacle = Geometry(
+    center=table_origin,
+    box=RectangularPrism(dims_mm=table_dims),
+    label="table"
+)
+
+# Define a post as a capsule
+post_origin = Pose(x=200, y=0, z=150)
+post_obstacle = Geometry(
+    center=post_origin,
+    capsule=Capsule(radius_mm=25, length_mm=300),
+    label="post"
+)
+
+# Define a ball as a sphere
+ball_origin = Pose(x=100, y=100, z=50)
+ball_obstacle = Geometry(
+    center=ball_origin,
+    sphere=Sphere(radius_mm=40),
+    label="ball"
+)
+
+# Combine into WorldState
+obstacles_in_frame = GeometriesInFrame(
+    reference_frame="world",
+    geometries=[table_obstacle, post_obstacle, ball_obstacle]
+)
+world_state = WorldState(obstacles=[obstacles_in_frame])
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+import (
+    "github.com/golang/geo/r3"
+    "go.viam.com/rdk/referenceframe"
+    "go.viam.com/rdk/spatialmath"
+)
+
+obstacles := make([]spatialmath.Geometry, 0)
+
+// Define a table as a box
+tableOrigin := spatialmath.NewPose(
+    r3.Vector{X: -202.5, Y: -546.5, Z: -19.0},
+    &spatialmath.OrientationVectorDegrees{OX: 0, OY: 0, OZ: 1, Theta: 0},
+)
+tableDims := r3.Vector{X: 635.0, Y: 1271.0, Z: 38.0}
+tableObj, err := spatialmath.NewBox(tableOrigin, tableDims, "table")
+if err != nil {
+    logger.Fatal(err)
+}
+obstacles = append(obstacles, tableObj)
+
+// Define a post as a capsule
+postOrigin := spatialmath.NewPose(
+    r3.Vector{X: 200, Y: 0, Z: 150},
+    &spatialmath.OrientationVectorDegrees{OX: 0, OY: 0, OZ: 1, Theta: 0},
+)
+postObj, err := spatialmath.NewCapsule(postOrigin, 25, 300, "post")
+if err != nil {
+    logger.Fatal(err)
+}
+obstacles = append(obstacles, postObj)
+
+// Define a ball as a sphere
+ballOrigin := spatialmath.NewPose(
+    r3.Vector{X: 100, Y: 100, Z: 50},
+    &spatialmath.OrientationVectorDegrees{OX: 0, OY: 0, OZ: 1, Theta: 0},
+)
+ballObj, err := spatialmath.NewSphere(ballOrigin, 40, "ball")
+if err != nil {
+    logger.Fatal(err)
+}
+obstacles = append(obstacles, ballObj)
+
+// Combine into WorldState
+obstaclesInFrame := referenceframe.NewGeometriesInFrame(
+    referenceframe.World, obstacles)
+worldState, err := referenceframe.NewWorldState(
+    []*referenceframe.GeometriesInFrame{obstaclesInFrame}, nil)
+if err != nil {
+    logger.Fatal(err)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 3. Use WorldState with the motion service
+
+Pass the WorldState to the motion service's `Move` method.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.services.motion import MotionClient
+from viam.proto.common import PoseInFrame, Pose
+
+motion_service = MotionClient.from_robot(machine, "builtin")
+
+destination = PoseInFrame(
+    reference_frame="world",
+    pose=Pose(x=300, y=200, z=400, o_x=0, o_y=0, o_z=-1, theta=0)
+)
+
+# Move with obstacle avoidance
+await motion_service.move(
+    component_name="my-arm",
+    destination=destination,
+    world_state=world_state
+)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+import (
+    "go.viam.com/rdk/services/motion"
+)
+
+motionService, err := motion.FromRobot(machine, "builtin")
+if err != nil {
+    logger.Fatal(err)
+}
+
+destination := referenceframe.NewPoseInFrame("world",
+    spatialmath.NewPose(
+        r3.Vector{X: 300, Y: 200, Z: 400},
+        &spatialmath.OrientationVectorDegrees{OX: 0, OY: 0, OZ: -1, Theta: 0},
+    ))
+
+moveReq := motion.MoveReq{
+    ComponentName: "my-arm",
+    Destination:   destination,
+    WorldState:    worldState,
+}
+_, err = motionService.Move(ctx, moveReq)
+if err != nil {
+    logger.Fatal(err)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+If the motion planner cannot find a collision-free path, it returns an error.
+This typically means the obstacles are too restrictive, the destination is inside
+an obstacle, or the arm physically cannot reach the destination without
+colliding.
+
+### 4. Visualize obstacles
+
+Check the Viam app to see your obstacle geometry:
+
+1. Navigate to your machine in the Viam app.
+2. Click the **3D SCENE** tab.
+3. Obstacles defined in component frame configurations appear as translucent
+   shapes in the 3D view.
+
+Dynamic obstacles (defined through WorldState in code) do not appear in the
+3D SCENE tab because they only exist during the `Move` call.
+
+## Try It
+
+1. Add a table geometry to a component frame in the CONFIGURE tab (step 1).
+   Open the 3D SCENE tab and verify the table appears.
+2. Write code to define a dynamic obstacle using WorldState (step 2) and pass
+   it to a `Move` call (step 3).
+3. Place a test obstacle between the arm and a target position. Verify the arm
+   takes an indirect path to avoid it.
+4. Remove the test obstacle and move again. Verify the arm takes a more direct
+   path.
+
+## Troubleshooting
+
+{{< expand "Motion planner cannot find a path" >}}
+
+- The obstacles may be too large or too close together, leaving no valid path.
+  Reduce obstacle dimensions slightly.
+- The destination may be inside or very close to an obstacle.
+- The collision buffer (default 150 mm) adds clearance. Obstacles that appear
+  far enough apart visually may be too close once the buffer is applied.
+
+{{< /expand >}}
+
+{{< expand "Obstacles appear in the wrong position" >}}
+
+- Verify the reference frame. Positions are relative to the specified frame's
+  origin.
+- Check units. Positions are in millimeters, not centimeters or meters.
+- Use the 3D SCENE tab to see where obstacles appear.
+
+{{< /expand >}}
+
+{{< expand "Arm clips through obstacles" >}}
+
+- The obstacle geometry may be too small. Add a 20-50 mm safety margin.
+- The arm's own collision geometry may be missing. Check the arm's kinematics
+  file for link geometry definitions.
+- Make thin obstacles (walls, panels) at least 20 mm thick.
+
+{{< /expand >}}
+
+## What's Next
+
+- [Move an Arm to a Target Pose](/motion-planning/motion-how-to/move-arm-to-pose/):
+  use the motion service to move the arm while avoiding obstacles.
+- [Configure Motion Constraints](/motion-planning/constraints/): restrict how
+  the arm moves between poses.
+- [Motion Planning Algorithms](/motion-planning/reference/algorithms/): understand how
+  the planner computes collision-free paths.
diff --git a/docs/motion-planning/reference/_index.md b/docs/motion-planning/reference/_index.md
new file mode 100644
index 0000000000..676fd445fb
--- /dev/null
+++ b/docs/motion-planning/reference/_index.md
@@ -0,0 +1,16 @@
+---
+linkTitle: "Reference"
+title: "Motion Planning Reference"
+weight: 200
+layout: "docs"
+type: "docs"
+description: "Configuration, API, and technical reference for the motion service."
+---
+
+{{< cards >}}
+{{% card link="/motion-planning/reference/motion-service/" noimage="true" %}}
+{{% card link="/motion-planning/reference/api/" noimage="true" %}}
+{{% card link="/motion-planning/reference/kinematics/" noimage="true" %}}
+{{% card link="/motion-planning/reference/algorithms/" noimage="true" %}}
+{{% card link="/motion-planning/reference/orientation-vectors/" noimage="true" %}}
+{{< /cards >}}
diff --git a/docs/motion-planning/reference/algorithms.md b/docs/motion-planning/reference/algorithms.md
new file mode 100644
index 0000000000..50077cb4f7
--- /dev/null
+++ b/docs/motion-planning/reference/algorithms.md
@@ -0,0 +1,113 @@
+---
+linkTitle: "Algorithms"
+title: "Motion Planning Algorithms"
+weight: 50
+layout: "docs"
+type: "docs"
+description: "How Viam's motion planner computes collision-free paths for robot arms."
+aliases:
+  - /reference/services/motion/algorithms/
+  - /services/motion/algorithms/
+  - /mobility/motion/algorithms/
+---
+
+## When you need this
+
+This page is useful when:
+
+- You need to tune planning performance (timeout, resolution).
+- You are debugging why the planner fails to find a path.
+- You are building your own motion service.
+- You want to understand what the planner is doing under the hood.
+
+## The cBiRRT algorithm
+
+Viam's motion service uses **cBiRRT** (Constrained Bidirectional
+Rapidly-Exploring Random Tree), based on Berenson et al. 2009. This is the
+only planning algorithm in the builtin motion service. There is no
+configuration option to select a different algorithm.
+
+### How it works
+
+cBiRRT grows two search trees simultaneously: one from the start configuration
+and one from the goal configuration. At each iteration, the algorithm:
+
+1. **Samples** a random configuration in joint space.
+2. **Extends** the nearest node in one tree toward the sample, checking
+   constraints and collisions at each step.
+3. **Attempts to connect** the two trees. If a connection is found, the path
+   is complete.
+4. **Projects** each new configuration onto the constraint manifold, ensuring
+   constraints are satisfied throughout the path.
+
+The bidirectional approach is significantly faster than growing a single tree,
+because both trees converge toward the middle simultaneously.
+
+### Why it works well for robot arms
+
+- **High-dimensional spaces**: A 6-axis arm has 6 degrees of freedom. cBiRRT
+  handles this efficiently through random sampling.
+- **Constraint satisfaction**: The projection step ensures constraints (linear,
+  orientation) are satisfied, not just checked.
+- **Bidirectional search**: Finding a path in 6D space from both ends is much
+  faster than searching from one end only.
+
+### What it does not do
+
+- **No optimal paths**: cBiRRT finds _a_ valid path, not the shortest or
+  smoothest path. The builtin service applies path smoothing (default 30
+  iterations) after planning to improve the result.
+- **No dynamic replanning**: The planner computes a full path before execution
+  begins. It does not adjust the path during execution.
+
+## Tuning parameters
+
+The planner accepts configuration through the motion service config and through
+per-request options.
+
+### Service-level config
+
+These are set in the motion service configuration:
+
+| Field                        | Type   | Default          | Description                             |
+| ---------------------------- | ------ | ---------------- | --------------------------------------- |
+| `num_threads`                | int    | (system default) | Number of threads for parallel planning |
+| `log_file_path`              | string | (none)           | Path to write planning logs             |
+| `log_planner_errors`         | bool   | false            | Log planning errors                     |
+| `log_slow_plan_threshold_ms` | int    | (none)           | Log plans that take longer than this    |
+
+### Planning defaults
+
+These defaults are compiled into the builtin motion service:
+
+| Parameter            | Default     | Description                                              |
+| -------------------- | ----------- | -------------------------------------------------------- |
+| Timeout              | 300 seconds | Maximum time to search for a path                        |
+| Resolution           | 2.0         | Constraint-checking granularity (mm or degrees per step) |
+| Max IK solutions     | 100         | Maximum inverse kinematics solutions to seed the search  |
+| Smoothing iterations | 30          | Post-planning path smoothing passes                      |
+| Collision buffer     | 150 mm      | Clearance around obstacles                               |
+
+### When planning fails
+
+If the planner returns an error ("no path found" or similar), consider:
+
+1. **Loosen constraints.** Tight linear or orientation tolerances can make the
+   constrained space too small to navigate.
+2. **Reduce obstacle sizes.** Oversized obstacles leave no room for the arm
+   to pass.
+3. **Check joint limits.** If the kinematics file has joint limits tighter than
+   the physical arm, the planner may not explore valid configurations.
+4. **Check the destination.** The destination pose must be reachable and not
+   inside an obstacle.
+5. **Increase timeout.** For complex environments, the default 300-second
+   timeout may not be enough, though this is rare.
+
+## What's Next
+
+- [Configure Motion Constraints](/motion-planning/constraints/): the
+  constraint types that cBiRRT enforces during planning.
+- [Define Obstacles](/motion-planning/obstacles/): collision geometry that
+  the planner routes around.
+- [Motion Service Configuration](/motion-planning/reference/motion-service/):
+  full configuration reference.
diff --git a/docs/motion-planning/reference/api.md b/docs/motion-planning/reference/api.md
new file mode 100644
index 0000000000..a114f605b2
--- /dev/null
+++ b/docs/motion-planning/reference/api.md
@@ -0,0 +1,75 @@
+---
+linkTitle: "API"
+title: "Motion Service API"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "The motion service API for planning and executing component movements."
+aliases:
+  - /reference/apis/services/motion/
+  - /appendix/apis/services/motion/
+---
+
+The motion service API supports the following methods:
+
+{{< readfile "/static/include/services/apis/generated/motion-table.md" >}}
+
+For full method signatures, parameters, and code examples, see the
+[auto-generated motion API reference](/reference/apis/services/motion/).
+
+## Method overview
+
+### Move
+
+Plans and executes a motion for a component to a destination pose. This is the
+primary method for arm and gantry motion planning.
+
+**Supported by:** builtin motion service.
+
+Key parameters:
+
+- `component_name`: the arm or gantry to move
+- `destination`: a `PoseInFrame` specifying the target pose and reference frame
+- `world_state`: optional obstacles and transforms
+- `constraints`: optional linear, orientation, or collision constraints
+
+### MoveOnMap
+
+Plans and executes motion on a SLAM map.
+
+**Not supported by** the builtin motion service. Requires a module
+implementation.
+
+### MoveOnGlobe
+
+Plans and executes motion to a GPS coordinate.
+
+**Not supported by** the builtin motion service. Use the
+[navigation service](/navigation/) for GPS-based navigation.
+
+### GetPlan
+
+Retrieves the plan for an executing motion.
+
+**Not supported by** the builtin motion service.
+
+### ListPlanStatuses
+
+Lists all active and recently completed plan statuses.
+
+**Not supported by** the builtin motion service.
+
+### StopPlan
+
+Stops an executing plan.
+
+**Not supported by** the builtin motion service.
+
+### GetPose (deprecated)
+
+Gets the pose of a component. Use `robot.GetPose()` instead.
+
+### DoCommand
+
+Sends arbitrary commands. The builtin motion service supports `"plan"`,
+`"execute"`, and `"executeCheckStart"` commands.
diff --git a/docs/motion-planning/reference/kinematics.md b/docs/motion-planning/reference/kinematics.md
new file mode 100644
index 0000000000..eafb4ad486
--- /dev/null
+++ b/docs/motion-planning/reference/kinematics.md
@@ -0,0 +1,310 @@
+---
+linkTitle: "Arm Kinematics"
+title: "Arm Kinematics"
+weight: 25
+layout: "docs"
+type: "docs"
+description: "Set up the kinematic model that describes how your arm's joints and links create motion."
+aliases:
+  - /work-cell-layout/configure-robot-kinematics/
+  - /build/work-cell-layout/configure-robot-kinematics/
+---
+
+When you command a robot arm to move its end effector to a position in 3D space,
+something needs to figure out what angle each joint should be set to in order to
+reach that position. This is the inverse kinematics problem, and solving it
+requires a mathematical model of the arm's physical structure: how long each
+link is, how each joint rotates, and what the limits of each joint are.
+
+{{< alert title="Most arms handle this automatically" color="tip" >}}
+
+Most arm modules in the Viam registry include a kinematics file that describes
+this structure. For standard commercial arms like the UR5e, xArm6, or Viam Arm,
+the module handles kinematics automatically. You do not need to provide or
+configure a kinematics file for these arms.
+
+This page is relevant if you are building a custom arm, using a module without a
+built-in kinematics file, or need to verify that a kinematics model matches your
+physical arm.
+
+{{< /alert >}}
+
+## Concepts
+
+### Forward and inverse kinematics
+
+**Forward kinematics** answers the question: given the current angle of every
+joint, where is the end effector? This is a straightforward calculation. You
+start at the base, apply each joint angle and link length in sequence, and
+arrive at the end effector's position and orientation in space. Every time you
+call `GetEndPosition`, the arm uses forward kinematics.
+
+**Inverse kinematics** answers the reverse question: given a target position and
+orientation for the end effector, what joint angles will get the arm there? This
+is harder because there may be zero, one, or many solutions. The arm might be
+able to reach the same point with the elbow up or elbow down, or it might not
+be able to reach the point at all. Viam's motion planner uses inverse kinematics
+internally when you call `Move`.
+
+### Links and joints
+
+A robot arm is modeled as a chain of rigid bodies (links) connected by joints:
+
+- **Links** are the rigid structural segments. Each link has a length and
+  optionally a geometry (for collision checking). Links do not move on their
+  own. They are moved by the joints that connect them.
+- **Joints** connect two links and define how they can move relative to each
+  other. Viam supports four joint types:
+  - **Revolute**: rotates around an axis (like an elbow or shoulder). Limits in
+    degrees.
+  - **Prismatic**: slides along an axis (like a linear actuator). Limits in
+    millimeters.
+  - **Continuous**: like revolute, but with no joint limits (full rotation).
+  - **Fixed**: no degrees of freedom (used in URDF files for rigid attachments).
+
+### Joint limits
+
+Every joint has limits that define its range of motion:
+
+- **Min/max angle** (revolute joints): the minimum and maximum rotation in
+  degrees. For example, a shoulder joint might allow -180 to 180 degrees.
+- **Min/max position** (prismatic joints): the minimum and maximum extension in
+  millimeters.
+
+Joint limits prevent the motion planner from computing solutions that would
+require the arm to bend past its physical limits.
+
+### Kinematics file formats
+
+Viam supports three formats for describing arm kinematics:
+
+| Format                           | Description                                             | When to use                                 |
+| -------------------------------- | ------------------------------------------------------- | ------------------------------------------- |
+| **SVA** (Spatial Vector Algebra) | Viam's native JSON format                               | Preferred for new arms, most detailed       |
+| **DH** (Denavit-Hartenberg)      | Standard robotics convention, four parameters per joint | When converting from textbook DH parameters |
+| **URDF**                         | XML format used by ROS and many manufacturers           | When the manufacturer provides a URDF file  |
+
+Most registry arm modules use SVA internally. You rarely need to write a
+kinematics file from scratch unless you are building a custom arm.
+
+### Tool center point (TCP)
+
+The tool center point is the reference point on the end effector. By default,
+it is at the last link's origin. If you attach a gripper or tool, you may need
+to define an offset so the TCP reflects the actual point of interaction (for
+example, the tip of a gripper or the center of a suction cup). This offset is
+configured through the [frame system](/motion-planning/frame-system/), not the
+kinematics file.
+
+## Steps
+
+### 1. Check if your arm has a built-in kinematics file
+
+Most arm modules in the Viam registry ship with a kinematics file built into
+the module. The module loads and applies the kinematics automatically when
+`viam-server` starts.
+
+Verify this by calling `GetKinematics`:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.components.arm import Arm
+
+arm = Arm.from_robot(machine, "my-arm")
+kinematics = await arm.get_kinematics()
+print(f"Kinematics format: {kinematics[0]}")
+# kinematics[1] contains the raw kinematics data
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+myArm, err := arm.FromRobot(machine, "my-arm")
+if err != nil {
+    logger.Fatal(err)
+}
+
+kinematicsType, kinematicsData, err := myArm.Kinematics(ctx, nil)
+if err != nil {
+    logger.Fatal(err)
+}
+fmt.Printf("Kinematics format: %v\n", kinematicsType)
+fmt.Printf("Kinematics data length: %d bytes\n", len(kinematicsData))
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+If this call succeeds and returns data, your arm module has kinematics built in.
+Proceed to step 4 to read joint and end effector data.
+
+If the call fails or returns empty data, the module does not include kinematics.
+You will need to provide a kinematics file (steps 2-3).
+
+### 2. Understand the SVA kinematics format
+
+The SVA format describes the arm as a sequence of links and joints in JSON. Here
+is a simplified example for a two-joint arm:
+
+```json
+{
+  "name": "MyArm",
+  "kinematic_param_type": "SVA",
+  "links": [
+    {
+      "id": "base_link",
+      "parent": "world",
+      "translation": { "x": 0, "y": 0, "z": 162.5 },
+      "geometry": {
+        "x": 120,
+        "y": 120,
+        "z": 260,
+        "translation": { "x": 0, "y": 0, "z": 130 }
+      }
+    },
+    {
+      "id": "upper_arm_link",
+      "parent": "shoulder_pan_joint",
+      "translation": { "x": 0, "y": 0, "z": 245.0 }
+    }
+  ],
+  "joints": [
+    {
+      "id": "shoulder_pan_joint",
+      "type": "revolute",
+      "parent": "base_link",
+      "axis": { "x": 0, "y": 0, "z": 1 },
+      "min": -360,
+      "max": 360
+    },
+    {
+      "id": "shoulder_lift_joint",
+      "type": "revolute",
+      "parent": "upper_arm_link",
+      "axis": { "x": 0, "y": 1, "z": 0 },
+      "min": -360,
+      "max": 360
+    }
+  ]
+}
+```
+
+Each field:
+
+- **`links[].id`**: unique name for the link
+- **`links[].parent`**: the joint or frame this link attaches to
+- **`links[].translation`**: offset in mm from the parent's origin
+- **`links[].geometry`**: optional collision shape (uses `type`, `x`/`y`/`z` for box, `r` for sphere/capsule, `l` for capsule length)
+- **`joints[].id`**: unique name for the joint
+- **`joints[].type`**: `"revolute"` (rotates) or `"prismatic"` (slides)
+- **`joints[].parent`**: the link this joint attaches to
+- **`joints[].axis`**: the axis of rotation or translation (unit vector)
+- **`joints[].min`** / **`joints[].max`**: joint limits in degrees (revolute)
+  or mm (prismatic)
+
+### 3. Import a URDF file
+
+If your arm manufacturer provides a URDF file, you can reference it in your arm
+module's configuration. URDF (Unified Robot Description Format) is an XML format
+that describes links, joints, visual meshes, and collision geometry.
+
+A typical URDF structure:
+
+```xml
+<robot name="my_arm">
+  <link name="base_link">
+    <visual>
+      <geometry><cylinder length="0.1" radius="0.05"/></geometry>
+    </visual>
+    <collision>
+      <geometry><cylinder length="0.1" radius="0.05"/></geometry>
+    </collision>
+  </link>
+  <joint name="shoulder_pan" type="revolute">
+    <parent link="base_link"/>
+    <child link="upper_arm"/>
+    <axis xyz="0 0 1"/>
+    <limit lower="-3.14" upper="3.14" velocity="1.0"/>
+  </joint>
+</robot>
+```
+
+To use a URDF file with your arm module, place the file in a location accessible
+to `viam-server` and reference it in the module's configuration. The exact
+configuration depends on the module. Consult the module's documentation for the
+specific attribute name.
+
+### 4. Verify kinematics in the 3D SCENE tab
+
+The Viam app can render a 3D visualization of your arm based on its kinematic
+model:
+
+1. Navigate to your machine in the Viam app.
+2. Click the **3D SCENE** tab.
+3. The arm should appear as a 3D model with joints and links.
+
+Verify the visualization by comparing it to the physical arm:
+
+1. Move a joint using the **CONTROL** tab.
+2. Switch to the **3D SCENE** tab and confirm the visualization updated.
+3. Check that the joint rotated in the correct direction and by the correct
+   amount.
+4. Repeat for each joint.
+
+If the visualization does not match the physical arm, the kinematics file may
+have incorrect link lengths, joint axes, or joint limits.
+
+## Try It
+
+1. Run the kinematics check from step 1 to confirm your arm module has a
+   built-in kinematics file.
+2. Open the 3D SCENE tab and compare the rendered arm to the physical arm. Move
+   individual joints using the CONTROL tab and verify the visualization matches.
+3. For reading joint positions and controlling the arm, see
+   [Add an Arm](/hardware/common-components/add-an-arm/) and the
+   [Arm API reference](/reference/apis/components/arm/).
+
+## Troubleshooting
+
+{{< expand "GetKinematics returns an error or empty data" >}}
+
+- The arm module may not include a built-in kinematics file. Check the module's
+  documentation or registry page for information about kinematics support.
+- Verify the arm component is configured correctly and `viam-server` has no
+  errors for this component.
+- Ensure you are using the correct component name in your code.
+
+{{< /expand >}}
+
+{{< expand "Joint limits are too restrictive" >}}
+
+- The motion planner may fail to find paths because joint limits prevent it from
+  exploring valid configurations. Check the kinematics file and widen limits if
+  the physical arm allows greater range of motion.
+- If the arm is a commercial model, use the manufacturer's documented joint
+  limits. Do not exceed these values.
+
+{{< /expand >}}
+
+{{< expand "3D SCENE tab does not match the physical arm" >}}
+
+- The kinematics file may have incorrect link lengths. Measure the physical arm
+  segments and compare to the values in the kinematics file.
+- Joint axes may be swapped or inverted. Move one joint at a time in the CONTROL
+  tab and verify the correct joint moves in the visualizer.
+- If the arm model appears offset from the frame axes, check the arm's frame
+  configuration in the CONFIGURE tab.
+
+{{< /expand >}}
+
+## What's Next
+
+- [Define Obstacles](/motion-planning/obstacles/): add collision geometry to
+  your workspace so the motion planner avoids collisions.
+- [Move an Arm to a Target Pose](/motion-planning/motion-how-to/move-arm-to-pose/):
+  use the motion service to move the arm to a position in 3D space.
+- [Camera Calibration](/motion-planning/camera-calibration/): calibrate your
+  camera for accurate 3D position estimation.
diff --git a/docs/motion-planning/reference/motion-service.md b/docs/motion-planning/reference/motion-service.md
new file mode 100644
index 0000000000..9a40ff7d9f
--- /dev/null
+++ b/docs/motion-planning/reference/motion-service.md
@@ -0,0 +1,180 @@
+---
+linkTitle: "Motion Service"
+title: "Motion Service Configuration"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Configure the motion service for planning and executing component movements."
+aliases:
+  - /reference/services/motion/
+  - /services/motion/
+  - /mobility/motion/
+---
+
+The motion service enables your machine to plan and move its components relative
+to itself, other machines, and the world. The builtin motion service is enabled
+by default on every machine running `viam-server`. You do not need to add it
+to your configuration.
+
+## Builtin service limitations
+
+The builtin motion service supports the `Move()` method for arms and gantries.
+The following methods return "not supported" errors from the builtin
+implementation and require a module or the navigation service:
+
+- `MoveOnMap()`: requires a SLAM service (not recommended)
+- `MoveOnGlobe()`: use the [navigation service](/navigation/) instead
+- `GetPlan()`, `ListPlanStatuses()`, `StopPlan()`: only available with
+  implementations that support `MoveOnMap` or `MoveOnGlobe`
+
+## Access the motion service
+
+Use the resource name `"builtin"` to get the default motion service client:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.services.motion import MotionClient
+
+motion_service = MotionClient.from_robot(machine, "builtin")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+import "go.viam.com/rdk/services/motion"
+
+motionService, err := motion.FromRobot(machine, "builtin")
+if err != nil {
+    logger.Fatal(err)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Configuration attributes
+
+The builtin motion service accepts the following optional configuration
+attributes:
+
+| Attribute                         | Type   | Default          | Description                                                                                     |
+| --------------------------------- | ------ | ---------------- | ----------------------------------------------------------------------------------------------- |
+| `log_file_path`                   | string | (none)           | Path to write planning debug logs.                                                              |
+| `num_threads`                     | int    | (system default) | Number of threads for parallel planning.                                                        |
+| `plan_file_path`                  | string | (none)           | Path to write plan output files.                                                                |
+| `plan_directory_include_trace_id` | bool   | false            | Include trace ID in plan output directory names.                                                |
+| `log_planner_errors`              | bool   | false            | Log planning errors to the log file.                                                            |
+| `log_slow_plan_threshold_ms`      | int    | (none)           | Log plans that take longer than this threshold in milliseconds.                                 |
+| `input_range_override`            | object | (none)           | Override joint input ranges. Map of component name to map of joint name to `{min, max}` limits. |
+
+Example configuration:
+
+```json
+{
+  "name": "builtin",
+  "api": "rdk:service:motion",
+  "model": "rdk:builtin:builtin",
+  "attributes": {
+    "log_planner_errors": true,
+    "log_slow_plan_threshold_ms": 5000
+  }
+}
+```
+
+## MotionConfiguration (per-request)
+
+When calling `MoveOnGlobe` or `MoveOnMap` (through a supporting implementation),
+you can pass a `MotionConfiguration` to override per-request settings:
+
+| Field                           | Type  | Default                | Description                                                   |
+| ------------------------------- | ----- | ---------------------- | ------------------------------------------------------------- |
+| `obstacle_detectors`            | list  | (none)                 | Vision service + camera pairs for dynamic obstacle detection. |
+| `position_polling_frequency_hz` | float | (unset)                | How often to poll the machine's position, in Hz.              |
+| `obstacle_polling_frequency_hz` | float | (unset)                | How often to poll vision services for obstacles, in Hz.       |
+| `plan_deviation_m`              | float | 2.6 (globe), 1.0 (map) | Maximum allowed deviation from the plan, in meters.           |
+| `linear_m_per_sec`              | float | 0.3                    | Linear velocity, in meters per second.                        |
+| `angular_degs_per_sec`          | float | 60.0                   | Angular velocity, in degrees per second.                      |
+
+## Planning defaults
+
+The builtin motion service uses the following compiled defaults:
+
+| Parameter                  | Value           | Description                                               |
+| -------------------------- | --------------- | --------------------------------------------------------- |
+| Planning timeout           | 300 seconds     | Maximum time to search for a path.                        |
+| Resolution                 | 2.0             | Constraint-checking granularity (mm or degrees per step). |
+| Max IK solutions           | 100             | Maximum inverse kinematics solutions to seed the search.  |
+| Smoothing iterations       | 30              | Post-planning path smoothing passes.                      |
+| Collision buffer           | 150 mm          | Clearance added around obstacles during planning.         |
+| MoveOnMap plan deviation   | 1000 mm (1.0 m) | Default for `MoveOnMap` calls.                            |
+| MoveOnGlobe plan deviation | 2600 mm (2.6 m) | Default for `MoveOnGlobe` calls.                          |
+
+## DoCommand
+
+The builtin motion service supports the following commands through `DoCommand`:
+
+| Command               | Description                                                               |
+| --------------------- | ------------------------------------------------------------------------- |
+| `"plan"`              | Generate a motion plan without executing it.                              |
+| `"execute"`           | Execute a previously generated plan.                                      |
+| `"executeCheckStart"` | Execute a plan after verifying the arm is at the expected start position. |
+
+## CLI commands
+
+The Viam CLI provides commands for inspecting and testing the motion service
+from the command line. These are useful for debugging frame configurations and
+testing motion without writing code.
+
+All commands require the `--part` flag to identify the machine part.
+
+### print-config
+
+Prints the frame system configuration for the specified machine part.
+
+```sh
+viam machines part motion print-config --part "my-machine-main"
+```
+
+### print-status
+
+Prints the current pose of every component relative to the world frame.
+
+```sh
+viam machines part motion print-status --part "my-machine-main"
+```
+
+Output shows X, Y, Z position (mm) and orientation (OX, OY, OZ, Theta in
+degrees) for each frame.
+
+### get-pose
+
+Gets the current pose of a specific component in the world frame.
+
+```sh
+viam machines part motion get-pose --part "my-machine-main" --component "my-arm"
+```
+
+### set-pose
+
+Moves a component to a specified pose using the motion service. Only the
+position and orientation values you provide are changed; the rest are kept from
+the component's current pose.
+
+```sh
+viam machines part motion set-pose --part "my-machine-main" --component "my-arm" \
+  --x 300 --y 200 --z 400
+```
+
+Available flags: `--x`, `--y`, `--z` (position in mm), `--ox`, `--oy`, `--oz`,
+`--theta` (orientation vector in degrees).
+
+## What's next
+
+- [Motion Service API](/motion-planning/reference/api/): full API reference.
+- [Motion Planning Algorithms](/motion-planning/reference/algorithms/): how the planner
+  works.
+- [Configure Motion Constraints](/motion-planning/constraints/): restrict arm
+  movement during planning.
diff --git a/docs/motion-planning/reference/orientation-vectors.md b/docs/motion-planning/reference/orientation-vectors.md
new file mode 100644
index 0000000000..d854b2203e
--- /dev/null
+++ b/docs/motion-planning/reference/orientation-vectors.md
@@ -0,0 +1,130 @@
+---
+linkTitle: "Orientation Vectors"
+title: "Orientation Vector Reference"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "Reference for specifying component orientation using orientation vectors and other rotation formats."
+aliases:
+  - /operate/mobility/orientation-vector/
+  - /internals/orientation-vector/
+  - /appendix/orientation-vector/
+  - /operate/reference/orientation-vector/
+---
+
+Orientation vectors describe the rotation of a component's coordinate frame
+relative to its parent frame. They are used in frame system configuration,
+motion planning destinations, and pose specifications.
+
+## Supported orientation formats
+
+Viam supports five orientation formats, specified with the `type` field in
+orientation configuration:
+
+### `ov_degrees` (default)
+
+Orientation vector with angle in degrees. Most commonly used.
+
+```json
+{
+  "type": "ov_degrees",
+  "value": { "x": 0, "y": 0, "z": 1, "th": 90 }
+}
+```
+
+- `x`, `y`, `z`: components of the rotation axis vector (must be non-zero;
+  normalized internally)
+- `th`: rotation angle in degrees
+
+Default (identity): `{"x": 0, "y": 0, "z": 1, "th": 0}`. This represents no rotation.
+
+### `ov_radians`
+
+Same as `ov_degrees` but with angle in radians.
+
+```json
+{
+  "type": "ov_radians",
+  "value": { "x": 0, "y": 0, "z": 1, "th": 1.5708 }
+}
+```
+
+### `euler_angles`
+
+Rotation around the x, y, and z axes. Values are in **radians**.
+
+```json
+{
+  "type": "euler_angles",
+  "value": { "roll": 0, "pitch": 0, "yaw": 1.5708 }
+}
+```
+
+- `roll`: rotation around x axis (radians)
+- `pitch`: rotation around y axis (radians)
+- `yaw`: rotation around z axis (radians)
+
+Default: `{"roll": 0, "pitch": 0, "yaw": 0}`.
+
+### `axis_angles`
+
+Rotation axis with angle in **radians**. Similar to `ov_radians` but uses the
+R4AA (Rotation 4 Axis Angle) representation.
+
+```json
+{
+  "type": "axis_angles",
+  "value": { "x": 0, "y": 0, "z": 1, "th": 1.5708 }
+}
+```
+
+- `x`, `y`, `z`: components of the rotation axis (normalized to unit sphere)
+- `th`: rotation angle in radians
+
+Default: `{"x": 0, "y": 0, "z": 1, "th": 0}`.
+
+The axis must have a non-zero norm. A zero-norm axis causes a runtime error.
+
+### `quaternion`
+
+Unit quaternion. Values are auto-normalized.
+
+```json
+{
+  "type": "quaternion",
+  "value": { "w": 0.707, "x": 0, "y": 0, "z": 0.707 }
+}
+```
+
+- `w`: scalar (real) component
+- `x`, `y`, `z`: vector (imaginary) components
+
+## Common orientations
+
+| Description                         | `ov_degrees` value                    |
+| ----------------------------------- | ------------------------------------- |
+| No rotation (identity)              | `{"x": 0, "y": 0, "z": 1, "th": 0}`   |
+| 90 degrees around z                 | `{"x": 0, "y": 0, "z": 1, "th": 90}`  |
+| 180 degrees around z (flip x and y) | `{"x": 0, "y": 0, "z": 1, "th": 180}` |
+| 90 degrees around x                 | `{"x": 1, "y": 0, "z": 0, "th": 90}`  |
+| Pointing straight down (-z)         | `{"x": 0, "y": 0, "z": -1, "th": 0}`  |
+| 30 degree tilt around y             | `{"x": 0, "y": 1, "z": 0, "th": 30}`  |
+
+## Gimbal lock
+
+When using `euler_angles`, certain pitch values (near +/- 90 degrees or pi/2
+radians) cause gimbal lock, where roll and yaw become ambiguous. If you need
+orientations near these values, use `ov_degrees`, `axis_angles`, or `quaternion`
+instead. These formats do not suffer from gimbal lock.
+
+## Validation
+
+For `ov_degrees` and `ov_radians`, the orientation vector `(x, y, z)` must have
+a non-zero magnitude. If all three components are zero, the code returns an
+error: _"has a normal of 0, probably X, Y, and Z are all 0"_.
+
+For `axis_angles`, a zero-norm axis causes a panic during normalization. Always
+provide a non-zero axis vector.
+
+For `quaternion`, values are auto-normalized, so any non-zero quaternion is
+valid.
diff --git a/docs/navigation/_index.md b/docs/navigation/_index.md
new file mode 100644
index 0000000000..6eae398e4c
--- /dev/null
+++ b/docs/navigation/_index.md
@@ -0,0 +1,70 @@
+---
+linkTitle: "Navigation"
+title: "Navigation"
+weight: 170
+layout: "docs"
+type: "docs"
+no_list: true
+noedit: true
+open_on_desktop: true
+overview: true
+description: "Autonomous GPS-based navigation for mobile robot bases."
+notoc: true
+---
+
+The navigation service gives a mobile robot the ability to navigate
+autonomously to GPS coordinates while avoiding obstacles. You define
+waypoints on a map, and the robot drives itself between them.
+
+This is GPS-based outdoor navigation. You need a mobile base, a GPS-capable
+movement sensor, and optionally cameras with vision services for obstacle
+detection. The navigation service handles path planning, replanning when
+the robot deviates, and obstacle avoidance. Your code sets waypoints and
+monitors progress.
+
+## What you can do
+
+- **Navigate to GPS coordinates.** Send the robot to a specific latitude
+  and longitude. The navigation service plans a path and drives the base
+  there, replanning if the robot deviates or encounters obstacles.
+- **Follow patrol routes.** Define a sequence of waypoints and the robot
+  navigates to each one in order.
+- **Avoid obstacles.** Configure vision services and cameras as obstacle
+  detectors. The navigation service feeds detected obstacles into the
+  path planner automatically. You can also define static obstacles and
+  geofences (bounding regions) in the configuration.
+- **Switch between manual and autonomous control.** Set the navigation
+  mode to Manual to drive the base directly, or Waypoint to start
+  autonomous navigation. Switching to Manual stops the current plan but
+  preserves your waypoints.
+
+## What you need
+
+- A configured [base](/hardware/common-components/add-a-base/) (the robot's
+  drive system).
+- A configured [movement sensor](/hardware/common-components/add-a-movement-sensor/)
+  that provides GPS position and compass heading.
+- Optionally, one or more [camera](/hardware/common-components/add-a-camera/)
+  and [vision service](/vision/configure/) pairs for obstacle detection.
+
+## How it works
+
+The navigation service operates in one of two modes:
+
+- **Manual mode.** The service is passive. You control the base directly
+  through base API calls or the Control tab. The service still reports
+  the robot's location through GetLocation.
+- **Waypoint mode.** The service takes control of the base. It picks the
+  next unvisited waypoint, calls the motion service's MoveOnGlobe to plan
+  and execute a path, monitors progress, and moves to the next waypoint
+  when it arrives. If navigation fails (obstacle, deviation, error), the
+  service retries the same waypoint automatically.
+
+The service uses the motion service internally for path planning and
+execution. You don't call the motion service directly when using
+navigation.
+
+{{< cards >}}
+{{% card link="/navigation/how-to/" %}}
+{{% card link="/navigation/reference/" %}}
+{{< /cards >}}
diff --git a/docs/navigation/how-to/_index.md b/docs/navigation/how-to/_index.md
new file mode 100644
index 0000000000..3196f9670f
--- /dev/null
+++ b/docs/navigation/how-to/_index.md
@@ -0,0 +1,35 @@
+---
+linkTitle: "How-to guides"
+title: "Navigation how-to guides"
+weight: 100
+layout: "docs"
+type: "docs"
+no_list: true
+description: "Task-oriented guides for GPS-based autonomous navigation."
+---
+
+These guides walk you through setting up and using GPS-based navigation
+on a mobile robot. Start with GPS setup, then configure the navigation
+service and send your robot to its first waypoint.
+
+## Setup
+
+| Guide                                                              | What you'll do                                                                       |
+| ------------------------------------------------------------------ | ------------------------------------------------------------------------------------ |
+| [Set up GPS for navigation](/navigation/how-to/set-up-gps/)        | Configure a GPS movement sensor and verify it reports accurate position and heading. |
+| [Navigate to a waypoint](/navigation/how-to/navigate-to-waypoint/) | Configure the navigation service and send your robot to a GPS coordinate.            |
+
+## Navigation tasks
+
+| Guide                                                                    | What you'll do                                                                        |
+| ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------- |
+| [Follow a patrol route](/navigation/how-to/follow-a-patrol-route/)       | Define a sequence of waypoints and navigate them repeatedly.                          |
+| [Avoid obstacles](/navigation/how-to/avoid-obstacles/)                   | Add vision-based obstacle detection to navigation.                                    |
+| [Run actions at waypoints](/navigation/how-to/run-actions-at-waypoints/) | Capture data, take readings, or trigger actions when the robot reaches each waypoint. |
+
+## Tuning and operations
+
+| Guide                                                                    | What you'll do                                                            |
+| ------------------------------------------------------------------------ | ------------------------------------------------------------------------- |
+| [Tune navigation behavior](/navigation/how-to/tune-navigation/)          | Adjust speed, deviation threshold, and polling for your environment.      |
+| [Monitor and troubleshoot](/navigation/how-to/monitor-and-troubleshoot/) | Use the Control tab map, read logs, and debug common navigation problems. |
diff --git a/docs/navigation/how-to/avoid-obstacles.md b/docs/navigation/how-to/avoid-obstacles.md
new file mode 100644
index 0000000000..33ab6426cc
--- /dev/null
+++ b/docs/navigation/how-to/avoid-obstacles.md
@@ -0,0 +1,176 @@
+---
+linkTitle: "Avoid obstacles"
+title: "Avoid obstacles during navigation"
+weight: 40
+layout: "docs"
+type: "docs"
+description: "Configure vision-based obstacle detection and static obstacles for autonomous navigation."
+aliases:
+  - /navigation/how-to/detect-while-moving/
+---
+
+The navigation service supports two kinds of obstacles: vision-detected
+obstacles from cameras and static obstacles defined in configuration. You
+can use both together.
+
+## Prerequisites
+
+- The [navigation service is configured](/navigation/how-to/navigate-to-waypoint/)
+  and your robot can navigate to a waypoint.
+- For vision-based detection: a [camera](/hardware/common-components/add-a-camera/)
+  and a [vision service](/vision/configure/) configured to detect obstacles.
+
+## Add vision-based obstacle detection
+
+Each obstacle detector pairs a vision service with a camera. The vision
+service analyzes frames from the camera and reports 3D obstacle geometries.
+The navigation service transforms these detections into geographic
+coordinates and feeds them to the path planner.
+
+### Configure an obstacle detector
+
+1. Open your navigation service configuration in the Viam app.
+2. In the **obstacle_detectors** section, add a detector:
+   - **vision_service**: the name of your vision service.
+   - **camera**: the name of the camera that feeds it.
+3. Click **Save**.
+
+```json
+{
+  "obstacle_detectors": [
+    {
+      "vision_service": "obstacle-detector",
+      "camera": "front-cam"
+    }
+  ]
+}
+```
+
+### Use multiple detectors
+
+You can configure multiple detectors for better coverage. Each detector
+operates independently and contributes its obstacles to the planner. The
+obstacles from all detectors are combined (not merged or deduplicated).
+
+Common multi-detector setups:
+
+- **Forward and rear cameras** for obstacle detection in both directions.
+- **Different vision models** on the same camera (one for large obstacles,
+  one for ground-level hazards).
+- **Different sensor types** (a camera-based detector for visual obstacles
+  and a lidar-based detector for transparent or reflective objects a camera
+  would miss).
+
+```json
+{
+  "obstacle_detectors": [
+    {
+      "vision_service": "obstacle-detector",
+      "camera": "front-cam"
+    },
+    {
+      "vision_service": "ground-hazard-detector",
+      "camera": "down-cam"
+    }
+  ]
+}
+```
+
+### How detection frequency works
+
+The navigation service polls each detector at
+`obstacle_polling_frequency_hz` (default 1 Hz). At each poll:
+
+1. The service queries the vision service for 3D point cloud objects.
+2. It transforms each detection from the camera's frame to geographic
+   coordinates using the movement sensor's position and heading.
+3. The transformed obstacles are added to the planner alongside any
+   static obstacles.
+
+Higher polling frequencies detect obstacles sooner but use more CPU and
+camera bandwidth. For robots moving at the default 0.3 m/s, 1 Hz means
+the robot moves about 30 cm between obstacle checks.
+
+## Add static obstacles
+
+Static obstacles are fixed geographic locations the robot should always
+avoid, regardless of what the cameras see. Use these for known hazards
+like ponds, buildings, restricted areas, or dropoffs.
+
+### Configure with the visual editor
+
+The easiest way to add static obstacles is through the Viam app:
+
+1. Open your navigation service in the **CONFIGURE** tab.
+2. The configuration card shows a map. Click to place obstacles on the
+   map.
+3. Define the obstacle shape (box, sphere, or capsule) and size.
+4. Click **Save**.
+
+### Configure in JSON
+
+Static obstacles are GeoGeometry objects in the `obstacles` array:
+
+```json
+{
+  "obstacles": [
+    {
+      "location": {
+        "latitude": 40.6645,
+        "longitude": -73.9382
+      },
+      "geometries": [
+        {
+          "type": "box",
+          "x": 5,
+          "y": 5,
+          "z": 2
+        }
+      ]
+    }
+  ]
+}
+```
+
+## Set up geofences (bounding regions)
+
+Bounding regions define geographic boundaries the robot must stay within.
+If configured, the path planner will not generate paths that leave these
+regions. Use bounding regions to keep the robot on your property, within a
+work zone, or away from roads.
+
+Configure bounding regions in the `bounding_regions` array. The format is
+the same as static obstacles (GeoGeometry objects), but the meaning is
+inverted: obstacles are areas to avoid, bounding regions are areas to stay
+within.
+
+```json
+{
+  "bounding_regions": [
+    {
+      "location": {
+        "latitude": 40.6643,
+        "longitude": -73.938
+      },
+      "geometries": [
+        {
+          "type": "box",
+          "x": 100,
+          "y": 100,
+          "z": 10
+        }
+      ]
+    }
+  ]
+}
+```
+
+## What's next
+
+- [Tune navigation behavior](/navigation/how-to/tune-navigation/):
+  adjust obstacle polling frequency and plan deviation for your
+  environment.
+- [Navigation service configuration](/navigation/reference/navigation-service/):
+  full reference for obstacle and bounding region attributes.
+- [Configure a vision service](/vision/configure/): set up the vision
+  service that powers your obstacle detectors.
diff --git a/docs/navigation/how-to/follow-a-patrol-route.md b/docs/navigation/how-to/follow-a-patrol-route.md
new file mode 100644
index 0000000000..f00843a56f
--- /dev/null
+++ b/docs/navigation/how-to/follow-a-patrol-route.md
@@ -0,0 +1,185 @@
+---
+linkTitle: "Follow a patrol route"
+title: "Follow a patrol route"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "Define a sequence of waypoints and navigate them repeatedly."
+---
+
+A patrol route is a sequence of GPS waypoints the robot visits in order.
+The navigation service handles driving between waypoints, replanning around
+obstacles, and retrying on failure. Your code defines the route and
+restarts it when the robot finishes.
+
+## Prerequisites
+
+- The [navigation service is configured](/navigation/how-to/navigate-to-waypoint/)
+  and your robot can navigate to a single waypoint.
+
+## Define a patrol route
+
+Add multiple waypoints in the order you want the robot to visit them.
+The navigation service visits waypoints in the order they were added.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.services.navigation import NavigationClient
+from viam.proto.common import GeoPoint
+from viam.proto.service.navigation import Mode
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    nav = NavigationClient.from_robot(robot, "my-nav")
+
+    # Define the patrol route
+    route = [
+        GeoPoint(latitude=40.6640, longitude=-73.9387),
+        GeoPoint(latitude=40.6645, longitude=-73.9382),
+        GeoPoint(latitude=40.6642, longitude=-73.9375),
+    ]
+
+    # Run the patrol loop
+    while True:
+        # Add all waypoints
+        for point in route:
+            await nav.add_waypoint(point)
+        print(f"Added {len(route)} waypoints")
+
+        # Start navigating
+        await nav.set_mode(Mode.MODE_WAYPOINT)
+
+        # Wait until all waypoints are visited
+        while True:
+            waypoints = await nav.get_waypoints()
+            if len(waypoints) == 0:
+                print("Patrol complete, restarting...")
+                break
+            await asyncio.sleep(5)
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "time"
+
+    "github.com/golang/geo/s2"
+    geo "github.com/kellydunn/golang-geo"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/services/navigation"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("patrol")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    nav, err := navigation.FromProvider(robot, "my-nav")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    // Define the patrol route
+    route := []*geo.Point{
+        geo.NewPoint(40.6640, -73.9387),
+        geo.NewPoint(40.6645, -73.9382),
+        geo.NewPoint(40.6642, -73.9375),
+    }
+
+    // Run the patrol loop
+    for {
+        for _, pt := range route {
+            if err := nav.AddWaypoint(ctx, pt, nil); err != nil {
+                logger.Fatal(err)
+            }
+        }
+        fmt.Printf("Added %d waypoints\n", len(route))
+
+        if err := nav.SetMode(ctx, navigation.ModeWaypoint, nil); err != nil {
+            logger.Fatal(err)
+        }
+
+        // Wait until all waypoints are visited
+        for {
+            wps, err := nav.Waypoints(ctx, nil)
+            if err != nil {
+                logger.Fatal(err)
+            }
+            if len(wps) == 0 {
+                fmt.Println("Patrol complete, restarting...")
+                break
+            }
+            time.Sleep(5 * time.Second)
+        }
+    }
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## How waypoint ordering works
+
+The navigation service visits waypoints in the order they were added.
+When all waypoints have been visited, GetWaypoints returns an empty list.
+The service does not automatically loop. Your code is responsible for
+re-adding waypoints to repeat the patrol.
+
+If the robot fails to reach a waypoint (obstacle it can't navigate around,
+motion planning failure), the service retries that waypoint indefinitely.
+It does not skip to the next waypoint. To skip a stuck waypoint, remove
+it with RemoveWaypoint.
+
+## Using the memory vs MongoDB store
+
+With the **memory store** (default), waypoints are lost if `viam-server`
+restarts. If your robot reboots mid-patrol, your code needs to re-add the
+waypoints on startup.
+
+With the **MongoDB store**, waypoints persist across restarts. The robot
+resumes from the first unvisited waypoint after a reboot. This is better
+for long-running patrol deployments where the robot may restart due to
+updates or power cycling.
+
+## What's next
+
+- [Avoid obstacles](/navigation/how-to/avoid-obstacles/): add
+  vision-based obstacle detection to your patrol.
+- [Run actions at waypoints](/navigation/how-to/run-actions-at-waypoints/):
+  capture data or trigger actions at each patrol stop.
+- [Tune navigation behavior](/navigation/how-to/tune-navigation/):
+  adjust speed and deviation for your patrol environment.
diff --git a/docs/navigation/how-to/monitor-and-troubleshoot.md b/docs/navigation/how-to/monitor-and-troubleshoot.md
new file mode 100644
index 0000000000..4c65fe527f
--- /dev/null
+++ b/docs/navigation/how-to/monitor-and-troubleshoot.md
@@ -0,0 +1,147 @@
+---
+linkTitle: "Monitor and troubleshoot"
+title: "Monitor and troubleshoot navigation"
+weight: 70
+layout: "docs"
+type: "docs"
+description: "Use the Control tab map, read logs, and debug common navigation problems."
+---
+
+## Monitor navigation in the Viam app
+
+The Control tab shows a live map with your robot's position, waypoints,
+and obstacles. Use it to monitor navigation in real time.
+
+1. Go to your machine's **CONTROL** tab.
+2. Find the navigation service card.
+3. The map shows:
+   - **Robot position** with a directional marker showing heading.
+   - **Waypoints** as markers you can add or remove.
+   - **Obstacles** (both static and vision-detected).
+   - **Current mode** (Manual or Waypoint).
+
+## Enable debug logging
+
+Set `log_file_path` in your navigation service configuration to write
+detailed logs to a file:
+
+```json
+{
+  "log_file_path": "/tmp/navigation.log"
+}
+```
+
+The log includes mode transitions, waypoint navigation attempts and
+completions, obstacle detections, frame transformations, and motion
+service calls. This is the most useful tool for understanding why the
+robot behaves unexpectedly.
+
+You can also check the **LOGS** tab in the Viam app for errors from the
+navigation and motion services.
+
+## Common problems
+
+{{< expand "Robot doesn't move after setting Waypoint mode" >}}
+
+1. Check that waypoints exist: call GetWaypoints or check the Control tab
+   map. The service needs at least one unvisited waypoint to navigate.
+2. Check the LOGS tab for motion service errors. Common causes:
+   - The base isn't responding (hardware or wiring issue).
+   - The movement sensor isn't returning position data (GPS not locked).
+   - The motion service can't plan a path (obstacles blocking all routes).
+3. Verify the base works independently by testing it from its TEST section
+   in the configure tab.
+
+{{< /expand >}}
+
+{{< expand "Robot replans constantly and makes slow progress" >}}
+
+Your `plan_deviation_m` is likely lower than your GPS error. The robot
+replans because normal GPS jitter (2-5 meters with standard GPS) exceeds
+the deviation threshold (default 2.6 meters).
+
+Fix: increase `plan_deviation_m` to 5-10 meters for standard GPS. See
+[Tune navigation behavior](/navigation/how-to/tune-navigation/) for
+guidance on setting this relative to your GPS accuracy.
+
+{{< /expand >}}
+
+{{< expand "Robot moves in circles or turns the wrong way" >}}
+
+This usually indicates a compass heading problem:
+
+- **Compass interference from motors:** Mount the GPS/IMU module farther
+  from motors and power wiring.
+- **Compass not calibrated:** Run magnetometer calibration per your
+  module's documentation.
+- **Heading offset:** The compass reports a consistent offset (for
+  example, 90 degrees off). Check the module's orientation configuration.
+
+Verify by watching the compass heading in the movement sensor's TEST
+section while rotating the robot by hand. The heading should change
+smoothly and correspond to the actual direction.
+
+{{< /expand >}}
+
+{{< expand "Robot gets stuck at a waypoint and retries indefinitely" >}}
+
+When the navigation service can't reach a waypoint (obstacle it can't
+navigate around, GPS position it can't get close enough to), it retries
+the same waypoint indefinitely. It does not skip to the next waypoint.
+
+To unblock:
+
+- Remove the stuck waypoint with RemoveWaypoint (from code or the Control
+  tab).
+- Check whether a static obstacle or bounding region prevents the robot
+  from reaching that location.
+- Check whether vision-based obstacle detection is producing false
+  positives that block the path.
+
+{{< /expand >}}
+
+{{< expand "Robot navigates but stops short of the waypoint" >}}
+
+The motion service considers a waypoint reached when the robot is within
+the planning tolerance of the target. With standard GPS accuracy, the
+robot may stop 2-5 meters from the intended coordinates because the GPS
+position satisfies the arrival condition even though the robot isn't
+exactly at the target.
+
+For tighter arrival accuracy, use RTK GPS.
+
+{{< /expand >}}
+
+{{< expand "Obstacles aren't detected" >}}
+
+1. Verify the vision service detects obstacles independently. Go to the
+   vision service's TEST section and check that it returns 3D object
+   point clouds from the camera.
+2. Check `obstacle_polling_frequency_hz`. At 0 Hz, no obstacle polling
+   occurs.
+3. Check that the camera and vision service names in `obstacle_detectors`
+   match the exact names in your configuration.
+4. Check the LOGS tab for frame transformation errors. The navigation
+   service needs to transform obstacle positions from the camera frame
+   to geographic coordinates through the movement sensor.
+
+{{< /expand >}}
+
+{{< expand "GPS position jumps or is inaccurate" >}}
+
+- Verify you have clear sky visibility. Trees, buildings, and overhead
+  structures degrade GPS accuracy.
+- Check the number of satellites your GPS module is tracking (if your
+  module exposes this data).
+- Consider upgrading to an RTK GPS module for sub-meter accuracy.
+- If the position jumps between two locations, you may have multipath
+  interference from nearby reflective surfaces.
+
+{{< /expand >}}
+
+## What's next
+
+- [Tune navigation behavior](/navigation/how-to/tune-navigation/):
+  adjust parameters based on what you observe.
+- [Navigation service configuration](/navigation/reference/navigation-service/):
+  full reference for all configuration parameters.
diff --git a/docs/navigation/how-to/navigate-to-waypoint.md b/docs/navigation/how-to/navigate-to-waypoint.md
new file mode 100644
index 0000000000..da1ef68f9e
--- /dev/null
+++ b/docs/navigation/how-to/navigate-to-waypoint.md
@@ -0,0 +1,260 @@
+---
+linkTitle: "Navigate to waypoint"
+title: "Navigate to a waypoint"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "Configure the navigation service and autonomously navigate to GPS waypoints."
+aliases:
+  - /navigation/how-to/drive-the-base/
+  - /navigation/how-to/move-to-gps-coordinate/
+---
+
+This guide walks you through configuring the navigation service and sending
+your robot to its first GPS waypoint.
+
+## Prerequisites
+
+- A configured [base](/hardware/common-components/add-a-base/) that drives
+  your robot.
+- A configured [movement sensor](/navigation/how-to/set-up-gps/) that
+  provides GPS position and compass heading. Verify it reports accurate
+  data before proceeding.
+- Your machine is online in the [Viam app](https://app.viam.com).
+
+## Add the navigation service
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for **navigation** and select the **builtin** model.
+4. Name it (for example, `my-nav`) and click **Create**.
+
+## Configure required attributes
+
+Set these attributes in the configuration panel:
+
+- **base**: the name of your base component (for example, `my-base`).
+- **movement_sensor**: the name of your GPS movement sensor (for example,
+  `my-gps`).
+- **map_type**: select **GPS**.
+
+Leave the other attributes at their defaults for now.
+See [navigation service configuration](/navigation/reference/navigation-service/)
+for all available attributes and what they control.
+
+Click **Save**.
+
+## Send the robot to a waypoint
+
+You can add waypoints through the Viam app's Control tab or from code.
+
+### Using the Control tab
+
+1. Go to your machine's **CONTROL** tab.
+2. Find the navigation service card. It shows a map centered on your
+   robot's GPS position.
+3. Click on the map to add a waypoint. A marker appears at that location.
+4. Switch the mode to **Waypoint**.
+5. The robot begins navigating to the waypoint. Watch its position update
+   on the map.
+
+When the robot reaches the waypoint, it marks the waypoint as visited.
+If you've added multiple waypoints, it navigates to the next one in order.
+
+### Using code
+
+Add a waypoint and set the mode to Waypoint programmatically.
+
+To get the credentials for the code below, go to your machine's page in
+the Viam app, click the **CONNECT** tab, and select **API keys**.
+Copy the **API key** and **API key ID**.
+Copy the **machine address** from the same tab.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.services.navigation import NavigationClient
+from viam.proto.common import GeoPoint
+from viam.proto.service.navigation import Mode
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    nav = NavigationClient.from_robot(robot, "my-nav")
+
+    # Add a waypoint (replace with your target coordinates)
+    target = GeoPoint(latitude=40.6640, longitude=-73.9387)
+    await nav.add_waypoint(target)
+    print(f"Added waypoint at {target.latitude}, {target.longitude}")
+
+    # Start navigating
+    await nav.set_mode(Mode.MODE_WAYPOINT)
+    print("Navigation started")
+
+    # Monitor progress
+    while True:
+        location = await nav.get_location()
+        waypoints = await nav.get_waypoints()
+        print(f"Position: {location.latitude:.6f}, {location.longitude:.6f}")
+        print(f"Remaining waypoints: {len(waypoints)}")
+
+        if len(waypoints) == 0:
+            print("All waypoints reached")
+            break
+
+        await asyncio.sleep(2)
+
+    # Stop navigation
+    await nav.set_mode(Mode.MODE_MANUAL)
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "time"
+
+    "github.com/golang/geo/s2"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/services/navigation"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("nav-test")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    nav, err := navigation.FromProvider(robot, "my-nav")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    // Add a waypoint (replace with your target coordinates)
+    target := s2.LatLngFromDegrees(40.6640, -73.9387)
+    point := s2.PointFromLatLng(target)
+    geoPoint := geo.NewPoint(target.Lat.Degrees(), target.Lng.Degrees())
+    err = nav.AddWaypoint(ctx, geoPoint, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Added waypoint at %f, %f\n", target.Lat.Degrees(), target.Lng.Degrees())
+
+    // Start navigating
+    err = nav.SetMode(ctx, navigation.ModeWaypoint, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Println("Navigation started")
+
+    // Monitor progress
+    for {
+        loc, err := nav.Location(ctx, nil)
+        if err != nil {
+            logger.Fatal(err)
+        }
+        waypoints, err := nav.Waypoints(ctx, nil)
+        if err != nil {
+            logger.Fatal(err)
+        }
+
+        fmt.Printf("Position: %f, %f\n", loc.Location().Lat(), loc.Location().Lng())
+        fmt.Printf("Remaining waypoints: %d\n", len(waypoints))
+
+        if len(waypoints) == 0 {
+            fmt.Println("All waypoints reached")
+            break
+        }
+
+        time.Sleep(2 * time.Second)
+    }
+
+    // Stop navigation
+    nav.SetMode(ctx, navigation.ModeManual, nil)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## What to expect
+
+When navigation starts:
+
+- The robot turns to face the waypoint, then drives toward it.
+- If the robot deviates from its path by more than `plan_deviation_m`
+  (default 2.6 meters), the service automatically replans.
+- If an obstacle is detected (from configured obstacle detectors), the
+  service replans around it.
+- When the robot reaches the waypoint, it marks it as visited and stops
+  (or moves to the next waypoint if more are queued).
+
+## Troubleshooting
+
+{{< expand "Robot doesn't move" >}}
+
+- Confirm the machine shows as **Live** in the Viam app.
+- Confirm the navigation mode is set to **Waypoint** (not Manual).
+- Check the **LOGS** tab for errors from the navigation or motion service.
+- Verify your base responds to direct commands first (use the base's
+  TEST section in the configure tab).
+- Verify your GPS movement sensor reports a valid position.
+
+{{< /expand >}}
+
+{{< expand "Robot moves erratically or in circles" >}}
+
+- Check compass heading accuracy. If the compass is affected by motor
+  interference, the robot won't know which direction to face. See
+  [Set up GPS](/navigation/how-to/set-up-gps/) for interference guidance.
+- Increase `plan_deviation_m` if the robot replans too frequently due
+  to GPS jitter. See [Tune navigation](/navigation/how-to/tune-navigation/).
+
+{{< /expand >}}
+
+{{< expand "Robot stops before reaching waypoint" >}}
+
+- The robot may be detecting an obstacle it can't navigate around. Check
+  GetObstacles from the API or the Control tab map for detected obstacles.
+- If using obstacle detectors, check that the vision service isn't
+  producing false positives.
+
+{{< /expand >}}
+
+## What's next
+
+- [Follow a patrol route](/navigation/how-to/follow-a-patrol-route/):
+  navigate a sequence of waypoints in a loop.
+- [Avoid obstacles](/navigation/how-to/avoid-obstacles/): add
+  vision-based obstacle detection.
+- [Tune navigation behavior](/navigation/how-to/tune-navigation/):
+  adjust speed, deviation, and polling for your environment.
diff --git a/docs/navigation/how-to/run-actions-at-waypoints.md b/docs/navigation/how-to/run-actions-at-waypoints.md
new file mode 100644
index 0000000000..a3f11c2631
--- /dev/null
+++ b/docs/navigation/how-to/run-actions-at-waypoints.md
@@ -0,0 +1,145 @@
+---
+linkTitle: "Run actions at waypoints"
+title: "Run actions at waypoints"
+weight: 60
+layout: "docs"
+type: "docs"
+description: "Capture data, take readings, or trigger actions when the robot reaches each waypoint."
+---
+
+The navigation service drives the robot between waypoints, but it doesn't
+perform actions at each stop. To capture an image, take a sensor reading,
+or trigger an alert at each waypoint, write code that monitors the robot's
+progress and acts when a waypoint is reached.
+
+## The pattern
+
+1. Add waypoints to the navigation service.
+2. Set the mode to Waypoint.
+3. Poll GetWaypoints to detect when a waypoint is visited (it disappears
+   from the list).
+4. When a waypoint is visited, run your action.
+5. Repeat until all waypoints are visited.
+
+## Example: capture an image at each waypoint
+
+This example navigates to a sequence of GPS coordinates and captures a
+camera image at each one.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+import asyncio
+from datetime import datetime
+from viam.robot.client import RobotClient
+from viam.services.navigation import NavigationClient
+from viam.components.camera import Camera
+from viam.proto.common import GeoPoint
+from viam.proto.service.navigation import Mode
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    nav = NavigationClient.from_robot(robot, "my-nav")
+    cam = Camera.from_robot(robot, "my-cam")
+
+    # Define inspection points
+    inspection_route = [
+        GeoPoint(latitude=40.6640, longitude=-73.9387),
+        GeoPoint(latitude=40.6645, longitude=-73.9382),
+        GeoPoint(latitude=40.6642, longitude=-73.9375),
+    ]
+
+    # Add all waypoints
+    for point in inspection_route:
+        await nav.add_waypoint(point)
+
+    # Start navigating
+    await nav.set_mode(Mode.MODE_WAYPOINT)
+
+    # Track which waypoints have been visited
+    previous_count = len(inspection_route)
+    waypoint_index = 0
+
+    while True:
+        waypoints = await nav.get_waypoints()
+        current_count = len(waypoints)
+
+        # A waypoint was visited when the count decreases
+        if current_count < previous_count:
+            print(f"Reached waypoint {waypoint_index + 1}")
+
+            # Pause navigation to hold position while capturing
+            await nav.set_mode(Mode.MODE_MANUAL)
+
+            # Capture image
+            images, metadata = await cam.get_images()
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"waypoint_{waypoint_index + 1}_{timestamp}.jpg"
+
+            # Save or process the image
+            print(f"Captured image: {filename}")
+
+            # Resume navigation
+            await nav.set_mode(Mode.MODE_WAYPOINT)
+
+            waypoint_index += 1
+            previous_count = current_count
+
+        if current_count == 0:
+            print("Inspection complete")
+            break
+
+        await asyncio.sleep(2)
+
+    await nav.set_mode(Mode.MODE_MANUAL)
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## How it works
+
+The navigation service marks waypoints as visited when the robot arrives
+at each one. GetWaypoints returns only unvisited waypoints. By tracking
+the count, you detect arrivals.
+
+When a waypoint is visited:
+
+1. Switch to Manual mode to pause navigation and hold position.
+2. Perform your action (capture image, read sensor, send alert).
+3. Switch back to Waypoint mode to resume navigation to the next waypoint.
+
+Switching to Manual mode stops the current motion plan but preserves the
+remaining waypoints. Switching back to Waypoint mode resumes navigation
+from the next unvisited waypoint.
+
+## Other actions you can run at waypoints
+
+The pattern works with any Viam API call:
+
+- **Sensor readings:** `await sensor.get_readings()` to log environmental
+  data at each location.
+- **Vision detections:** `await vision.get_detections_from_camera("cam")`
+  to run object detection at each stop.
+- **Alerts:** send a webhook or log entry when the robot reaches a
+  specific location.
+- **Gripper operations:** pick up or place objects at designated
+  waypoints.
+
+## What's next
+
+- [Follow a patrol route](/navigation/how-to/follow-a-patrol-route/):
+  run waypoint actions on a repeating patrol.
+- [Capture and sync data](/data/capture-sync/capture-and-sync-data/):
+  configure automatic data capture for your camera or sensors.
diff --git a/docs/navigation/how-to/set-up-gps.md b/docs/navigation/how-to/set-up-gps.md
new file mode 100644
index 0000000000..fd7b581731
--- /dev/null
+++ b/docs/navigation/how-to/set-up-gps.md
@@ -0,0 +1,196 @@
+---
+linkTitle: "Set up GPS"
+title: "Set up GPS for navigation"
+weight: 5
+layout: "docs"
+type: "docs"
+description: "Configure a GPS movement sensor and verify it reports accurate position and heading before enabling navigation."
+---
+
+Before you can use the navigation service, you need a movement sensor that
+provides GPS position and compass heading. This guide walks you through
+choosing a GPS module, configuring it, and verifying the data is accurate
+enough for navigation.
+
+## Choose a GPS module
+
+Browse GPS-capable movement sensor models in the
+[Viam registry](https://app.viam.com/registry?type=component&subtype=movement_sensor).
+Search for your GPS hardware by manufacturer or chip name.
+
+### GPS accuracy and what it means for navigation
+
+Standard GPS is accurate to approximately 3 meters under open sky. In
+environments with trees, buildings, or uneven terrain, accuracy degrades
+due to signal interference.
+
+The navigation service's `plan_deviation_m` parameter controls how far the
+robot can drift from its planned path before replanning. If your GPS error
+is 3 meters and `plan_deviation_m` is 2.6 meters (the default), the robot
+will replan frequently because normal GPS jitter exceeds the threshold.
+
+| GPS type          | Typical accuracy | Good `plan_deviation_m` range |
+| ----------------- | ---------------- | ----------------------------- |
+| Standard GPS      | 2-5 meters       | 5-10 meters                   |
+| SBAS-enhanced GPS | 1-3 meters       | 3-5 meters                    |
+| RTK GPS           | 1-10 centimeters | 0.5-2 meters                  |
+
+If your application requires sub-meter accuracy (following a precise path,
+working near obstacles), look for RTK GPS modules in the registry.
+
+## Configure the movement sensor
+
+1. Open your machine in the [Viam app](https://app.viam.com).
+2. Click the **+** button and select **Configuration block**.
+3. Search for the model that matches your GPS hardware.
+4. Name it (for example, `my-gps`) and click **Create**.
+5. Configure the attributes as required by your module (serial port,
+   baud rate, I2C address, or network settings).
+6. Click **Save**.
+
+## Verify GPS position
+
+Before configuring navigation, confirm the movement sensor reports
+accurate GPS data.
+
+1. Find your movement sensor in the configuration view.
+2. Expand the **TEST** section.
+3. Check that **position** shows a latitude and longitude close to your
+   actual location.
+4. Check that **compass heading** updates when you rotate the robot.
+   0 degrees is north, 90 is east, 180 is south, 270 is west.
+
+If the position is significantly wrong or the compass heading doesn't
+change when you rotate the robot, check your wiring and module
+configuration before proceeding.
+
+### Compass interference
+
+The compass (magnetometer) in many GPS/IMU modules is sensitive to
+magnetic interference from motors, metal structures, and power wiring.
+Common symptoms:
+
+- Heading doesn't change when the robot rotates.
+- Heading jumps erratically.
+- Heading is consistently offset by a fixed amount.
+
+To reduce interference:
+
+- Mount the GPS module as far from motors and power wiring as practical.
+- Run magnetometer calibration if your module supports it (check the
+  module's documentation in the registry).
+- Consider the
+  [merged movement sensor](/hardware/common-components/add-a-movement-sensor/)
+  model, which combines data from multiple sensors. For example, use GPS
+  for position and a separately mounted IMU for heading.
+
+## Verify with code
+
+Read position and heading programmatically to confirm the data is
+available to your application code.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.components.movement_sensor import MovementSensor
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    gps = MovementSensor.from_robot(robot, "my-gps")
+
+    position, altitude = await gps.get_position()
+    heading = await gps.get_compass_heading()
+    properties = await gps.get_properties()
+
+    print(f"Latitude:  {position.latitude}")
+    print(f"Longitude: {position.longitude}")
+    print(f"Altitude:  {altitude}m")
+    print(f"Heading:   {heading} degrees")
+    print(f"Supports position: {properties.position_supported}")
+    print(f"Supports heading:  {properties.compass_heading_supported}")
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/components/movementsensor"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/utils"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("gps-test")
+
+    robot, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithCredentials(utils.Credentials{
+            Type:    utils.CredentialsTypeAPIKey,
+            Payload: "YOUR-API-KEY",
+        }),
+        client.WithAPIKeyID("YOUR-API-KEY-ID"),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer robot.Close(ctx)
+
+    gps, err := movementsensor.FromProvider(robot, "my-gps")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    pos, alt, err := gps.Position(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    heading, err := gps.CompassHeading(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    props, err := gps.Properties(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    fmt.Printf("Latitude:  %f\n", pos.Lat())
+    fmt.Printf("Longitude: %f\n", pos.Lng())
+    fmt.Printf("Altitude:  %fm\n", alt)
+    fmt.Printf("Heading:   %f degrees\n", heading)
+    fmt.Printf("Supports position: %v\n", props.PositionSupported)
+    fmt.Printf("Supports heading:  %v\n", props.CompassHeadingSupported)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## What's next
+
+- [Navigate to a waypoint](/navigation/how-to/navigate-to-waypoint/):
+  configure the navigation service and send your robot to a GPS coordinate.
+- [Movement sensor API reference](/reference/apis/components/movement-sensor/):
+  full method documentation.
diff --git a/docs/navigation/how-to/tune-navigation.md b/docs/navigation/how-to/tune-navigation.md
new file mode 100644
index 0000000000..99d0c08fdb
--- /dev/null
+++ b/docs/navigation/how-to/tune-navigation.md
@@ -0,0 +1,92 @@
+---
+linkTitle: "Tune navigation"
+title: "Tune navigation behavior"
+weight: 50
+layout: "docs"
+type: "docs"
+description: "Adjust speed, deviation threshold, and polling for your environment and GPS accuracy."
+---
+
+The navigation service starts with defaults that work for slow outdoor
+robots with standard GPS. As you test in your environment, you'll want to
+adjust these parameters.
+
+All parameters can be changed in the Viam app without restarting
+`viam-server`. Changes take effect on the next navigation cycle.
+
+## Speed
+
+| Parameter        | Default | What it controls                                            |
+| ---------------- | ------- | ----------------------------------------------------------- |
+| `meters_per_sec` | 0.3     | Linear speed. How fast the robot drives in a straight line. |
+| `degs_per_sec`   | 20.0    | Angular speed. How fast the robot turns.                    |
+
+**When to increase speed:** Your robot's motors and terrain support faster
+movement, and your obstacle detection polling is fast enough to react at
+the higher speed. At 1 m/s with 1 Hz obstacle polling, the robot travels
+1 meter between obstacle checks.
+
+**When to decrease speed:** The robot overshoots waypoints, turns are too
+aggressive, or obstacle detection can't keep up. Reduce angular speed
+first if turns are the problem.
+
+## Plan deviation
+
+| Parameter          | Default | What it controls                                                                                    |
+| ------------------ | ------- | --------------------------------------------------------------------------------------------------- |
+| `plan_deviation_m` | 2.6     | How far the robot can drift from its planned path (in meters) before the service triggers a replan. |
+
+This is the most important tuning parameter. Set it relative to your GPS
+accuracy:
+
+| GPS type      | GPS error | Recommended `plan_deviation_m` |
+| ------------- | --------- | ------------------------------ |
+| Standard GPS  | 2-5m      | 5-10m                          |
+| SBAS-enhanced | 1-3m      | 3-5m                           |
+| RTK GPS       | 1-10cm    | 0.5-2m                         |
+
+**If it's too low** (below your GPS error), the robot replans constantly
+because normal GPS jitter looks like path deviation. You'll see the robot
+stop and recalculate frequently, making slow progress.
+
+**If it's too high**, the robot tolerates large deviations before
+correcting. It might cut corners, drift off the intended path, or approach
+obstacles before replanning.
+
+## Polling frequencies
+
+| Parameter                       | Default | What it controls                             |
+| ------------------------------- | ------- | -------------------------------------------- |
+| `position_polling_frequency_hz` | 1.0     | How often to check the robot's GPS position. |
+| `obstacle_polling_frequency_hz` | 1.0     | How often to query obstacle detectors.       |
+
+**Position polling** determines how quickly the service detects that the
+robot has deviated from its plan. At 1 Hz, a deviation takes up to 1
+second to detect. For fast-moving robots, increase this.
+
+**Obstacle polling** determines how quickly new obstacles are detected.
+Higher values improve reaction time but increase CPU and camera bandwidth
+usage. Balance against your robot's speed: at 0.3 m/s and 1 Hz, the robot
+moves 30 cm between checks. At 1 m/s, it moves 1 meter.
+
+## Tuning workflow
+
+1. **Start with defaults.** Navigate to a nearby waypoint in an open area
+   with no obstacles.
+2. **Check for excessive replanning.** If the robot stops frequently to
+   recalculate, increase `plan_deviation_m`. Watch the Control tab map to
+   see when replans happen.
+3. **Adjust speed.** Increase `meters_per_sec` gradually. Watch for
+   overshooting waypoints or unstable turns.
+4. **Add obstacle detection.** Once basic navigation works, add obstacle
+   detectors and test with known obstacles.
+5. **Adjust polling.** If the robot doesn't detect obstacles quickly
+   enough, increase `obstacle_polling_frequency_hz`. If the robot is
+   slow because of excessive polling, decrease it.
+
+## What's next
+
+- [Navigation service configuration](/navigation/reference/navigation-service/):
+  full reference for all parameters.
+- [Monitor and troubleshoot](/navigation/how-to/monitor-and-troubleshoot/):
+  debug navigation problems using the Control tab and logs.
diff --git a/docs/navigation/reference/_index.md b/docs/navigation/reference/_index.md
new file mode 100644
index 0000000000..2a22778b63
--- /dev/null
+++ b/docs/navigation/reference/_index.md
@@ -0,0 +1,14 @@
+---
+linkTitle: "Reference"
+title: "Navigation reference"
+weight: 200
+layout: "docs"
+type: "docs"
+no_list: true
+description: "Configuration and API reference for the navigation service."
+---
+
+| Reference                                                                     | What it covers                                                   |
+| ----------------------------------------------------------------------------- | ---------------------------------------------------------------- |
+| [Navigation service configuration](/navigation/reference/navigation-service/) | All configuration attributes with types, defaults, and guidance. |
+| [Navigation API](/navigation/reference/api/)                                  | All API methods with parameters, return types, and examples.     |
diff --git a/docs/navigation/reference/api.md b/docs/navigation/reference/api.md
new file mode 100644
index 0000000000..1424a21173
--- /dev/null
+++ b/docs/navigation/reference/api.md
@@ -0,0 +1,295 @@
+---
+linkTitle: "API"
+title: "Navigation service API"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "The navigation service API for autonomous GPS-based navigation."
+---
+
+The navigation service API provides methods for controlling autonomous
+GPS-based navigation. Use these methods to set the navigation mode, manage
+waypoints, monitor the robot's location, and query obstacles and paths.
+
+## GetMode
+
+Get the current navigation mode.
+
+**Returns:** `Mode` (MANUAL, WAYPOINT, or EXPLORE)
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+mode = await nav.get_mode()
+print(f"Current mode: {mode}")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+mode, err := nav.Mode(ctx, nil)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## SetMode
+
+Set the navigation mode.
+
+| Parameter | Type | Description                                      |
+| --------- | ---- | ------------------------------------------------ |
+| `mode`    | Mode | The mode to set: `MODE_MANUAL`, `MODE_WAYPOINT`. |
+
+In **Manual** mode, the navigation service is passive. You control the
+base directly. In **Waypoint** mode, the service takes control of the
+base and navigates to unvisited waypoints.
+
+Switching from Waypoint to Manual stops the current motion plan but
+preserves all waypoints. Switching back to Waypoint resumes from the next
+unvisited waypoint.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.proto.service.navigation import Mode
+
+await nav.set_mode(Mode.MODE_WAYPOINT)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+err := nav.SetMode(ctx, navigation.ModeWaypoint, nil)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## GetLocation
+
+Get the robot's current GPS location and compass heading.
+
+**Returns:** `GeoPoint` with latitude and longitude, plus compass heading
+in degrees (0 = north, 90 = east, 180 = south, 270 = west).
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+location = await nav.get_location()
+print(f"Lat: {location.latitude}, Lng: {location.longitude}")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+geoPose, err := nav.Location(ctx, nil)
+loc := geoPose.Location()
+heading := geoPose.Heading()
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## GetWaypoints
+
+Get all unvisited waypoints. Visited waypoints are not included.
+
+**Returns:** list of `Waypoint` objects, each with an `id` and `location`
+(GeoPoint).
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+waypoints = await nav.get_waypoints()
+for wp in waypoints:
+    print(f"Waypoint {wp.id}: {wp.location.latitude}, {wp.location.longitude}")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+waypoints, err := nav.Waypoints(ctx, nil)
+for _, wp := range waypoints {
+    pt := wp.ToPoint()
+    fmt.Printf("Waypoint %s: %f, %f\n", wp.ID.Hex(), pt.Lat(), pt.Lng())
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## AddWaypoint
+
+Add a GPS waypoint to the navigation queue. Waypoints are visited in the
+order they are added.
+
+| Parameter  | Type     | Description                                                |
+| ---------- | -------- | ---------------------------------------------------------- |
+| `location` | GeoPoint | The GPS coordinates (latitude, longitude) of the waypoint. |
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.proto.common import GeoPoint
+
+point = GeoPoint(latitude=40.6640, longitude=-73.9387)
+await nav.add_waypoint(point)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+point := geo.NewPoint(40.6640, -73.9387)
+err := nav.AddWaypoint(ctx, point, nil)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## RemoveWaypoint
+
+Remove a waypoint by its ID. Use this to skip a waypoint the robot can't
+reach, or to clear the queue.
+
+| Parameter | Type   | Description                        |
+| --------- | ------ | ---------------------------------- |
+| `id`      | string | The waypoint ID from GetWaypoints. |
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+waypoints = await nav.get_waypoints()
+if waypoints:
+    await nav.remove_waypoint(waypoints[0].id)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+waypoints, _ := nav.Waypoints(ctx, nil)
+if len(waypoints) > 0 {
+    err := nav.RemoveWaypoint(ctx, waypoints[0].ID, nil)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## GetObstacles
+
+Get all known obstacles, including both static obstacles from configuration
+and transient obstacles detected by vision services.
+
+**Returns:** list of `GeoGeometry` objects.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+obstacles = await nav.get_obstacles()
+print(f"Found {len(obstacles)} obstacles")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+obstacles, err := nav.Obstacles(ctx, nil)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## GetPaths
+
+Get the planned paths to waypoints, if any exist.
+
+**Returns:** list of `Path` objects, each with a destination waypoint ID
+and a list of GeoPoints defining the path.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+paths = await nav.get_paths()
+for path in paths:
+    print(f"Path to {path.destination_waypoint_id}: {len(path.geopoints)} points")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+paths, err := nav.Paths(ctx, nil)
+for _, p := range paths {
+    fmt.Printf("Path to %s: %d points\n",
+        p.DestinationWaypointID().Hex(), len(p.GeoPoints()))
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## GetProperties
+
+Get the navigation service's properties, including the map type.
+
+**Returns:** `MapType` (NONE or GPS).
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+props = await nav.get_properties()
+print(f"Map type: {props}")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+props, err := nav.Properties(ctx)
+fmt.Printf("Map type: %v\n", props.MapType)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## DoCommand
+
+Send an arbitrary command to the navigation service. This is model-specific
+and depends on the implementation.
+
+| Parameter | Type | Description                           |
+| --------- | ---- | ------------------------------------- |
+| `command` | map  | Key-value pairs defining the command. |
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+result = await nav.do_command({"custom_command": "value"})
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+result, err := nav.DoCommand(ctx, map[string]interface{}{"custom_command": "value"})
+```
+
+{{% /tab %}}
+{{< /tabs >}}
diff --git a/docs/navigation/reference/navigation-service.md b/docs/navigation/reference/navigation-service.md
new file mode 100644
index 0000000000..dcd15be0d2
--- /dev/null
+++ b/docs/navigation/reference/navigation-service.md
@@ -0,0 +1,125 @@
+---
+linkTitle: "Navigation service"
+title: "Navigation service configuration"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Configure the navigation service for autonomous GPS-based waypoint navigation."
+---
+
+The navigation service is configured as a service in your machine's JSON
+configuration. You can configure it through the Viam app UI or by editing
+JSON directly.
+
+## Required attributes
+
+| Attribute         | Type   | Description                                                                                                                                                            |
+| ----------------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `base`            | string | Name of the [base component](/hardware/common-components/add-a-base/) the navigation service drives.                                                                   |
+| `movement_sensor` | string | Name of the [movement sensor](/hardware/common-components/add-a-movement-sensor/) that provides GPS position and compass heading. Required when `map_type` is `"GPS"`. |
+| `store`           | object | Where to store waypoints. See [Store configuration](#store-configuration).                                                                                             |
+
+## Optional attributes
+
+| Attribute                       | Type   | Default     | Description                                                                                                                                                                                                                                                        |
+| ------------------------------- | ------ | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `map_type`                      | string | `"GPS"`     | `"GPS"` for GPS-based waypoint navigation. `"none"` for manual-only mode (no autonomous navigation).                                                                                                                                                               |
+| `motion_service`                | string | `"builtin"` | Name of the motion service to use for path planning. Most users should leave this as the default.                                                                                                                                                                  |
+| `meters_per_sec`                | float  | `0.3`       | Linear speed in meters per second. How fast the robot drives in a straight line. Start low and increase after testing. Faster speeds need more stopping distance for obstacle avoidance.                                                                           |
+| `degs_per_sec`                  | float  | `20.0`      | Angular speed in degrees per second. How fast the robot turns. Higher values make sharper turns. Lower values make smoother, wider turns.                                                                                                                          |
+| `plan_deviation_m`              | float  | `2.6`       | How far the robot can deviate from its planned path (in meters) before replanning. Set this larger than your GPS error. With standard GPS (~3m accuracy), the default of 2.6m means frequent replanning. Consider 5-10m for standard GPS, or 1-2m if you have RTK. |
+| `position_polling_frequency_hz` | float  | `1.0`       | How often to check the robot's GPS position, in Hz. Higher values detect deviation sooner but use more CPU. 1 Hz is sufficient for most outdoor robots.                                                                                                            |
+| `obstacle_polling_frequency_hz` | float  | `1.0`       | How often to query obstacle detectors, in Hz. Higher values detect obstacles sooner but use more CPU and camera bandwidth.                                                                                                                                         |
+| `obstacle_detectors`            | array  | `[]`        | List of vision service and camera pairs for obstacle detection. See [Obstacle detectors](#obstacle-detectors).                                                                                                                                                     |
+| `obstacles`                     | array  | `[]`        | Static obstacles the robot should avoid, defined as geographic geometries. These are fixed locations on the map (buildings, ponds, restricted areas). Configure these through the visual editor in the Viam app's configure tab.                                   |
+| `bounding_regions`              | array  | `[]`        | Geographic regions the robot must stay within (geofences). If configured, the robot will not navigate outside these boundaries. Define these as geographic geometries.                                                                                             |
+| `log_file_path`                 | string | `""`        | Path to a file for navigation debug logging. When set, all navigation service logging (mode transitions, waypoint attempts, obstacle detections, frame transformations) is written to this file. Useful for debugging navigation behavior in the field.            |
+
+## Store configuration
+
+The `store` object configures where waypoints are persisted.
+
+| Field  | Type   | Description                          |
+| ------ | ------ | ------------------------------------ |
+| `type` | string | `"memory"` (default) or `"mongodb"`. |
+
+**Memory store** keeps waypoints in RAM. Simple, no dependencies, works
+for development and single-session deployments. Waypoints are lost when
+`viam-server` restarts.
+
+**MongoDB store** persists waypoints to a MongoDB database. Waypoints
+survive restarts. Requires a MongoDB server accessible from the machine.
+Add a `config` object with your MongoDB connection details:
+
+```json
+{
+  "type": "mongodb",
+  "config": {
+    "uri": "mongodb://127.0.0.1:27017"
+  }
+}
+```
+
+## Obstacle detectors
+
+Each obstacle detector pairs a [vision service](/vision/configure/) with a
+[camera](/hardware/common-components/add-a-camera/). The vision service
+analyzes frames from the camera and reports detected obstacles. The
+navigation service transforms these detections into geographic coordinates
+and feeds them to the path planner.
+
+You can configure multiple detectors. Each one contributes obstacles
+independently. For example, use a forward-facing camera for path obstacles
+and a downward-facing camera for terrain hazards.
+
+```json
+{
+  "obstacle_detectors": [
+    {
+      "vision_service": "obstacle-detector",
+      "camera": "front-cam"
+    },
+    {
+      "vision_service": "terrain-classifier",
+      "camera": "down-cam"
+    }
+  ]
+}
+```
+
+## Full example
+
+```json
+{
+  "name": "my-nav",
+  "api": "rdk:service:navigation",
+  "model": "builtin",
+  "attributes": {
+    "base": "my-base",
+    "movement_sensor": "my-gps",
+    "map_type": "GPS",
+    "store": {
+      "type": "memory"
+    },
+    "meters_per_sec": 0.5,
+    "degs_per_sec": 30,
+    "plan_deviation_m": 5.0,
+    "position_polling_frequency_hz": 2,
+    "obstacle_polling_frequency_hz": 2,
+    "obstacle_detectors": [
+      {
+        "vision_service": "obstacle-detector",
+        "camera": "front-cam"
+      }
+    ]
+  }
+}
+```
+
+## What's next
+
+- [Navigate to a waypoint](/navigation/how-to/navigate-to-waypoint/):
+  set up the navigation service and send your robot to a GPS coordinate.
+- [Tune navigation behavior](/navigation/how-to/tune-navigation/):
+  adjust speeds, deviation threshold, and polling for your environment.
+- [Navigation API](/navigation/reference/api/): full method reference.
diff --git a/docs/operate/_index.md b/docs/operate/_index.md
index 81f9881f66..df7ce3a6ad 100644
--- a/docs/operate/_index.md
+++ b/docs/operate/_index.md
@@ -3,6 +3,7 @@ linkTitle: "Build and Integrate"
 title: "Build and Integrate"
 weight: 150
 layout: "docs"
+toc_hide: true
 type: "docs"
 no_list: true
 noedit: true
diff --git a/docs/operate/control/api-keys.md b/docs/operate/control/api-keys.md
index d89bfc181d..8e6a708765 100644
--- a/docs/operate/control/api-keys.md
+++ b/docs/operate/control/api-keys.md
@@ -51,4 +51,4 @@ If you ever need to rotate an API key you can use the web UI:
 1. Find the old API key on the page and click on **Show details**.
 1. Then click **Remove API key**.
 
-Alternatively, you can use the [`RotateKey`](/dev/reference/apis/fleet/#rotatekey) API method.
+Alternatively, you can use the [`RotateKey`](/reference/apis/fleet/#rotatekey) API method.
diff --git a/docs/operate/control/headless-app.md b/docs/operate/control/headless-app.md
index 95be5f56db..27d3bc5361 100644
--- a/docs/operate/control/headless-app.md
+++ b/docs/operate/control/headless-app.md
@@ -32,7 +32,7 @@ We recommend running your code on a laptop, desktop, or server if:
 - You are using computationally-intensive programs involving, for example, computer vision or motion planning, and
 - You have a stable internet connection
 
-The client code will establish a connection to the instance of `viam-server` on your machine's SBC over [LAN or WAN](/dev/reference/sdks/connectivity/).
+The client code will establish a connection to the instance of `viam-server` on your machine's SBC over [LAN or WAN](/reference/sdks/connectivity/).
 
 ### On the machine itself
 
@@ -49,7 +49,7 @@ Install your preferred Viam SDK on the computer or SBC where you plan to run the
 {{< tabs >}}
 {{% tab name="Python" %}}
 
-If you are using the Python SDK, [set up a virtual environment](/dev/reference/sdks/python/python-venv/) to package the SDK inside before running your code, avoiding conflicts with other projects or your system.
+If you are using the Python SDK, [set up a virtual environment](/reference/sdks/python/python-venv/) to package the SDK inside before running your code, avoiding conflicts with other projects or your system.
 
 For macOS (both Intel `x86_64` and Apple Silicon) or Linux (`x86`, `aarch64`, `armv6l`), run the following commands:
 
@@ -63,7 +63,7 @@ Windows is not supported.
 If you are using Windows, use the [Windows Subsystem for Linux (WSL)](https://learn.microsoft.com/en-us/windows/wsl/install) and install the Python SDK using the preceding instructions for Linux.
 For other unsupported systems, see [Installing from source](https://python.viam.dev/#installing-from-source).
 
-If you intend to use the [ML (machine learning) model service](/data-ai/ai/deploy/), use the following command instead, which installs additional required dependencies along with the Python SDK:
+If you intend to use the [ML (machine learning) model service](/vision/configure/), use the following command instead, which installs additional required dependencies along with the Python SDK:
 
 ```sh {class="command-line" data-prompt="$"}
 pip install 'viam-sdk[mlmodel]'
@@ -93,15 +93,15 @@ Select your preferred **Language** to display a code snippet, with connection co
 
 You can use the toggle to include the machine API key and API key ID, though we strongly recommend storing your API keys in environment variables to reduce the risk of accidentally sharing your API key and granting access to your machines.
 
-If your code will connect to multiple machines or use [Platform APIs](/dev/reference/apis/#platform-apis) you can create an API key with broader access.
+If your code will connect to multiple machines or use [Platform APIs](/reference/apis/#platform-apis) you can create an API key with broader access.
 
 ## Write your control code
 
-For API reference including code snippets for each method, see [Viam's Client APIs](/dev/reference/apis/).
+For API reference including code snippets for each method, see [Viam's Client APIs](/reference/apis/).
 
 {{< expand "Example code for moving a rover in a square" >}}
 
-The following code moves a mobile robot base in a square using the [base API](/dev/reference/apis/components/base/).
+The following code moves a mobile robot base in a square using the [base API](/reference/apis/components/base/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -288,7 +288,7 @@ int main() {
 
 {{< expand "Example Python code for turning on a fan based on sensor readings" >}}
 
-The following example from [Automate air filtration with air quality sensors](https://codelabs.viam.com/guide/air-quality/index.html?index=..%2F..index#0) uses both the sensor API's [GetReadings](/dev/reference/apis/components/sensor/#getreadings) command as well as custom functionality with the generic [DoCommand](/dev/reference/apis/components/generic/#docommand).
+The following example from [Automate air filtration with air quality sensors](https://codelabs.viam.com/guide/air-quality/index.html?index=..%2F..index#0) uses both the sensor API's [GetReadings](/reference/apis/components/sensor/#getreadings) command as well as custom functionality with the generic [DoCommand](/reference/apis/components/generic/#docommand).
 
 ```python {class="line-numbers linkable-line-numbers"}
 import asyncio
diff --git a/docs/operate/control/mobile-app.md b/docs/operate/control/mobile-app.md
index e76e6cc4db..2606ce0618 100644
--- a/docs/operate/control/mobile-app.md
+++ b/docs/operate/control/mobile-app.md
@@ -29,7 +29,7 @@ Select **Flutter** to display a code snippet with connection code as well as som
 
 You can use the toggle to include the machine API key and API key ID, though we strongly recommend storing your API keys in environment variables to reduce the risk of accidentally sharing your API key and granting access to your machines.
 
-If your code will connect to multiple machines or use [Platform APIs](/dev/reference/apis/#platform-apis) you can create an API key with broader access.
+If your code will connect to multiple machines or use [Platform APIs](/reference/apis/#platform-apis) you can create an API key with broader access.
 
 ## Write your app
 
diff --git a/docs/operate/control/sdks.md b/docs/operate/control/sdks.md
index 4693237bae..201a8db661 100644
--- a/docs/operate/control/sdks.md
+++ b/docs/operate/control/sdks.md
@@ -4,5 +4,5 @@ linkTitle: "SDKs"
 weight: 40
 type: "docs"
 layout: "empty"
-canonical: "/dev/reference/sdks/"
+canonical: "/reference/sdks/"
 ---
diff --git a/docs/operate/control/web-app.md b/docs/operate/control/web-app.md
index b118216951..415cf7d1f2 100644
--- a/docs/operate/control/web-app.md
+++ b/docs/operate/control/web-app.md
@@ -33,7 +33,7 @@ Select **TypeScript** to display a code snippet, with connection code as well as
 
 You can use the toggle to include the machine API key and API key ID, though we strongly recommend storing your API keys in environment variables to reduce the risk of accidentally sharing your API key and granting access to your machines.
 
-If your code will connect to multiple machines or use [Platform APIs](/dev/reference/apis/#platform-apis) you can create an API key with broader access.
+If your code will connect to multiple machines or use [Platform APIs](/reference/apis/#platform-apis) you can create an API key with broader access.
 
 ## Write your app
 
diff --git a/docs/operate/hello-world/building.md b/docs/operate/hello-world/building.md
index b24f3e8014..28682a8138 100644
--- a/docs/operate/hello-world/building.md
+++ b/docs/operate/hello-world/building.md
@@ -55,22 +55,22 @@ To start with the minimum amount of hardware, begin with one robotic arm, one en
 <p>Review the following list of components and consider which components you may need. If in doubt, click on the component to review its API to understand what the component does.</p>
 
 {{< cards >}}
-{{% relatedcard link="/dev/reference/apis/components/arm/" highlight="green" %}}
-{{% relatedcard link="/dev/reference/apis/components/base/" %}}
-{{% relatedcard link="/dev/reference/apis/components/board/" %}}
-{{% relatedcard link="/dev/reference/apis/components/button/" %}}
-{{% relatedcard link="/dev/reference/apis/components/camera/" highlight="green" %}}
-{{% relatedcard link="/dev/reference/apis/components/encoder/" %}}
-{{% relatedcard link="/dev/reference/apis/components/gantry/" %}}
-{{% relatedcard link="/dev/reference/apis/components/generic/" %}}
-{{% relatedcard link="/dev/reference/apis/components/gripper/" highlight="green" %}}
-{{% relatedcard link="/dev/reference/apis/components/input-controller/" %}}
-{{% relatedcard link="/dev/reference/apis/components/motor/" %}}
-{{% relatedcard link="/dev/reference/apis/components/movement-sensor/" %}}
-{{% relatedcard link="/dev/reference/apis/components/power-sensor/" %}}
-{{% relatedcard link="/dev/reference/apis/components/sensor/" %}}
-{{% relatedcard link="/dev/reference/apis/components/servo/" %}}
-{{% relatedcard link="/dev/reference/apis/components/switch/" %}}
+{{% relatedcard link="/reference/apis/components/arm/" highlight="green" %}}
+{{% relatedcard link="/reference/apis/components/base/" %}}
+{{% relatedcard link="/reference/apis/components/board/" %}}
+{{% relatedcard link="/reference/apis/components/button/" %}}
+{{% relatedcard link="/reference/apis/components/camera/" highlight="green" %}}
+{{% relatedcard link="/reference/apis/components/encoder/" %}}
+{{% relatedcard link="/reference/apis/components/gantry/" %}}
+{{% relatedcard link="/reference/apis/components/generic/" %}}
+{{% relatedcard link="/reference/apis/components/gripper/" highlight="green" %}}
+{{% relatedcard link="/reference/apis/components/input-controller/" %}}
+{{% relatedcard link="/reference/apis/components/motor/" %}}
+{{% relatedcard link="/reference/apis/components/movement-sensor/" %}}
+{{% relatedcard link="/reference/apis/components/power-sensor/" %}}
+{{% relatedcard link="/reference/apis/components/sensor/" %}}
+{{% relatedcard link="/reference/apis/components/servo/" %}}
+{{% relatedcard link="/reference/apis/components/switch/" %}}
 {{< /cards >}}
 
 <p><b>Wood sanding project:</b>
@@ -106,14 +106,14 @@ Services often operate on components.</p>
 <p>Review the following list of services and consider which services you may need. If in doubt, click on the service to review its API to understand what the service does.</p>
 
 {{< cards >}}
-{{% relatedcard link="/dev/reference/apis/services/data/" %}}
-{{% relatedcard link="/dev/reference/apis/services/ml/" highlight="green" %}}
-{{% relatedcard link="/dev/reference/apis/services/vision/" highlight="green" %}}
-{{% relatedcard link="/dev/reference/apis/services/motion/" highlight="green" %}}
-{{% relatedcard link="/dev/reference/apis/services/navigation/" %}}
-{{% relatedcard link="/dev/reference/apis/services/slam/" %}}
-{{% relatedcard link="/dev/reference/apis/services/generic/" %}}
-{{% relatedcard link="/dev/reference/apis/services/base-rc/" %}}
+{{% relatedcard link="/reference/apis/services/data/" %}}
+{{% relatedcard link="/reference/apis/services/ml/" highlight="green" %}}
+{{% relatedcard link="/reference/apis/services/vision/" highlight="green" %}}
+{{% relatedcard link="/reference/apis/services/motion/" highlight="green" %}}
+{{% relatedcard link="/reference/apis/services/navigation/" %}}
+{{% relatedcard link="/reference/apis/services/slam/" %}}
+{{% relatedcard link="/reference/apis/services/generic/" %}}
+{{% relatedcard link="/reference/apis/services/base-rc/" %}}
 {{< /cards >}}
 
 <p><strong>Wood sanding project:</strong> For the software side, you'll want something to identify the areas to sand.
@@ -161,112 +161,112 @@ You can search all the available components in the Viam web UI when adding resou
 {{% /tab %}}
 {{% tab name="Arm" %}}
 
-The following models implement the [arm component API](/dev/reference/apis/components/arm/):
+The following models implement the [arm component API](/reference/apis/components/arm/):
 
 {{<resources api="rdk:component:arm" type="arm" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Base" %}}
 
-The following models implement the [base component API](/dev/reference/apis/components/base/):
+The following models implement the [base component API](/reference/apis/components/base/):
 
 {{<resources api="rdk:component:base" type="base" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Board" %}}
 
-The following models implement the [board component API](/dev/reference/apis/components/board/):
+The following models implement the [board component API](/reference/apis/components/board/):
 
 {{<resources api="rdk:component:board" type="board" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Button" %}}
 
-The following models implement the [button component API](/dev/reference/apis/components/button/):
+The following models implement the [button component API](/reference/apis/components/button/):
 
 {{<resources api="rdk:component:button" type="button" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Camera" %}}
 
-The following models implement the [camera component API](/dev/reference/apis/components/camera/):
+The following models implement the [camera component API](/reference/apis/components/camera/):
 
 {{<resources api="rdk:component:camera" type="camera" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Encoder" %}}
 
-The following models implement the [encoder component API](/dev/reference/apis/components/encoder/):
+The following models implement the [encoder component API](/reference/apis/components/encoder/):
 
 {{<resources api="rdk:component:encoder" type="encoder" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Gantry" %}}
 
-The following models implement the [gantry component API](/dev/reference/apis/components/gantry/):
+The following models implement the [gantry component API](/reference/apis/components/gantry/):
 
 {{<resources api="rdk:component:gantry" type="gantry" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Generic" %}}
 
-The following models implement the [generic component API](/dev/reference/apis/components/generic/):
+The following models implement the [generic component API](/reference/apis/components/generic/):
 
 {{<resources api="rdk:component:generic" type="generic" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Gripper" %}}
 
-The following models implement the [gripper component API](/dev/reference/apis/components/gripper/):
+The following models implement the [gripper component API](/reference/apis/components/gripper/):
 
 {{<resources api="rdk:component:gripper" type="gripper" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Input Controller" %}}
 
-The following models implement the [input controller component API](/dev/reference/apis/components/input-controller/):
+The following models implement the [input controller component API](/reference/apis/components/input-controller/):
 
 {{<resources api="rdk:component:input_controller" type="input_controller" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Motor" %}}
 
-The following models implement the [motor component API](/dev/reference/apis/components/motor/):
+The following models implement the [motor component API](/reference/apis/components/motor/):
 
 {{<resources api="rdk:component:motor" type="motor" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Movement Sensor" %}}
 
-The following models implement the [movement sensor component API](/dev/reference/apis/components/movement-sensor/):
+The following models implement the [movement sensor component API](/reference/apis/components/movement-sensor/):
 
 {{<resources api="rdk:component:movement_sensor" type="movement_sensor" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Power Sensor" %}}
 
-The following models implement the [power sensor component API](/dev/reference/apis/components/power-sensor/):
+The following models implement the [power sensor component API](/reference/apis/components/power-sensor/):
 
 {{<resources api="rdk:component:power_sensor" type="power_sensor" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Sensor" %}}
 
-The following models implement the [sensor component API](/dev/reference/apis/components/sensor/):
+The following models implement the [sensor component API](/reference/apis/components/sensor/):
 
 {{<resources api="rdk:component:sensor" type="sensor" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Servo" %}}
 
-The following models implement the [servo component API](/dev/reference/apis/components/servo/):
+The following models implement the [servo component API](/reference/apis/components/servo/):
 
 {{<resources api="rdk:component:servo" type="servo" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Switch" %}}
 
-The following models implement the [switch component API](/dev/reference/apis/components/switch/):
+The following models implement the [switch component API](/reference/apis/components/switch/):
 
 {{<resources api="rdk:component:switch" type="switch" no-intro="true">}}
 
@@ -305,8 +305,8 @@ To mock the resources you don't have hardware for or which you can't find existi
 We recommend consulting the docs for each service that might be helpful for your project and checking for suitable models and usage information.
 Then configure the service and test it.
 
-- [**Data management**](/data-ai/capture-data/capture-sync/): Capture, store, and sync data
-- [**Vision**](/data-ai/ai/run-inference/#using-a-vision-service) and [**ML model**](/data-ai/ai/deploy/): Detect objects, classify images, or track movement in camera streams
+- [**Data management**](/data/capture-sync/capture-and-sync-data/): Capture, store, and sync data
+- [**Vision**](/vision/detect/#using-a-vision-service) and [**ML model**](/vision/configure/): Detect objects, classify images, or track movement in camera streams
 - [**Motion**](/operate/mobility/motion-concepts/) and [**Frame system**](/operate/reference/services/frame-system/#configuration): Plan and execute complex movements
 - [**Navigation**](/operate/reference/services/navigation/): Help machines move autonomously
 - [**SLAM (Simultaneous Localization and Mapping)**](/operate/reference/services/slam/): Create maps of surroundings and locate machines within those maps
@@ -494,7 +494,7 @@ If you intend to ship machines, Viam provides the following features:
 - [**Provisioning**](/manage/fleet/provision/setup/): ship machines with a preconfigured setup so customers can connect them to the internet and get them up and running
 - [**Remote monitoring**](/manage/troubleshoot/monitor/): monitor, operate, and troubleshoot machines from anywhere in the world
 - [**Machine settings**](/manage/fleet/system-settings/): manage operating system package updates, network configuration, and system-level logging
-- [**Billing**](/manage/manage/white-labeled-billing/): bill customers for usage through the Viam platform
+- [**Billing**](/organization/white-labeled-billing/): bill customers for usage through the Viam platform
 
 **Wood sanding project:**
 A sanding project might be bespoke enough that you will install it for your customers, so you may not require provisioning.
diff --git a/docs/operate/hello-world/first-project/part-1.md b/docs/operate/hello-world/first-project/part-1.md
index daa106d2ba..f51a87573b 100644
--- a/docs/operate/hello-world/first-project/part-1.md
+++ b/docs/operate/hello-world/first-project/part-1.md
@@ -17,18 +17,18 @@ date: "2025-01-30"
 ## Prerequisites
 
 Before starting this tutorial, you need the can inspection simulation running.
-Follow the **[Gazebo Simulation Setup Guide](../gazebo-setup/)** to:
+Follow the **[Simulation Setup Guide](../sim-setup/)** to:
 
-1. Build the Docker image with Gazebo Harmonic
+1. Boot a simulation environment on Viam's cloud
 2. Create a machine in Viam and get credentials
 3. Start the container with your Viam credentials
 
 Once you see "Can Inspection Simulation Running!" in the container logs and your machine shows **Live** in the Viam app, return here to continue.
 
 {{< alert title="What you're working with" color="info" >}}
-The simulation runs Gazebo Harmonic inside a Docker container.
+The simulation runs Gazebo Harmonic inside a sandbox.
 It simulates a conveyor belt with cans (some dented) passing under an inspection camera.
-viam-server runs on the Linux virtual machine inside the container and connects to Viam's cloud, just like it would on a physical machine.
+viam-server runs inside the sandbox and connects to Viam's cloud, just like it would on a physical machine.
 Everything you configure in the Viam app applies to the simulated hardware.
 {{< /alert >}}
 
@@ -131,7 +131,7 @@ You'll configure two services:
 1. Click **+** next to your machine part
 2. Select **Configuration block**
 3. Search for `tflite`
-4. Select `tflight_cpu/tflight_cpu`
+4. Select `tflite_cpu/tflite_cpu`
 5. Click **Add component**
 6. Name it `model-service`
 7. Click **Add component**
@@ -176,7 +176,7 @@ Now add a vision service that connects your camera to the ML model service.
 1. Select the `vision-service` service in your machine's configuration
 2. Find the **ML Model** dropdown and select `model-service` (the ML model service you just created)
 3. Find the **Default Camera** dropdown and select `inspection-cam`
-4. Find the **Attributes** section and set **Minimum confidence threshold** to 0.75
+4. In the **Attributes** section, set **Minimum confidence threshold** to 0.75
 5. Click **Save** in the upper right corner
 
 {{<imgproc src="/tutorials/first-project/vision-service-config.png" resize="x1100" declaredimensions=true alt="Vision service configuration panel showing ML Model set to model-service, Default Camera set to inspection-cam, and confidence threshold at 0.75." class="imgzoom shadow">}}
diff --git a/docs/operate/hello-world/first-project/gazebo-setup.md b/docs/operate/hello-world/first-project/sim-setup.md
similarity index 73%
rename from docs/operate/hello-world/first-project/gazebo-setup.md
rename to docs/operate/hello-world/first-project/sim-setup.md
index ac6a12593d..2a11fcd0e6 100644
--- a/docs/operate/hello-world/first-project/gazebo-setup.md
+++ b/docs/operate/hello-world/first-project/sim-setup.md
@@ -1,47 +1,34 @@
 ---
-linkTitle: "Gazebo Simulation Setup"
-title: "Gazebo Simulation Setup"
+linkTitle: "Simulation Setup"
+title: "Simulation Setup"
 weight: 100
 layout: "docs"
 type: "docs"
-description: "Set up the Gazebo simulation environment for the inspection tutorial."
+description: "Set up the hosted simulation environment for the inspection tutorial."
 date: "2025-01-30"
+aliases:
+  - gazebo-setup
 ---
 
 This guide walks you through setting up the Gazebo simulation used in the [Your First Project](../) tutorial.
 
-## Prerequisites
+## Step 1: Start a Simulation Environment
 
-- **Docker Desktop** installed and running
-- ~5GB disk space for the Docker image
+Visit [cans.viam-labs.com](https://cans.viam-labs.com), and follow the prompts to log in. Wait for your instance to start.
 
-## Step 1: Pull the Docker Image
+{{< alert title="Note" color="note" >}}
+The simulation session has a 1 hour time limit, but can be extended. Watch the session time in the top toolbar.
+{{< /alert >}}
 
-The simulation runs in a Docker container with Gazebo Harmonic and viam-server pre-installed.
+## Step 2: Verify the Simulation
 
-```bash
-docker pull ghcr.io/viamrobotics/can-inspection-simulation:latest-local
-```
-
-This downloads the pre-built image, which takes about a minute depending on your internet connection.
-
-## Step 2: Start the Container
-
-```bash
-docker run --name gz-station1 -d \
-  -p 8080:8080 -p 8081:8081 -p 8443:8443 \
-  ghcr.io/viamrobotics/can-inspection-simulation:latest-local
-```
-
-## Step 3: Verify the Simulation
-
-Open your browser to `http://localhost:8081`
-
-You should see two live camera feeds from the inspection station:
+When your instance is finished starting, you should see two live camera feeds from the inspection station:
 
 {{<imgproc src="/tutorials/first-project/sim-viewer.png" resize="x1100" declaredimensions=true alt="Simulation web viewer showing the Can Inspection Station with Overview Camera and Inspection Camera feeds." class="imgzoom shadow">}}
 
-## Step 4: Create a Machine in Viam
+If the camera feeds every go dark or stops responding, try refreshing the page or press <kbd>Ctrl</kbd>+<kbd>R</kbd>.
+
+## Step 3: Create a Machine in Viam
 
 1. Go to [app.viam.com](https://app.viam.com) and create a free account or log in
 2. Click the **Locations** tab
@@ -49,7 +36,7 @@ You should see two live camera feeds from the inspection station:
 
    {{<imgproc src="/tutorials/first-project/fleet-add-machine.png" resize="x1100" declaredimensions=true alt="Viam app Fleet page showing First Location with no machines and the Add machine button." class="imgzoom shadow">}}
 
-## Step 5: Configure Machine Credentials
+## Step 4: Configure Machine Credentials
 
 1. In the Viam app, click the **Awaiting setup** button on your new machine and click **Machine cloud credentials** to copy the credentials JSON
 
@@ -67,7 +54,7 @@ You should see two live camera feeds from the inspection station:
 
    {{<imgproc src="/tutorials/first-project/sim-config-running.png" resize="x1100" declaredimensions=true alt="Simulation configuration page after restart, showing a green 'Configuration updated successfully' banner and Viam Server Status: Running." class="imgzoom shadow">}}
 
-## Step 6: Verify Machine Connection
+## Step 5: Verify Machine Connection
 
 Go back to your machine's page in the Viam app.
 The status indicator should now show **Live**.
diff --git a/docs/operate/hello-world/tutorial-desk-safari.md b/docs/operate/hello-world/tutorial-desk-safari.md
index 8c5bdcc1a7..be93671b1d 100644
--- a/docs/operate/hello-world/tutorial-desk-safari.md
+++ b/docs/operate/hello-world/tutorial-desk-safari.md
@@ -169,9 +169,9 @@ Let's configure all these:
 {{% tablestep start=1 %}}
 **Add multiple resources in one step.**
 
-On the **CONFIGURE** tab, click the **+** icon next to your machine part in the left-hand menu and select **Insert fragment**.
-Select the `HelloWorldMLResources` fragment by the `Robot Land` organization.
-Click **Insert fragment**.
+On the **CONFIGURE** tab, click **+** and select **Configuration block**.
+Search for `HelloWorldMLResources` by the `Robot Land` organization and select it.
+Click **Add fragment**, then click **Add fragment** again to confirm.
 This adds a vision service named `object-detector` and a model for it.
 Save your config.
 
@@ -759,8 +759,8 @@ You can use these tools to **build any kind of machine** with Viam.
 If you want to continue working on your game, consider:
 
 - Building your own [Viam application, mobile app, or headless app.](/operate/control/viam-applications/)
-- Taking photos when an item is successfully detected by [capturing data from your machines](/data-ai/capture-data/capture-sync/)
-- [Training your own TF or TFLite model](/data-ai/train/train-tf-tflite/) to recognize more or other items
+- Taking photos when an item is successfully detected by [capturing data from your machines](/data/capture-sync/capture-and-sync-data/)
+- [Training your own TF or TFLite model](/train/train-a-model/) to recognize more or other items
 
 ## Troubleshooting
 
@@ -783,7 +783,7 @@ If you want to continue working on your game, consider:
 - Reduce the **Minimum confidence threshold** in the vision service's attributes and use the vision service's **TEST** panel to check if it would detect the item at a lower confidence threshold.
   If so, keep the lower value and update your value to also use the lower threshold instead of `0.5`.
 - If you cannot get the item to be recognized, the model may not work well enough.
-  Remove it from the `POSSIBLE_OPTIONS` or [train your own model](/data-ai/train/train-tf-tflite/).
+  Remove it from the `POSSIBLE_OPTIONS` or [train your own model](/train/train-a-model/).
 
 ### Job or game logic not running
 
diff --git a/docs/operate/install/setup-micro/micro-troubleshooting.md b/docs/operate/install/setup-micro/micro-troubleshooting.md
index 0db8d59b64..8e629533de 100644
--- a/docs/operate/install/setup-micro/micro-troubleshooting.md
+++ b/docs/operate/install/setup-micro/micro-troubleshooting.md
@@ -92,7 +92,7 @@ espflash write-bin 0x0 target/esp32-server.bin -B 460800  && sleep 2 && espflash
 
 ### Unstable connection
 
-Because microcontrollers are more resource-constrained than single-board computers or other computers, when you run [control code](/dev/reference/sdks/) to control your Micro-RDK machine, you may experience instability.
+Because microcontrollers are more resource-constrained than single-board computers or other computers, when you run [control code](/reference/sdks/) to control your Micro-RDK machine, you may experience instability.
 If your connection is unstable, we recommend changing the default settings by making the following changes to your connection code.
 This code will disable the SDK background task that monitors the connection to your machine, reducing processing demands and improving the reliability of connection establishment.
 
diff --git a/docs/operate/mobility/move-arm/arm-motion.md b/docs/operate/mobility/move-arm/arm-motion.md
index 805403ca89..f3375b79c6 100644
--- a/docs/operate/mobility/move-arm/arm-motion.md
+++ b/docs/operate/mobility/move-arm/arm-motion.md
@@ -17,7 +17,7 @@ date: "2025-05-21"
 
 This is the recommended way to write an application to move an arm.
 
-The [motion service API](/dev/reference/apis/services/motion/) allows you to plan and execute complex movements while avoiding collisions between components and obstacles.
+The [motion service API](/reference/apis/services/motion/) allows you to plan and execute complex movements while avoiding collisions between components and obstacles.
 
 ## Prerequisites
 
@@ -49,7 +49,7 @@ See [Configure an arm](/operate/mobility/move-arm/configure-arm/) for instructio
 1. Choose your programming language.
    The examples below are written in Python and Go, so choose one of those to follow along.
 
-1. Toggle **Include API key**.
+1. Select **API keys** and copy your **API key** and **API key ID**.
 
 1. Copy and paste the connection code into a file on your machine, for example `move_arm.py` or `move_arm.go`.
 
@@ -280,7 +280,7 @@ You will pass your `WorldState` object to the motion planning API in the next se
 
 ## Move the arm
 
-To move the arm, use the motion service API's [`Move` method](/dev/reference/apis/services/motion/#move).
+To move the arm, use the motion service API's [`Move` method](/reference/apis/services/motion/#move).
 Follow the steps below to construct the necessary objects and pass them to `Move`.
 
 1. Construct a destination pose for the arm.
@@ -381,7 +381,7 @@ myConstraints := &motionplan.Constraints{
 {{% /tab %}}
 {{< /tabs >}}
 
-1. Call the [`Move` method](/dev/reference/apis/services/motion/#move), passing in the destination pose, any constraints, and the world state:
+1. Call the [`Move` method](/reference/apis/services/motion/#move), passing in the destination pose, any constraints, and the world state:
 
    {{< tabs >}}
    {{% tab name="Python" %}}
diff --git a/docs/operate/mobility/move-arm/configure-additional.md b/docs/operate/mobility/move-arm/configure-additional.md
index 9a0c34d01d..06f9f0ebd6 100644
--- a/docs/operate/mobility/move-arm/configure-additional.md
+++ b/docs/operate/mobility/move-arm/configure-additional.md
@@ -27,7 +27,7 @@ Configure the gripper's frame to describe its position and orientation relative
 
 1. In the **CONFIGURE** tab, find the gripper's configuration card.
 
-1. Click **+ Add frame**.
+1. Click the **Frame** button.
 
 1. Select the arm's frame as the parent frame.
 
@@ -65,7 +65,7 @@ Configure the gripper's frame to describe its position and orientation relative
 
    Some grippers have [kinematics files](/operate/reference/kinematic-chain-config/) that describe the position and orientation of the jaws of the gripper as they move, relative to the gripper's base.
    This file typically also contains geometries that represent the gripper's volume to avoid collisions between the gripper and its environment.
-   You can check whether your gripper has a kinematics file by looking in its module source code, or by using the [`GetKinematics` method](/dev/reference/apis/components/gripper/).
+   You can check whether your gripper has a kinematics file by looking in its module source code, or by using the [`GetKinematics` method](/reference/apis/components/gripper/).
 
    If you have a kinematics file, you do not need to add any geometries to the gripper's frame, assuming the gripper appears as expected in the **VISUALIZE** tab.
 
@@ -80,7 +80,7 @@ If you have a camera that can see the environment, configure the camera's frame
 
 1. In the **CONFIGURE** tab, find the camera's configuration card.
 
-1. Click **+ Add frame**.
+1. Click the **Frame** button.
 
 1. Edit the frame depending on where the camera is mounted:
 
@@ -114,7 +114,7 @@ If you have a passive object attached to the arm such as a camera mount, you wil
 
 1. Enter a name and click **Create**.
 
-1. Click **+ Add frame**.
+1. Click the **Frame** button.
 
 1. Set the parent frame to the name of the arm or gripper, depending on where the object is attached.
 
diff --git a/docs/operate/mobility/move-arm/configure-arm.md b/docs/operate/mobility/move-arm/configure-arm.md
index 2be3d105e2..0186ce2e89 100644
--- a/docs/operate/mobility/move-arm/configure-arm.md
+++ b/docs/operate/mobility/move-arm/configure-arm.md
@@ -44,7 +44,7 @@ For example, if you have a UFactory xArm 6, select the `xArm6` model.
 
 {{% expand "Click to view the available arm models" %}}
 
-The following models implement the [arm component API](/dev/reference/apis/components/arm/):
+The following models implement the [arm component API](/reference/apis/components/arm/):
 
 {{<resources api="rdk:component:arm" type="arm" no-intro="true">}}
 
diff --git a/docs/operate/mobility/move-arm/frame-how-to.md b/docs/operate/mobility/move-arm/frame-how-to.md
index caf2b91185..d0a1e1de3a 100644
--- a/docs/operate/mobility/move-arm/frame-how-to.md
+++ b/docs/operate/mobility/move-arm/frame-how-to.md
@@ -28,7 +28,7 @@ You define it implicitly by configuring the frame of a component relative to wor
 ### Add a frame to your arm
 
 1. Mount the arm in a fixed location.
-1. On your arm's configuration card, click **+ Add frame**.
+1. On your arm's configuration card, click the **Frame** button.
 1. The card will populate with the following default values:
 
    ```json {class="line-numbers linkable-line-numbers"}
diff --git a/docs/operate/mobility/move-base.md b/docs/operate/mobility/move-base.md
index a8f124cedd..41c9648463 100644
--- a/docs/operate/mobility/move-base.md
+++ b/docs/operate/mobility/move-base.md
@@ -12,9 +12,9 @@ aliases:
 
 You have three options for moving a mobile robot [base](/operate/reference/components/base/):
 
-- Give direct commands such as `Spin` and `MoveStraight` using the [base API](/dev/reference/apis/components/base/)
-- Send the base to a destination on a SLAM map or to a GPS coordinate using the [motion planning service API's](/dev/reference/apis/services/motion/) `MoveOnMap` or `MoveOnGlobe` commands, respectively
-- Define waypoints and move your base along those waypoints while avoiding obstacles, using the [navigation service API](/dev/reference/apis/services/navigation/)
+- Give direct commands such as `Spin` and `MoveStraight` using the [base API](/reference/apis/components/base/)
+- Send the base to a destination on a SLAM map or to a GPS coordinate using the [motion planning service API's](/reference/apis/services/motion/) `MoveOnMap` or `MoveOnGlobe` commands, respectively
+- Define waypoints and move your base along those waypoints while avoiding obstacles, using the [navigation service API](/reference/apis/services/navigation/)
 
 ## Prerequisites
 
@@ -175,9 +175,9 @@ func main() {
 
 ## Move your base using GPS
 
-To move a base component directly to a destination GPS point, you can use the motion service API's [`MoveOnGlobe`](/dev/reference/apis/services/motion/#moveonglobe) command.
+To move a base component directly to a destination GPS point, you can use the motion service API's [`MoveOnGlobe`](/reference/apis/services/motion/#moveonglobe) command.
 
-If you'd like to plan a more detailed path through a series of waypoints, use the [navigation service API](/dev/reference/apis/services/navigation/).
+If you'd like to plan a more detailed path through a series of waypoints, use the [navigation service API](/reference/apis/services/navigation/).
 The following tutorial demonstrates how to use GPS navigation with a robot base:
 
 {{< cards >}}
@@ -186,4 +186,4 @@ The following tutorial demonstrates how to use GPS navigation with a robot base:
 
 ## Move your base on a SLAM map
 
-To move a base component to a destination pose on a SLAM map, use the motion service API's [`MoveOnMap`](/dev/reference/apis/services/motion/#moveonmap) command.
+To move a base component to a destination pose on a SLAM map, use the motion service API's [`MoveOnMap`](/reference/apis/services/motion/#moveonmap) command.
diff --git a/docs/operate/mobility/move-gantry.md b/docs/operate/mobility/move-gantry.md
index 51852ae71f..d18dfbf278 100644
--- a/docs/operate/mobility/move-gantry.md
+++ b/docs/operate/mobility/move-gantry.md
@@ -9,8 +9,8 @@ description: "Move a gantry with linear actuator positions or automated motion p
 
 You have two options for moving a [gantry](/operate/reference/components/gantry/):
 
-- Move each axis of the gantry directly with the [gantry API](/dev/reference/apis/components/gantry/)
-- Use automated complex motion planning with the [motion planning service API](/dev/reference/apis/services/motion/)
+- Move each axis of the gantry directly with the [gantry API](/reference/apis/components/gantry/)
+- Use automated complex motion planning with the [motion planning service API](/reference/apis/services/motion/)
 
 ## Prerequisites
 
@@ -59,7 +59,7 @@ See [Create a web app](/operate/control/web-app/), [Create a mobile app](/operat
 ## Control each axis
 
 The following is an example Python script using the gantry API.
-For more methods and code snippets in more languages, see [Gantry API](/dev/reference/apis/components/gantry/).
+For more methods and code snippets in more languages, see [Gantry API](/reference/apis/components/gantry/).
 
 ```python {class="line-numbers linkable-line-numbers"}
 import asyncio
@@ -114,7 +114,7 @@ Before using the motion service with a gantry, you must [define your gantry's re
 {{% /alert %}}
 
 The following is an example Python script using the motion planning API.
-For more methods and code snippets in more languages, see [Motion API](/dev/reference/apis/services/motion/).
+For more methods and code snippets in more languages, see [Motion API](/reference/apis/services/motion/).
 
 ```python {class="line-numbers linkable-line-numbers"}
 import asyncio
diff --git a/docs/operate/mobility/use-input-to-act.md b/docs/operate/mobility/use-input-to-act.md
index 8bef48ca77..6a232e583c 100644
--- a/docs/operate/mobility/use-input-to-act.md
+++ b/docs/operate/mobility/use-input-to-act.md
@@ -39,7 +39,7 @@ Depending on your use case, see [Create a web app](/operate/control/web-app/), [
 {{% tablestep %}}
 **Get an input**
 
-Use one of the input APIs, such as a [sensor's](/dev/reference/apis/components/sensor/) `GetReadings` method:
+Use one of the input APIs, such as a [sensor's](/reference/apis/components/sensor/) `GetReadings` method:
 
 ```python {class="line-numbers linkable-line-numbers"}
 my_sensor = Sensor.from_robot(robot=machine, name='my_sensor')
@@ -48,12 +48,12 @@ my_sensor = Sensor.from_robot(robot=machine, name='my_sensor')
 readings = await my_sensor.get_readings()
 ```
 
-Other common inputs include the methods of a [board](/dev/reference/apis/components/board/) (`GetGPIO`, `GetPWM`, `PWMFrequency`, `GetDigitalInterruptValue`, and `ReadAnalogReader`), or a [power sensor](/dev/reference/apis/components/power-sensor/) (`GetVoltage`, `GetCurrent`, `GetPower`, and `GetReadings`).
+Other common inputs include the methods of a [board](/reference/apis/components/board/) (`GetGPIO`, `GetPWM`, `PWMFrequency`, `GetDigitalInterruptValue`, and `ReadAnalogReader`), or a [power sensor](/reference/apis/components/power-sensor/) (`GetVoltage`, `GetCurrent`, `GetPower`, and `GetReadings`).
 
 You can also use camera input, for example to detect objects and pick them up with an arm.
 See [Act based on inferences](/data-ai/ai/act/) for relevant examples.
 
-If you want to send alerts based on computer vision or captured data, see [Alert on inferences](/data-ai/ai/alert/) or [Alert on data](/data-ai/data/alert-data/).
+If you want to send alerts based on computer vision or captured data, see [Alert on inferences](/vision/alert-on-detections/) or [Alert on data](/data-ai/data/alert-data/).
 
 {{% /tablestep %}}
 {{% tablestep %}}
@@ -61,7 +61,7 @@ If you want to send alerts based on computer vision or captured data, see [Alert
 
 To move your actuator, use your actuator component's API, with logic based on your input.
 
-For example, use the [motor API's](/dev/reference/apis/components/motor/) which includes methods like `SetPower`, `SetRPM`, `GoFor`, `GoTo`, and `Stop`.
+For example, use the [motor API's](/reference/apis/components/motor/) which includes methods like `SetPower`, `SetRPM`, `GoFor`, `GoTo`, and `Stop`.
 A Python example:
 
 ```python {class="line-numbers linkable-line-numbers"}
@@ -76,10 +76,10 @@ else:
     await my_motor.stop()
 ```
 
-Other actuation methods include the [servo API's](/dev/reference/apis/components/servo/) `Move` method, the [gripper API's](/dev/reference/apis/components/gripper/) `Open`, `Grab`, and `Stop` methods, and the [board API's](/dev/reference/apis/components/board/) `SetGPIO`, `SetPWM`, `SetPWMFrequency`, and `WriteAnalog` methods.
+Other actuation methods include the [servo API's](/reference/apis/components/servo/) `Move` method, the [gripper API's](/reference/apis/components/gripper/) `Open`, `Grab`, and `Stop` methods, and the [board API's](/reference/apis/components/board/) `SetGPIO`, `SetPWM`, `SetPWMFrequency`, and `WriteAnalog` methods.
 
 If your use case involves planning coordinated motion of multiple motors, see [Move a base](/operate/mobility/move-base/), [Move an arm](/operate/mobility/move-arm/), or [Move a gantry](/operate/mobility/move-gantry/) for more information on how to automate intelligent motion planning.
-Instead of actuating using the component API, you can use the [motion service API](/dev/reference/apis/services/motion/)'s `Move`, `MoveOnMap`, or `MoveOnGlobe` commands.
+Instead of actuating using the component API, you can use the [motion service API](/reference/apis/services/motion/)'s `Move`, `MoveOnMap`, or `MoveOnGlobe` commands.
 
 {{% /tablestep %}}
 {{% /table %}}
diff --git a/docs/operate/modules/advanced/cpp-module.md b/docs/operate/modules/advanced/cpp-module.md
index ab7de9e693..2690a380f4 100644
--- a/docs/operate/modules/advanced/cpp-module.md
+++ b/docs/operate/modules/advanced/cpp-module.md
@@ -21,7 +21,7 @@ aliases:
 Viam provides built-in support for a variety of different {{< glossary_tooltip term_id="component" text="components" >}} and {{< glossary_tooltip term_id="service" text="services" >}}, as well as a registry full of {{< glossary_tooltip term_id="module" text="modules" >}} created by other users.
 If no [existing modules](/operate/modules/configure-modules/) support your specific use case, you can write your own custom modular {{< glossary_tooltip term_id="resource" text="resources" >}} by creating a module, and either upload it to the [registry](https://app.viam.com/registry) to share it publicly, or deploy it to your machine as a local module without uploading it to the registry.
 
-Follow the instructions below to learn how to write a new module using your preferred language and its corresponding [Viam SDK](/dev/reference/sdks/), and then deploy it to your machines.
+Follow the instructions below to learn how to write a new module using your preferred language and its corresponding [Viam SDK](/reference/sdks/), and then deploy it to your machines.
 
 {{< alert title="Note: viam-micro-server modules" color="note" >}}
 [`viam-micro-server`](/operate/reference/viam-micro-server/) works differently from the RDK (and `viam-server`), so creating modular resources for it is different from the process described on this page.
@@ -50,7 +50,7 @@ While you can certainly combine the resource model definition and the main progr
 
 ### Choose an API to implement in your model
 
-Look through the [component APIs](/dev/reference/apis/#component-apis) and [service API](/dev/reference/apis/#service-apis) and find the API that best fits your use case.
+Look through the [component APIs](/reference/apis/#component-apis) and [service API](/reference/apis/#service-apis) and find the API that best fits your use case.
 Each API contains various methods which you will need to define in your module:
 
 - One or more methods specific to that API, such as the servo component's `Move` and `GetPosition` methods.
@@ -59,8 +59,8 @@ Each API contains various methods which you will need to define in your module:
 
 {{< expand "Click for more guidance" >}}
 Think about what functionality you want your module to provide, what methods you need, and choose an API to implement accordingly.
-For example, the [sensor API](/dev/reference/apis/components/sensor/) has a `GetReadings` method, so if you create a module for a model of sensor, you'll need to write code to provide a response to the `GetReadings` method.
-If instead of just getting readings, you actually have an encoder and need to be able to reset the zero position, use the [encoder API](/dev/reference/apis/components/encoder/) so you can define functionality behind the `GetPosition` and `ResetPosition` methods.
+For example, the [sensor API](/reference/apis/components/sensor/) has a `GetReadings` method, so if you create a module for a model of sensor, you'll need to write code to provide a response to the `GetReadings` method.
+If instead of just getting readings, you actually have an encoder and need to be able to reset the zero position, use the [encoder API](/reference/apis/components/encoder/) so you can define functionality behind the `GetPosition` and `ResetPosition` methods.
 
 In addition to the list of methods, another reason to choose one API over another is how certain APIs fit into the Viam ecosystem.
 For example, though you could technically implement a GPS as a sensor with just the `GetReadings` method, if you implement it as a movement sensor then you have access to methods like `GetCompassHeading` which allow you to use your GPS module with the [navigation service](/operate/reference/services/navigation/).
@@ -168,10 +168,10 @@ Browse additional example modules by language:
 <!-- prettier-ignore -->
 | Module | Repository | Description |
 | ------ | ---------- | ----------- |
-| [berryimu](https://app.viam.com/module/viam-labs/berryimu) | [viam-labs/berry-imu](https://github.com/viam-labs/berry-imu) | Extends the built-in [movement sensor API](/dev/reference/apis/components/movement-sensor/) to support using the BerryIMU v3 accelerometer, gyroscope and magnetometer using an I2C connection on ARM64 systems. |
-| [oak](https://app.viam.com/module/viam/oak) | [viam-modules/viam-camera-oak](https://github.com/viam-modules/viam-camera-oak) | Extends the built-in [camera API](/dev/reference/apis/components/camera/) to support OAK cameras. |
+| [berryimu](https://app.viam.com/module/viam-labs/berryimu) | [viam-labs/berry-imu](https://github.com/viam-labs/berry-imu) | Extends the built-in [movement sensor API](/reference/apis/components/movement-sensor/) to support using the BerryIMU v3 accelerometer, gyroscope and magnetometer using an I2C connection on ARM64 systems. |
+| [oak](https://app.viam.com/module/viam/oak) | [viam-modules/viam-camera-oak](https://github.com/viam-modules/viam-camera-oak) | Extends the built-in [camera API](/reference/apis/components/camera/) to support OAK cameras. |
 | [odrive](https://app.viam.com/module/viam/odrive) | [viamrobotics/odrive](https://github.com/viamrobotics/odrive) | Extends the built-in [motor API](/operate/reference/components/motor/#api) to support the ODrive motor. This module provides two models, one for a `canbus`-connected ODrive motor, and one for a `serial`-connected ODrive motor. |
-| [yahboom](https://app.viam.com/module/rand/yahboom) | [viamlabs/yahboom](https://github.com/viam-labs/yahboom) | Extends the built-in [arm API](/dev/reference/apis/components/arm/) and [gripper API](/dev/reference/apis/components/gripper/) to support the Yahboom Dofbot robotic arm. |
+| [yahboom](https://app.viam.com/module/rand/yahboom) | [viamlabs/yahboom](https://github.com/viam-labs/yahboom) | Extends the built-in [arm API](/reference/apis/components/arm/) and [gripper API](/reference/apis/components/gripper/) to support the Yahboom Dofbot robotic arm. |
 
 For more Python module examples:
 
@@ -185,9 +185,9 @@ For more Python module examples:
 <!-- prettier-ignore -->
 | Module | Repository | Description |
 | ------ | ---------- | ----------- |
-| [agilex-limo](https://app.viam.com/module/viam/agilex-limo) | [viamlabs/agilex](https://github.com/viam-labs/agilex/) | Extends the built-in [base API](/dev/reference/apis/components/base/) to support the Agilex Limo base. |
-| [rplidar](https://app.viam.com/module/viam/rplidar) | [viamrobotics/rplidar](https://github.com/viamrobotics/rplidar) | Extends the built-in [camera API](/dev/reference/apis/components/camera/) to support several models of the SLAMTEC RPlidar. |
-| [filtered-camera](https://app.viam.com/module/erh/filtered-camera) | [erh/filtered_camera](https://github.com/erh/filtered_camera) | Extends the built-in [camera API](/dev/reference/apis/components/camera/) to enable filtering captured images by comparing to a defined ML model, and only syncing matching images to Viam. See the [filtered-camera guide](/data-ai/capture-data/filter-before-sync/) for more information. |
+| [agilex-limo](https://app.viam.com/module/viam/agilex-limo) | [viamlabs/agilex](https://github.com/viam-labs/agilex/) | Extends the built-in [base API](/reference/apis/components/base/) to support the Agilex Limo base. |
+| [rplidar](https://app.viam.com/module/viam/rplidar) | [viamrobotics/rplidar](https://github.com/viamrobotics/rplidar) | Extends the built-in [camera API](/reference/apis/components/camera/) to support several models of the SLAMTEC RPlidar. |
+| [filtered-camera](https://app.viam.com/module/erh/filtered-camera) | [erh/filtered_camera](https://github.com/erh/filtered_camera) | Extends the built-in [camera API](/reference/apis/components/camera/) to enable filtering captured images by comparing to a defined ML model, and only syncing matching images to Viam. See the [filtered-camera guide](/data-ai/capture-data/filter-before-sync/) for more information. |
 
 For more Go module examples:
 
@@ -200,7 +200,7 @@ For more Go module examples:
 <!-- prettier-ignore -->
 | Module | Repository | Description |
 | ------ | ---------- | ----------- |
-| [csi-cam](https://app.viam.com/module/viam/csi-cam) | [viamrobotics/csi-camera](https://github.com/viamrobotics/csi-camera/) | Extends the built-in [camera API](/dev/reference/apis/components/camera/) to support the Intel CSI camera. |
+| [csi-cam](https://app.viam.com/module/viam/csi-cam) | [viamrobotics/csi-camera](https://github.com/viamrobotics/csi-camera/) | Extends the built-in [camera API](/reference/apis/components/camera/) to support the Intel CSI camera. |
 <!-- | [module-example-cpp](https://app.viam.com/module/viam/module-example-cpp) | [viamrobotics/module-example-cpp](https://github.com/viamrobotics/module-example-cpp) | Extends the built-in [sensor API](/operate/reference/components/sensor/#api) to report wifi statistics. | -->
 
 {{% /tab %}}
@@ -430,7 +430,7 @@ For example, the `is_moving()` implementation in the example code above returns
 For more information on the base component API methods used in this example, see the following resources:
 
 - [Python SDK documentation for the `Base` class](https://python.viam.dev/autoapi/viam/components/base/index.html)
-- [Base API methods](/dev/reference/apis/components/base/)
+- [Base API methods](/reference/apis/components/base/)
 
 {{% /tab %}}
 {{% tab name="Go"%}}
@@ -674,7 +674,7 @@ This matches the `error` return type of the built-in `SetPower()` method as defi
 For more information on the base component API methods used in this example, see the following resources:
 
 - [Go SDK documentation for the `base` package](https://pkg.go.dev/go.viam.com/rdk/components/base#pkg-functions)
-- [Base API methods](/dev/reference/apis/components/base/)
+- [Base API methods](/reference/apis/components/base/)
 
 {{% /tab %}}
 {{% tab name="C++" %}}
@@ -909,7 +909,7 @@ For example, the `set_power()` implementation in the example code above returns
 For more information on the base component API methods used in these examples, see the following resources:
 
 - [C++ SDK documentation for the `Base` class](https://cpp.viam.dev/classviam_1_1sdk_1_1Base.html)
-- [Base API methods](/dev/reference/apis/components/base/)
+- [Base API methods](/reference/apis/components/base/)
 
 For more C++ module examples of varying complexity,see the [C++ SDK `examples` directory](https://github.com/viamrobotics/viam-cpp-sdk/tree/main/src/viam/examples/modules/).
 
@@ -1225,7 +1225,7 @@ When packaged in this fashion, you can run the resulting executable on your desi
 
 To create a packaged executable:
 
-1. First, [create a Python virtual environment](/dev/reference/sdks/python/python-venv/) in your module's directory to ensure your module has access to any required libraries.
+1. First, [create a Python virtual environment](/reference/sdks/python/python-venv/) in your module's directory to ensure your module has access to any required libraries.
    Be sure you are within your Python virtual environment for the rest of these steps: your terminal prompt should include the name of your virtual environment in parentheses.
 
 1. Create a `requirements.txt` file containing a list of all the dependencies your module requires.
@@ -1289,7 +1289,7 @@ If you get `"ImportError: attempted relative import with no known parent package
 In addition, PyInstaller does not support cross-compiling: you must compile your module on the target architecture you wish to support.
 For example, you cannot run a module on a Linux `arm64` system if you compiled it using PyInstaller on a Linux `amd64` system.
 Viam makes this easy to manage by providing a build system for modules.
-Follow [these instructions](/dev/tools/cli/#using-the-build-subcommand) to automatically build for each system your module can support using Viam's [CLI](/dev/tools/cli/).
+Follow [these instructions](/cli/#using-the-build-subcommand) to automatically build for each system your module can support using Viam's [CLI](/cli/).
 
 {{% /alert %}}
 
@@ -1335,7 +1335,7 @@ This is the recommended approach for modules written in Python:
 
 Using a virtual environment together with a `requirements.txt` file and a `run.sh` file that references it ensures that your module has access to any packages it requires during runtime.
 If you intend to share your module with other users, or to deploy it to a fleet of machines, this approach handles dependency resolution for each deployment automatically, meaning that there is no need to explicitly determine and install the Python packages your module requires to run on each machine that installs your module.
-See [prepare a Python virtual environment](/dev/reference/sdks/python/python-venv/) for more information.
+See [prepare a Python virtual environment](/reference/sdks/python/python-venv/) for more information.
 
 {{% /tab %}}
 {{% tab name="Python: nuitka" %}}
@@ -1344,7 +1344,7 @@ Use the [`nuitka` Python compiler](https://pypi.org/project/Nuitka/) to compile
 
 1. In order to use Nuitka, you must install a [supported C compiler](https://github.com/Nuitka/Nuitka#c-compiler) on your machine.
 
-1. Then, [create a Python virtual environment](/dev/reference/sdks/python/python-venv/) in your module's directory to ensure your module has access to any required libraries.
+1. Then, [create a Python virtual environment](/reference/sdks/python/python-venv/) in your module's directory to ensure your module has access to any required libraries.
    Be sure you are within your Python virtual environment for the rest of these steps: your terminal prompt should include the name of your virtual environment in parentheses.
 
 1. Create a `requirements.txt` file containing a list of all the dependencies your module requires.
@@ -1381,7 +1381,7 @@ If you intend to share your module with other users, or to deploy it to a fleet
 
 However, used in this manner, Nuitka does not support relative imports (imports starting with `.`).
 In addition, Nuitka does not support cross-compiling: you can only compile your module on the target architecture you wish to support if using the Nutika approach.
-If you want to cross-compile your module, consider using a different local compilation method, or the [`module build start` command](/dev/tools/cli/#using-the-build-subcommand) to build your module on a cloud build host, which supports building for multiple platforms.
+If you want to cross-compile your module, consider using a different local compilation method, or the [`module build start` command](/cli/#using-the-build-subcommand) to build your module on a cloud build host, which supports building for multiple platforms.
 For example, you cannot run a module on a Linux `arm64` system if you compiled it using Nuitka on a Linux `amd64` system.
 
 {{% /tab %}}
@@ -1540,7 +1540,7 @@ _Add troubleshooting notes here._
 ````md
 # [`agilex-limo` module](https://app.viam.com/module/viam/agilex-limo)
 
-This module implements the [`rdk:component:base` API](https://docs.viam.com/dev/reference/apis/components/base/) in an `agilex` model for the [AgileX LIMO](https://global.agilex.ai/products/limo-pro) base to be used with `viam-server`.
+This module implements the [`rdk:component:base` API](https://docs.viam.com/reference/apis/components/base/) in an `agilex` model for the [AgileX LIMO](https://global.agilex.ai/products/limo-pro) base to be used with `viam-server`.
 This driver supports differential, ackermann, and omni directional steering modes over the serial port.
 
 ## Configure your `agilex-limo` base
@@ -1591,7 +1591,7 @@ The following attributes are available for `viam:base:agilex-limo` bases:
 ## Next steps
 
 - To test your base, go to the [**CONTROL** tab](https://docs.viam.com/manage/troubleshoot/teleoperate/default-interface/).
-- To write code against your base, use one of the [available SDKs](https://docs.viam.com/dev/reference/sdks/).
+- To write code against your base, use one of the [available SDKs](https://docs.viam.com/reference/sdks/).
 - To view examples using a base component, explore [these tutorials](https://docs.viam.com/tutorials/).
 
 ## Local development
diff --git a/docs/operate/modules/advanced/dependencies.md b/docs/operate/modules/advanced/dependencies.md
index 3659ebc305..61638be025 100644
--- a/docs/operate/modules/advanced/dependencies.md
+++ b/docs/operate/modules/advanced/dependencies.md
@@ -396,7 +396,7 @@ For more information on capturing data only if conditions are met, see [Pet phot
 
 {{% hiddencontent %}}
 There is currently no SDK method to directly access configuration attributes of dependencies in Python or Go.
-However, you can use [`GetRobotPart`](/dev/reference/apis/fleet/#getrobotpart) to return information including the entire configuration of a machine part, and then access the configuration attributes of the dependency from there.
+However, you can use [`GetRobotPart`](/reference/apis/fleet/#getrobotpart) to return information including the entire configuration of a machine part, and then access the configuration attributes of the dependency from there.
 
 To learn how to use the Fleet management API from a module, see [Access platform APIs from within a module](/operate/modules/advanced/platform-apis/).
 {{% /hiddencontent %}}
diff --git a/docs/operate/modules/advanced/manage-modules.md b/docs/operate/modules/advanced/manage-modules.md
index e0bfd6b2c1..fec61f2c08 100644
--- a/docs/operate/modules/advanced/manage-modules.md
+++ b/docs/operate/modules/advanced/manage-modules.md
@@ -33,7 +33,7 @@ Once your module is in the [registry](https://app.viam.com/registry), there are
 
   - If you enabled cloud build when you generated your module, the GitHub Actions are already set up for you.
 
-- [Update manually](#update-manually) using the [Viam CLI](/dev/tools/cli/): Fine for small projects with one contributor.
+- [Update manually](#update-manually) using the [Viam CLI](/cli/): Fine for small projects with one contributor.
 
 ### Update automatically from a GitHub repo with cloud build
 
@@ -184,7 +184,7 @@ tar -czvf dist/archive.tar.gz ./dist/main
 
 {{< /expand >}}
 
-You can test this build configuration by running the Viam CLI's [`build local` command](/dev/tools/cli/#using-the-build-subcommand) on your development machine:
+You can test this build configuration by running the Viam CLI's [`build local` command](/cli/#using-the-build-subcommand) on your development machine:
 
 ```sh {class="command-line" data-prompt="$"}
 viam module build local
@@ -234,9 +234,9 @@ When you are ready to test the action, uncomment `if: github.event_name == 'rele
 
 For guidance on configuring the other parameters, see the documentation for each:
 
-- [`org-id`](/dev/tools/cli/#using-the---org-id-and---public-namespace-arguments): Not required if your module is public.
-- [`platform`](/dev/tools/cli/#using-the---platform-argument): You can only upload one platform at a time.
-- [`version`](https://github.com/viamrobotics/upload-module/blob/main/README.md#versioning): See [Using the --version argument](/dev/tools/cli/#using-the---version-argument) for more details on the types of versioning supported.
+- [`org-id`](/cli/#using-the---org-id-and---public-namespace-arguments): Not required if your module is public.
+- [`platform`](/cli/#using-the---platform-argument): You can only upload one platform at a time.
+- [`version`](https://github.com/viamrobotics/upload-module/blob/main/README.md#versioning): See [Using the --version argument](/cli/#using-the---version-argument) for more details on the types of versioning supported.
 
 For more details, see the [`upload-module` GitHub Action documentation](https://github.com/viamrobotics/upload-module), or take a look through one of the following example repositories that show how to package and deploy modules using the Viam SDKs:
 
@@ -248,7 +248,7 @@ For more details, see the [`upload-module` GitHub Action documentation](https://
   {{% /tab %}}
   {{< /tabs >}}
 
-3. [Create an organization API key](/dev/tools/cli/#create-an-organization-api-key) with owner role:
+3. [Create an organization API key](/cli/#create-an-organization-api-key) with owner role:
 
    ```sh {class="command-line" data-prompt="$"}
    viam organizations api-key create --org-id <org-id> --name <key-name>
@@ -283,7 +283,7 @@ While the registry supports additional platforms like `windows/amd64`, `linux/ar
 
 ### Update manually
 
-Use the [Viam CLI](/dev/tools/cli/) to manually update your module:
+Use the [Viam CLI](/cli/) to manually update your module:
 
 1. Edit your module code and update the [`meta.json`](/operate/modules/advanced/metajson/) file if needed.
    For example, if you've changed the module's functionality, update the description in the `meta.json` file.
@@ -304,9 +304,9 @@ Use the [Viam CLI](/dev/tools/cli/) to manually update your module:
 
    For example, `viam module upload --version 1.0.1 --platform darwin/arm64 my-module.tar.gz`.
 
-When you `upload` a module, the command performs basic [validation](/dev/tools/cli/#upload-validation) of your module to check for common errors.
+When you `upload` a module, the command performs basic [validation](/cli/#upload-validation) of your module to check for common errors.
 
-For more information, see the [`viam module` command](/dev/tools/cli/#module).
+For more information, see the [`viam module` command](/cli/#module).
 
 ## Change module visibility
 
@@ -330,7 +330,7 @@ To change the visibility:
      Only organization members can edit the module.
      Not listed in the registry for users outside of your organization.
 
-You can also edit the visibility by editing the [meta.json](/operate/modules/advanced/metajson/) file and then running the following [CLI](/dev/tools/cli/#module) command:
+You can also edit the visibility by editing the [meta.json](/operate/modules/advanced/metajson/) file and then running the following [CLI](/cli/#module) command:
 
 ```sh {id="terminal-prompt" class="command-line" data-prompt="$"}
 viam module update
diff --git a/docs/operate/modules/advanced/module-configuration.md b/docs/operate/modules/advanced/module-configuration.md
index d7c62b2897..c364ff0499 100644
--- a/docs/operate/modules/advanced/module-configuration.md
+++ b/docs/operate/modules/advanced/module-configuration.md
@@ -312,7 +312,7 @@ Not all of these variables are automatically available on [local modules](/opera
 | `VIAM_MODULE_ROOT` | The root of the module install directory. The module process uses this directory as its current working directory (`cwd`). This variable is useful for file navigation that is relative to the root of the module.<br>Example: <file>/opt/my-module/verxxxx-my-module/</file> | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
 | `VIAM_RESOURCE_CONFIGURATION_TIMEOUT` | Duration that resources are allowed to configure or reconfigure.<br>Example: `4m0s`<br>Default: `2m0s`. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
 | `VIAM_MODULE_STARTUP_TIMEOUT` | Duration that modules are allowed to start up.<br>Example: `7m15s`<br>Default: 5 minutes. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| `VIAM_MODULE_DATA` | A persistent folder location a module can use to store data across reboots and version updates. The folder will be removed when the module is removed from the machine, including when disabled in the machine configuration. This location is a good place to store [python virtual environments](/dev/reference/sdks/python/python-venv/).<br>Example: <file>$VIAM_HOME/module-data/cloud-machine-id/my-module-name/</file> | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| `VIAM_MODULE_DATA` | A persistent folder location a module can use to store data across reboots and version updates. The folder will be removed when the module is removed from the machine, including when disabled in the machine configuration. This location is a good place to store [python virtual environments](/reference/sdks/python/python-venv/).<br>Example: <file>$VIAM_HOME/module-data/cloud-machine-id/my-module-name/</file> | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
 | `VIAM_MODULE_ID` | The module ID of the module.<br>Example: `viam:realsense` | |
 | `VIAM_API_KEY` | An API key with access to the machine where this instance of the module is running. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
 | `VIAM_API_KEY_ID` | The ID of the API key with access to the machine where this instance of the module is running. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
diff --git a/docs/operate/modules/advanced/platform-apis.md b/docs/operate/modules/advanced/platform-apis.md
index 10dd0cf768..7a05866749 100644
--- a/docs/operate/modules/advanced/platform-apis.md
+++ b/docs/operate/modules/advanced/platform-apis.md
@@ -19,10 +19,10 @@ To use the platform or machine APIs, you must authenticate using API keys.
 
 The following steps show you how to use the following APIs from a module:
 
-- [Fleet management (`app_client`)](/dev/reference/apis/fleet/)
-- [Data client (`data_client`)](/dev/reference/apis/data-client/)
-- [ML training (`ml_training_client`)](/dev/reference/apis/ml-training-client/)
-- [Billing (`billing_client`)](/dev/reference/apis/billing-client/)
+- [Fleet management (`app_client`)](/reference/apis/fleet/)
+- [Data client (`data_client`)](/reference/apis/data-client/)
+- [ML training (`ml_training_client`)](/reference/apis/ml-training-client/)
+- [Billing (`billing_client`)](/reference/apis/billing-client/)
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -157,7 +157,7 @@ If you need a higher level of access, you can pass API keys as part of the modul
 
 ## Use the machine management API from a module
 
-To use the [machine management (`robot_client`) API](/dev/reference/apis/robot/), you must get the machine's FQDN and API keys from the module environment variables.
+To use the [machine management (`robot_client`) API](/reference/apis/robot/), you must get the machine's FQDN and API keys from the module environment variables.
 
 {{< tabs >}}
 {{% tab name="Python" %}}
diff --git a/docs/operate/modules/configure-modules.md b/docs/operate/modules/configure-modules.md
index 7b9846ed74..4541debde6 100644
--- a/docs/operate/modules/configure-modules.md
+++ b/docs/operate/modules/configure-modules.md
@@ -26,7 +26,7 @@ aliases:
 date: "2025-11-04"
 ---
 
-Viam has a registry of {{< glossary_tooltip term_id="module" text="modules" >}} that implement [standardized APIs](/dev/reference/apis/#component-apis) for categories of hardware {{< glossary_tooltip term_id="component" text="components" >}} and software {{< glossary_tooltip term_id="service" text="services" >}}.
+Viam has a registry of {{< glossary_tooltip term_id="module" text="modules" >}} that implement [standardized APIs](/reference/apis/#component-apis) for categories of hardware {{< glossary_tooltip term_id="component" text="components" >}} and software {{< glossary_tooltip term_id="service" text="services" >}}.
 
 If you are using an ESP32 microcontroller, see the [ESP32-specific instructions](/operate/install/setup-micro/#configure-and-test-your-machine) for how to add modules to the firmware build.
 
@@ -101,112 +101,112 @@ If you don't find a component that supports your hardware, you can [create a new
 {{% /tab %}}
 {{% tab name="Arm" %}}
 
-The following models implement the [arm component API](/dev/reference/apis/components/arm/):
+The following models implement the [arm component API](/reference/apis/components/arm/):
 
 {{<resources api="rdk:component:arm" type="arm" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Base" %}}
 
-The following models implement the [base component API](/dev/reference/apis/components/base/):
+The following models implement the [base component API](/reference/apis/components/base/):
 
 {{<resources api="rdk:component:base" type="base" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Board" %}}
 
-The following models implement the [board component API](/dev/reference/apis/components/board/):
+The following models implement the [board component API](/reference/apis/components/board/):
 
 {{<resources api="rdk:component:board" type="board" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Button" %}}
 
-The following models implement the [button component API](/dev/reference/apis/components/button/):
+The following models implement the [button component API](/reference/apis/components/button/):
 
 {{<resources api="rdk:component:button" type="button" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Camera" %}}
 
-The following models implement the [camera component API](/dev/reference/apis/components/camera/):
+The following models implement the [camera component API](/reference/apis/components/camera/):
 
 {{<resources api="rdk:component:camera" type="camera" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Encoder" %}}
 
-The following models implement the [encoder component API](/dev/reference/apis/components/encoder/):
+The following models implement the [encoder component API](/reference/apis/components/encoder/):
 
 {{<resources api="rdk:component:encoder" type="encoder" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Gantry" %}}
 
-The following models implement the [gantry component API](/dev/reference/apis/components/gantry/):
+The following models implement the [gantry component API](/reference/apis/components/gantry/):
 
 {{<resources api="rdk:component:gantry" type="gantry" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Generic" %}}
 
-The following models implement the [generic component API](/dev/reference/apis/components/generic/):
+The following models implement the [generic component API](/reference/apis/components/generic/):
 
 {{<resources api="rdk:component:generic" type="generic" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Gripper" %}}
 
-The following models implement the [gripper component API](/dev/reference/apis/components/gripper/):
+The following models implement the [gripper component API](/reference/apis/components/gripper/):
 
 {{<resources api="rdk:component:gripper" type="gripper" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Input Controller" %}}
 
-The following models implement the [input controller component API](/dev/reference/apis/components/input-controller/):
+The following models implement the [input controller component API](/reference/apis/components/input-controller/):
 
 {{<resources api="rdk:component:input_controller" type="input_controller" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Motor" %}}
 
-The following models implement the [motor component API](/dev/reference/apis/components/motor/):
+The following models implement the [motor component API](/reference/apis/components/motor/):
 
 {{<resources api="rdk:component:motor" type="motor" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Movement Sensor" %}}
 
-The following models implement the [movement sensor component API](/dev/reference/apis/components/movement-sensor/):
+The following models implement the [movement sensor component API](/reference/apis/components/movement-sensor/):
 
 {{<resources api="rdk:component:movement_sensor" type="movement_sensor" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Power Sensor" %}}
 
-The following models implement the [power sensor component API](/dev/reference/apis/components/power-sensor/):
+The following models implement the [power sensor component API](/reference/apis/components/power-sensor/):
 
 {{<resources api="rdk:component:power_sensor" type="power_sensor" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Sensor" %}}
 
-The following models implement the [sensor component API](/dev/reference/apis/components/sensor/):
+The following models implement the [sensor component API](/reference/apis/components/sensor/):
 
 {{<resources api="rdk:component:sensor" type="sensor" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Servo" %}}
 
-The following models implement the [servo component API](/dev/reference/apis/components/servo/):
+The following models implement the [servo component API](/reference/apis/components/servo/):
 
 {{<resources api="rdk:component:servo" type="servo" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Switch" %}}
 
-The following models implement the [switch component API](/dev/reference/apis/components/switch/):
+The following models implement the [switch component API](/reference/apis/components/switch/):
 
 {{<resources api="rdk:component:switch" type="switch" no-intro="true">}}
 
@@ -233,42 +233,42 @@ If you are looking to write control logic, see [Run control logic](/operate/modu
 {{% /tab %}}
 {{% tab name="Vision" %}}
 
-The following models implement the [vision service API](/dev/reference/apis/services/vision/):
+The following models implement the [vision service API](/reference/apis/services/vision/):
 
 {{<resources api="rdk:service:vision" type="vision" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="ML model" %}}
 
-The following models implement the [ML model service API](/dev/reference/apis/services/ml/):
+The following models implement the [ML model service API](/reference/apis/services/ml/):
 
 {{<resources api="rdk:service:mlmodel" type="mlmodel" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Motion" %}}
 
-The following models implement the [motion service API](/dev/reference/apis/services/motion/):
+The following models implement the [motion service API](/reference/apis/services/motion/):
 
 {{<resources api="rdk:service:motion" type="motion" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Generic" %}}
 
-The following models implement the [generic service API](/dev/reference/apis/services/generic/):
+The following models implement the [generic service API](/reference/apis/services/generic/):
 
 {{<resources api="rdk:service:generic" type="generic" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="SLAM" %}}
 
-The following models implement the [SLAM service API](/dev/reference/apis/services/slam/):
+The following models implement the [SLAM service API](/reference/apis/services/slam/):
 
 {{<resources api="rdk:service:slam" type="slam" no-intro="true">}}
 
 {{% /tab %}}
 {{% tab name="Discovery" %}}
 
-The following models implement the [discovery service API](/dev/reference/apis/services/discovery/):
+The following models implement the [discovery service API](/reference/apis/services/discovery/):
 
 {{<resources api="rdk:service:discovery" type="discovery" no-intro="true">}}
 
@@ -286,6 +286,6 @@ If you have configured all your hardware and software, you can do a variety of t
 
 - [Deploy control logic to run directly on your machines](/operate/modules/write-a-logic-module/)
 - [Write an app](/operate/control/web-app/) to interact with your machines using any of the Viam SDKs
-- [Capture data from your machines](/data-ai/capture-data/capture-sync/)
-- [Create a dataset](/data-ai/train/create-dataset/) and [train an AI model](/data-ai/train/train-tf-tflite/)
+- [Capture data from your machines](/data/capture-sync/capture-and-sync-data/)
+- [Create a dataset](/data-ai/train/create-dataset/) and [train an AI model](/train/train-a-model/)
 - [Share the configuration across multiple machines](/manage/fleet/reuse-configuration/)
diff --git a/docs/operate/modules/lifecycle-of-a-module.md b/docs/operate/modules/lifecycle-of-a-module.md
index 3c1699e4ac..7481a91e58 100644
--- a/docs/operate/modules/lifecycle-of-a-module.md
+++ b/docs/operate/modules/lifecycle-of-a-module.md
@@ -13,7 +13,7 @@ aliases:
 
 Modules run on your machine, alongside `viam-server` as separate processes, communicating with `viam-server` over UNIX sockets.
 
-[`viam-server` manages](/operate/reference/viam-server/) the dependencies, start-up, reconfiguration, [data management](/data-ai/capture-data/capture-sync/), and shutdown behavior of your {{< glossary_tooltip term_id="resource" text="modular resources" >}}.
+[`viam-server` manages](/operate/reference/viam-server/) the dependencies, start-up, reconfiguration, [data management](/data/capture-sync/capture-and-sync-data/), and shutdown behavior of your {{< glossary_tooltip term_id="resource" text="modular resources" >}}.
 
 The lifecycle of a module and the resources it provides are as follows:
 
@@ -21,7 +21,7 @@ The lifecycle of a module and the resources it provides are as follows:
 
 1. `viam-server` starts any configured modules.
 
-1. When a module initializes, it registers its model or models and associated [APIs](/dev/reference/apis/) with `viam-server`, making the models available for use.
+1. When a module initializes, it registers its model or models and associated [APIs](/reference/apis/) with `viam-server`, making the models available for use.
 
 1. For each modular resource configured on the machine, `viam-server` uses the return values of the resource's `validate_config` function to determine the required and optional [dependencies](/operate/modules/advanced/dependencies/) of the resource.
 
@@ -37,7 +37,7 @@ The lifecycle of a module and the resources it provides are as follows:
    - a validation error or exception thrown during reconfiguration
    - exceeding the [configured timeout limits](/operate/modules/advanced/module-configuration/#environment-variables) (default 5 minutes to start up and 1 minute to reconfigure)
 
-   Check the `viam-server` logs for these [errors](/dev/tools/common-errors/#timed-out-waiting-for-module) on the machine's **LOGS** tab.
+   Check the `viam-server` logs for these [errors](/monitor/troubleshoot/#timed-out-waiting-for-module) on the machine's **LOGS** tab.
 
 1. Once the modular resource has started up and finished configuring, it is available for use.
 
diff --git a/docs/operate/modules/write-a-driver-module/_index.md b/docs/operate/modules/write-a-driver-module/_index.md
index a117806001..0b4634e230 100644
--- a/docs/operate/modules/write-a-driver-module/_index.md
+++ b/docs/operate/modules/write-a-driver-module/_index.md
@@ -69,7 +69,7 @@ matches your hardware or service:
 | `generic`         | Does not fit any of the above                         | `DoCommand`                        |
 
 For the full list of component and service APIs, see
-[Resource APIs](/dev/reference/apis/).
+[Resource APIs](/reference/apis/).
 
 Using the right API means data capture, TEST cards, and other platform
 features work with your component automatically.
diff --git a/docs/operate/modules/write-a-logic-module.md b/docs/operate/modules/write-a-logic-module.md
index 602872b7d0..8dd805619d 100644
--- a/docs/operate/modules/write-a-logic-module.md
+++ b/docs/operate/modules/write-a-logic-module.md
@@ -86,7 +86,7 @@ custom logic -- you define your own command vocabulary.
 
 Use `generic` when your module's interface doesn't map to an existing service
 API (like `vision` or `mlmodel`). For the full list of service APIs, see
-[Resource APIs](/dev/reference/apis/).
+[Resource APIs](/reference/apis/).
 
 ### Background tasks
 
diff --git a/docs/operate/reference/advanced-modules/_index.md b/docs/operate/reference/advanced-modules/_index.md
index 2cd61420e5..9d35dbcc29 100644
--- a/docs/operate/reference/advanced-modules/_index.md
+++ b/docs/operate/reference/advanced-modules/_index.md
@@ -26,17 +26,17 @@ Depending on your needs, you may wish to define an entirely new resource API, de
 
 ## New APIs
 
-The [component APIs](/dev/reference/apis/#component-apis) and [service APIs](/dev/reference/apis/#service-apis) provide a standard interface for controlling common hardware components and higher level functionality.
+The [component APIs](/reference/apis/#component-apis) and [service APIs](/reference/apis/#service-apis) provide a standard interface for controlling common hardware components and higher level functionality.
 If your use case aligns closely with an existing API, you should use that API to program your new resource.
 
-If you want to use most of an existing API but need just a few other functions, you can use the `DoCommand` endpoint together with [extra parameters](/dev/reference/sdks/use-extra-params/) to add custom functionality to an existing resource API.
+If you want to use most of an existing API but need just a few other functions, you can use the `DoCommand` endpoint together with [extra parameters](/reference/sdks/use-extra-params/) to add custom functionality to an existing resource API.
 
 Or, if your resource does not fit into an existing resource API, you can use one of the following:
 
-- If you are working with a component that doesn't fit into any of the existing [component APIs](/dev/reference/apis/#component-apis), you can use the [generic component](/operate/reference/components/generic/) to build your own component API.
-- If you are designing a service that doesn't fit into any of the existing [service APIs](/dev/reference/apis/#service-apis), you can use the [generic service](/dev/reference/apis/services/generic/) to build your own service API.
+- If you are working with a component that doesn't fit into any of the existing [component APIs](/reference/apis/#component-apis), you can use the [generic component](/operate/reference/components/generic/) to build your own component API.
+- If you are designing a service that doesn't fit into any of the existing [service APIs](/reference/apis/#service-apis), you can use the [generic service](/reference/apis/services/generic/) to build your own service API.
 
-Both generic resources use the [`DoCommand`](/dev/reference/apis/components/generic/#docommand) endpoint to enable you to make arbitrary calls as needed for your resource.
+Both generic resources use the [`DoCommand`](/reference/apis/components/generic/#docommand) endpoint to enable you to make arbitrary calls as needed for your resource.
 
 Alternatively, you can also [define a new resource API](/operate/reference/advanced-modules/create-subtype/) if none of the above options are a good fit for your use case.
 
@@ -52,6 +52,6 @@ If you need to package and deploy a module using Docker, for example if your mod
 
 ## Design a custom ML model
 
-When working with the [ML model service](/dev/reference/apis/services/ml/), you can deploy an [existing model](/data-ai/ai/deploy/) or [train your own model](/data-ai/train/train/).
+When working with the [ML model service](/reference/apis/services/ml/), you can deploy an [existing model](/vision/configure/) or [train your own model](/train/custom-training-scripts/).
 
-However, if you are writing your own {{< glossary_tooltip term_id="module" text="module" >}} that uses the ML model service together with the [vision service](/dev/reference/apis/services/vision/), you can also [design your own ML model](/data-ai/reference/mlmodel-design/) to better match your specific use case.
+However, if you are writing your own {{< glossary_tooltip term_id="module" text="module" >}} that uses the ML model service together with the [vision service](/reference/apis/services/vision/), you can also [design your own ML model](/data-ai/reference/mlmodel-design/) to better match your specific use case.
diff --git a/docs/operate/reference/advanced-modules/create-subtype.md b/docs/operate/reference/advanced-modules/create-subtype.md
index 0da8c5d75c..f88c17fb94 100644
--- a/docs/operate/reference/advanced-modules/create-subtype.md
+++ b/docs/operate/reference/advanced-modules/create-subtype.md
@@ -17,14 +17,14 @@ date: "2022-01-01"
 You can define a new, custom {{< glossary_tooltip term_id="resource" text="resource" >}} API if:
 
 - You have a {{% glossary_tooltip term_id="resource" text="resource" %}} that does not fit into any of the existing {{< glossary_tooltip term_id="component" text="component" >}} or {{< glossary_tooltip term_id="service" text="service" >}} APIs.
-- You have a resource that could fit into an existing API, but you want to define an API with different methods and messages than the one in the existing [APIs](/dev/reference/apis/).
+- You have a resource that could fit into an existing API, but you want to define an API with different methods and messages than the one in the existing [APIs](/reference/apis/).
 
 {{% alert title="Tip" color="tip" %}}
 
 Defining a new resource API is significantly more complex than using an existing API.
 In most cases, you should try to use an existing API rather than define a new one.
 
-If you want to use most of an existing API but need just a few other functions, try using the `DoCommand` endpoint and [extra parameters](/dev/reference/sdks/use-extra-params/) to add custom functionality to an existing API.
+If you want to use most of an existing API but need just a few other functions, try using the `DoCommand` endpoint and [extra parameters](/reference/sdks/use-extra-params/) to add custom functionality to an existing API.
 For example, if you have a [sensor](/operate/reference/components/sensor/) and you want to define a `Calibrate` method, you can use `DoCommand`.
 
 If your use case uses only `DoCommand` and no other API methods, you can define a new model of [generic component](/operate/reference/components/generic/) or [generic service](/operate/reference/services/generic/).
@@ -93,7 +93,6 @@ The following steps guide you through this process in more detail:
    - [<file>buf.lock</file>](https://buf.build/docs/configuration/v1/buf-lock/)
 
 1. In the <file>/src/</file> directory of your module, use the protobuf compiler to [generate](https://buf.build/docs/tutorials/getting-started-with-buf-cli/#generate-code) all other necessary protocol buffer code, based on the `<API name>.proto` file you wrote.
-
    - [Example generated files for a Python-based service](https://github.com/viam-labs/speech-service-api/tree/main/src/proto).
      The `buf.` files were generated.
      The <file>speech.proto</file> was manually written.
@@ -114,7 +113,7 @@ Now that your resource API is defined, create a new model that implements your n
 
 After you define a new API and create a model that implements it, keep the following in mind when writing code against your new API:
 
-- You can't use [SDKs](/dev/reference/sdks/) to call your new API unless you build out the client to support it.
+- You can't use [SDKs](/reference/sdks/) to call your new API unless you build out the client to support it.
   It is easiest to write code against your new API in the language you used to define it.
 - Since your API doesn't have built-in SDK support, you'll need a local copy of the module code on whatever machine is running client code against it.
 - Be sure to import the API definition from the module directory, for example in Python it would be of the form `from path.to.module.src.gizmo import Gizmo`.
diff --git a/docs/operate/reference/advanced-modules/custom-components-remotes.md b/docs/operate/reference/advanced-modules/custom-components-remotes.md
index 351fca1781..8c10f98573 100644
--- a/docs/operate/reference/advanced-modules/custom-components-remotes.md
+++ b/docs/operate/reference/advanced-modules/custom-components-remotes.md
@@ -17,12 +17,12 @@ date: "2022-01-01"
 
 Running {{< glossary_tooltip term_id="modular-resource" text="modular resources" >}} on the computer directly connected to your components is the preferred way of managing and controlling custom components.
 
-However, if you are unable to use [modular resources](/operate/modules/write-a-driver-module/) because you need to host `viam-server` on a non-Linux system or have an issue with compilation, you can use a [Viam SDK](/dev/reference/sdks/) to code a custom resource implementation, host it on a server, and add it as a [remote part](/operate/reference/architecture/parts/) of your machine.
+However, if you are unable to use [modular resources](/operate/modules/write-a-driver-module/) because you need to host `viam-server` on a non-Linux system or have an issue with compilation, you can use a [Viam SDK](/reference/sdks/) to code a custom resource implementation, host it on a server, and add it as a [remote part](/operate/reference/architecture/parts/) of your machine.
 
 Once you have coded your custom component and configured the remote servers, you can control and monitor your component with the Viam SDKs, like any other component.
 
 To show how to create a custom resource, the following example creates an arm as a custom component and registers the new arm model with a Viam SDK.
-Then you can control it as part of your machine with the same [API methods](/dev/reference/apis/components/arm/#api) available for [arm models built into the RDK](/operate/reference/components/arm/#configuration).
+Then you can control it as part of your machine with the same [API methods](/reference/apis/components/arm/#api) available for [arm models built into the RDK](/operate/reference/components/arm/#configuration).
 
 ## Instructions
 
@@ -33,7 +33,7 @@ To add a custom resource as a [remote part](/operate/reference/architecture/part
 
 1. Code a new model of a built-in resource type.
    You can do this by creating a new interface that implements required methods.
-   The new model must implement any functions of the built-in resource type marked as required in its [RDK API definition](/dev/reference/apis/).
+   The new model must implement any functions of the built-in resource type marked as required in its [RDK API definition](/reference/apis/).
 2. Register the custom component on a new gRPC server instance and start the server.
 3. Add the server as a [remote part](/operate/reference/architecture/parts/) of your machine.
 4. (Optional) Ensure the remote server automatically starts when the machine boots.
@@ -49,7 +49,7 @@ For more detailed instructions, see the full example in the [Python SDK document
 
 1. Code a new model of a built-in resource type.
    You can do this by subclassing a built in resource type like `sensor` or `arm`.
-   The new model must implement any methods of the built-in resource type marked as required in its [RDK API definition](/dev/reference/apis/).
+   The new model must implement any methods of the built-in resource type marked as required in its [RDK API definition](/reference/apis/).
 1. Register the custom component on a new gRPC server instance and start the server.
    You can do this with the [`viam.rpc` library](https://python.viam.dev/autoapi/viam/rpc/index.html) by creating a new `rpc.server.Server` instance.
 1. Add the server as a [remote part](/operate/reference/architecture/parts/) of your machine.
diff --git a/docs/operate/reference/architecture/_index.md b/docs/operate/reference/architecture/_index.md
index 019f0e55e8..c3914a6976 100644
--- a/docs/operate/reference/architecture/_index.md
+++ b/docs/operate/reference/architecture/_index.md
@@ -41,7 +41,7 @@ When `viam-server` can connect to the cloud, it also:
 - Automatically pulls configuration updates you make
 - Gets new versions of software packages
 - Uploads and syncs image and sensor data
-- Handles requests from client code you write with [SDKs](/dev/reference/sdks/)
+- Handles requests from client code you write with [SDKs](/reference/sdks/)
 - Allows you to remotely monitor and control your machine
 
 `viam-server` can use the internet, wide area networks (WAN) or local networks (LAN) to establish peer-to-peer connections between two {{< glossary_tooltip term_id="machine" text="machines" >}}, or to a client application.
@@ -135,7 +135,7 @@ Data is captured and synced to the Viam Cloud as follows:
 
 If a device has intermittent internet connectivity, data is stored locally until the machine can reconnect to the cloud.
 
-For more information, see [Data management service](/data-ai/capture-data/capture-sync/).
+For more information, see [Data management service](/data/capture-sync/capture-and-sync-data/).
 
 ## Basic machine example
 
@@ -156,7 +156,7 @@ Here is how this works in Viam:
 Now imagine you want to run code to turn on a fan when the temperature sensor reads over 100 degrees Fahrenheit:
 
 - Configure the fan motor as a motor component and wire the fan motor relay to the same board as the sensor.
-- Write your script using one of the Viam [SDKs](/dev/reference/sdks/), for example the Viam Python SDK, using the sensor API and motor API.
+- Write your script using one of the Viam [SDKs](/reference/sdks/), for example the Viam Python SDK, using the sensor API and motor API.
 - You then run this code either locally on the SBC, or on a separate server.
   See [Create a headless app](/operate/control/headless-app/) for more information.
   Your code connects to the machine, authenticating with API keys, and uses the [sensor API](/operate/reference/components/sensor/#api) to get readings and the [motor API](/operate/reference/components/motor/#api) to turn the motor on and off.
diff --git a/docs/operate/reference/architecture/parts.md b/docs/operate/reference/architecture/parts.md
index d27fac0b9d..f165560e29 100644
--- a/docs/operate/reference/architecture/parts.md
+++ b/docs/operate/reference/architecture/parts.md
@@ -110,7 +110,7 @@ To establish a connection between a part of one machine and a part of a second m
 1. Select the remote part from the list of parts.
 
    Alternatively, click **Add empty remote** and then scroll to the newly-created remote part configuration card.
-   Click on **{}** (Switch to advanced) and replace the JSON object with a remote config.
+   Click on **JSON** and replace the JSON object with a remote config.
 
    {{<imgproc src="/build/configure/parts/remote-config.png" resize="x1100" declaredimensions=true alt="The configured remote." style="width:700px" class="shadow" >}}
 
@@ -120,7 +120,7 @@ To establish a connection between a part of one machine and a part of a second m
    This is the machine part whose resources will be accessible to the other machine part.
 1. Navigate to the **CONNECT** tab.
 1. Click **Configure as a remote part** in the left-hand menu.
-1. Toggle the **Include API key** switch on, then copy the entire JSON snippet including the name, address, and authentication credentials of the remote part.
+1. Copy the entire JSON snippet including the name, address, and authentication credentials of the remote part.
 
    {{% snippet "show-secret.md" %}}
 
diff --git a/docs/operate/reference/components/arm/_index.md b/docs/operate/reference/components/arm/_index.md
index 400099c49e..bb43a80566 100644
--- a/docs/operate/reference/components/arm/_index.md
+++ b/docs/operate/reference/components/arm/_index.md
@@ -62,7 +62,7 @@ There is currently no support for this component compatible with the Micro-RDK.
 
 ## API
 
-The [arm API](/dev/reference/apis/components/arm/) supports the following methods:
+The [arm API](/reference/apis/components/arm/) supports the following methods:
 
 {{< readfile "/static/include/components/apis/generated/arm-table.md" >}}
 
diff --git a/docs/operate/reference/components/arm/eva.md b/docs/operate/reference/components/arm/eva.md
index 95863f40d7..4a7bf53741 100644
--- a/docs/operate/reference/components/arm/eva.md
+++ b/docs/operate/reference/components/arm/eva.md
@@ -44,7 +44,7 @@ Then, configure the arm:
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/arm/" customTitle="Arm API" noimage="true" %}}
+{{% card link="/reference/apis/components/arm/" customTitle="Arm API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/mobility/move-arm/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/arm/fake.md b/docs/operate/reference/components/arm/fake.md
index 5cbcff29e9..72ca4a83b8 100644
--- a/docs/operate/reference/components/arm/fake.md
+++ b/docs/operate/reference/components/arm/fake.md
@@ -88,7 +88,7 @@ The following attributes are available for `fake` arms:
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/arm/" customTitle="Arm API" noimage="true" %}}
+{{% card link="/reference/apis/components/arm/" customTitle="Arm API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/mobility/move-arm/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/arm/yahboom-dofbot.md b/docs/operate/reference/components/arm/yahboom-dofbot.md
index 5374cb39df..281b870659 100644
--- a/docs/operate/reference/components/arm/yahboom-dofbot.md
+++ b/docs/operate/reference/components/arm/yahboom-dofbot.md
@@ -82,7 +82,7 @@ Edit and fill in the attributes as applicable.
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/arm/" customTitle="Arm API" noimage="true" %}}
+{{% card link="/reference/apis/components/arm/" customTitle="Arm API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/mobility/move-arm/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/base/_index.md b/docs/operate/reference/components/base/_index.md
index 3b3e33f1ea..390e15aa78 100644
--- a/docs/operate/reference/components/base/_index.md
+++ b/docs/operate/reference/components/base/_index.md
@@ -61,7 +61,7 @@ For additional configuration information, click on the model name:
 
 ## API
 
-The [base API](/dev/reference/apis/components/base/) supports the following methods:
+The [base API](/reference/apis/components/base/) supports the following methods:
 
 {{< readfile "/static/include/components/apis/generated/base-table.md" >}}
 
diff --git a/docs/operate/reference/components/base/boat.md b/docs/operate/reference/components/base/boat.md
index 0dff706457..f2149b14bf 100644
--- a/docs/operate/reference/components/base/boat.md
+++ b/docs/operate/reference/components/base/boat.md
@@ -55,7 +55,7 @@ The following attributes are available for `boat` bases:
 | ---- | ---- | --------- | ----------- |
 | `length_mm` | int | **Required** | Length of the base in millimeters. In other words, the distance between the approximate centers of the right and left wheels. Can be an approximation. |
 | `width_mm` | int | **Required** | Width of the base in millimeters. In other words, the distance between the approximate centers of the right and left motors. Can be an approximation. |
-| `IMU` | string | **Required** | Name of the [Inertial Measurement Unit](/dev/reference/apis/components/movement-sensor/#imu-configuration) in the boat. |
+| `IMU` | string | **Required** | Name of the [Inertial Measurement Unit](/reference/apis/components/movement-sensor/#imu-configuration) in the boat. |
 | `Motors` | string[] | **Required** | JSON struct containing the configuration attributes for each motor attached to the boat. |
 
 Each [motor](/operate/reference/components/motor/) inside of `Motors` has the following attributes available:
@@ -82,7 +82,7 @@ Each [motor](/operate/reference/components/motor/) inside of `Motors` has the fo
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/base/" customTitle="Base API" noimage="true" %}}
+{{% card link="/reference/apis/components/base/" customTitle="Base API" noimage="true" %}}
 {{% card link="/tutorials/configure/configure-rover/" noimage="true" %}}
 {{% card link="/tutorials/control/drive-rover/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/base/fake.md b/docs/operate/reference/components/base/fake.md
index 9ab145fd22..cb60e84719 100644
--- a/docs/operate/reference/components/base/fake.md
+++ b/docs/operate/reference/components/base/fake.md
@@ -56,7 +56,7 @@ See [GitHub](https://github.com/viamrobotics/rdk/blob/main/components/base/fake/
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/base/" customTitle="Base API" noimage="true" %}}
+{{% card link="/reference/apis/components/base/" customTitle="Base API" noimage="true" %}}
 {{% card link="/tutorials/configure/configure-rover/" noimage="true" %}}
 {{% card link="/tutorials/control/drive-rover/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/base/sensor-controlled.md b/docs/operate/reference/components/base/sensor-controlled.md
index 40a3b90f52..31665728f8 100644
--- a/docs/operate/reference/components/base/sensor-controlled.md
+++ b/docs/operate/reference/components/base/sensor-controlled.md
@@ -16,16 +16,16 @@ toc_hide: true
 A `sensor-controlled` base supports a robotic base with feedback control from a movement sensor.
 
 {{% alert title="Requirements" color="note" %}}
-In order to use feedback control, you must provide a movement sensor that implements [AngularVelocity()](/dev/reference/apis/components/movement-sensor/#getangularvelocity) and [LinearVelocity()](/dev/reference/apis/components/movement-sensor/#getlinearvelocity). This will enable feedback control for [SetVelocity()](/dev/reference/apis/components/base/#setvelocity).
+In order to use feedback control, you must provide a movement sensor that implements [AngularVelocity()](/reference/apis/components/movement-sensor/#getangularvelocity) and [LinearVelocity()](/reference/apis/components/movement-sensor/#getlinearvelocity). This will enable feedback control for [SetVelocity()](/reference/apis/components/base/#setvelocity).
 
-In order to use feedback control for [Spin()](/dev/reference/apis/components/base/#spin), you must also provide a movement sensor that implements [Orientation()](/dev/reference/apis/components/movement-sensor/#getorientation).
+In order to use feedback control for [Spin()](/reference/apis/components/base/#spin), you must also provide a movement sensor that implements [Orientation()](/reference/apis/components/movement-sensor/#getorientation).
 
-In order to use feedback control for [MoveStraight()](/dev/reference/apis/components/base/#spin), you must also provide a movement sensor that implements [Position()](/dev/reference/apis/components/movement-sensor/#getposition).
-Additionally, heading feedback control while moving straight can be used by providing a movement sensor that implements [Orientation()](/dev/reference/apis/components/movement-sensor/#getorientation) or [CompassHeading()](/dev/reference/apis/components/movement-sensor/#getcompassheading).
+In order to use feedback control for [MoveStraight()](/reference/apis/components/base/#spin), you must also provide a movement sensor that implements [Position()](/reference/apis/components/movement-sensor/#getposition).
+Additionally, heading feedback control while moving straight can be used by providing a movement sensor that implements [Orientation()](/reference/apis/components/movement-sensor/#getorientation) or [CompassHeading()](/reference/apis/components/movement-sensor/#getcompassheading).
 {{% /alert %}}
 
 To configure a `sensor-controlled` base as a component of your machine, first configure the [model of base](/operate/reference/components/base/) you want to wrap with feedback control and each required [movement sensor](/operate/reference/components/movement-sensor/).
-To see what models of movement sensor report which feedback, reference the appropriate column in [Movement Sensor API](/dev/reference/apis/components/movement-sensor/#api).
+To see what models of movement sensor report which feedback, reference the appropriate column in [Movement Sensor API](/reference/apis/components/movement-sensor/#api).
 
 Configure a `sensor-controlled` base as follows:
 
@@ -99,11 +99,11 @@ When `control_parameters` is set, `MoveStraight` calculates the required velocit
 
 The following base control API methods are available on a `sensor-controlled` base:
 
-- [SetVelocity()](/dev/reference/apis/components/base/#setvelocity): available if base is configured to receive angular and linear velocity feedback.
-- [Spin()](/dev/reference/apis/components/base/#spin): available if base is configured to receive orientation feedback.
-- [MoveStraight()](/dev/reference/apis/components/base/#movestraight): available if base is configured to receive position feedback.
+- [SetVelocity()](/reference/apis/components/base/#setvelocity): available if base is configured to receive angular and linear velocity feedback.
+- [Spin()](/reference/apis/components/base/#spin): available if base is configured to receive orientation feedback.
+- [MoveStraight()](/reference/apis/components/base/#movestraight): available if base is configured to receive position feedback.
 
-For example, a rover using `sensor-controlled` base following both an [angular](/dev/reference/apis/components/base/#spin) and [linear](/dev/reference/apis/components/base/#movestraight) velocity command:
+For example, a rover using `sensor-controlled` base following both an [angular](/reference/apis/components/base/#spin) and [linear](/reference/apis/components/base/#movestraight) velocity command:
 
 {{<gif webm_src="/components/encoded-motor/base_moving.webm" mp4_src="/components/encoded-motor/base-moving.mp4" alt="A Viam rover turning in a half circle" max-width="400px" >}}
 
@@ -120,7 +120,7 @@ The position, orientation, and linear and angular velocity of the rover changing
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/base/" customTitle="Base API" noimage="true" %}}
+{{% card link="/reference/apis/components/base/" customTitle="Base API" noimage="true" %}}
 {{% card link="/tutorials/configure/configure-rover/" noimage="true" %}}
 {{% card link="/tutorials/control/drive-rover/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/base/two_wheeled_base.md b/docs/operate/reference/components/base/two_wheeled_base.md
index 856e377bb5..a2c7591677 100644
--- a/docs/operate/reference/components/base/two_wheeled_base.md
+++ b/docs/operate/reference/components/base/two_wheeled_base.md
@@ -91,7 +91,7 @@ The following attributes are available for `two_wheeled_base` bases:
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/base/" customTitle="Base API" noimage="true" %}}
+{{% card link="/reference/apis/components/base/" customTitle="Base API" noimage="true" %}}
 {{% card link="/tutorials/configure/configure-rover/" noimage="true" %}}
 {{% card link="/tutorials/control/drive-rover/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/base/wheeled.md b/docs/operate/reference/components/base/wheeled.md
index a7f9112489..18cd49495e 100644
--- a/docs/operate/reference/components/base/wheeled.md
+++ b/docs/operate/reference/components/base/wheeled.md
@@ -162,7 +162,7 @@ Note that your base's wiring will vary depending on your choice of board, motors
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/base/" customTitle="Base API" noimage="true" %}}
+{{% card link="/reference/apis/components/base/" customTitle="Base API" noimage="true" %}}
 {{% card link="/tutorials/configure/configure-rover/" noimage="true" %}}
 {{% card link="/tutorials/control/drive-rover/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/board/_index.md b/docs/operate/reference/components/board/_index.md
index 0870f7bf05..0741054b46 100644
--- a/docs/operate/reference/components/board/_index.md
+++ b/docs/operate/reference/components/board/_index.md
@@ -79,7 +79,7 @@ For Linux boards like the Odroid C4, Pumpkin, or, Banana Pi, you can also use th
 
 ## API
 
-The [board API](/dev/reference/apis/components/board/) supports the following methods:
+The [board API](/reference/apis/components/board/) supports the following methods:
 
 {{< readfile "/static/include/components/apis/generated/board-table.md" >}}
 
diff --git a/docs/operate/reference/components/board/esp32.md b/docs/operate/reference/components/board/esp32.md
index 1dbb14185c..30921d37f9 100644
--- a/docs/operate/reference/components/board/esp32.md
+++ b/docs/operate/reference/components/board/esp32.md
@@ -111,10 +111,10 @@ The following attributes are available for `esp32` boards:
 | `analogs` | array | Optional | Attributes of any pins that can be used as analog-to-digital converter (ADC) inputs. See [configuration info](#analogs). |
 | `i2cs` | array | Optional | Any Inter-Integrated Circuit (I<sup>2</sup>C) pins' bus index and name. See [configuration info](#i2cs). |
 | `digital_interrupts` | array | Optional | Any digital interrupts' GPIO number. See [configuration info](#digital_interrupts). |
-| `pins` | array | Optional | The GPIO number of any GPIO pins you wish to use as input/output with the [board API](/dev/reference/apis/components/board/#api). |
+| `pins` | array | Optional | The GPIO number of any GPIO pins you wish to use as input/output with the [board API](/reference/apis/components/board/#api). |
 
-Any pin not specified in either `"pins"` or `"digital_interrupts"` cannot be interacted with through the [board API](/dev/reference/apis/components/board/#api).
-Interaction with digital interrupts is only supported with the [board API](/dev/reference/apis/components/board/#api); these digital interrupts cannot be used as software interrupts in driver implementations.
+Any pin not specified in either `"pins"` or `"digital_interrupts"` cannot be interacted with through the [board API](/reference/apis/components/board/#api).
+Interaction with digital interrupts is only supported with the [board API](/reference/apis/components/board/#api); these digital interrupts cannot be used as software interrupts in driver implementations.
 
 ### `analogs`
 
@@ -151,7 +151,7 @@ The following properties are available for `digital_interrupts`:
 
 ### PWM signals on `esp32` pins
 
-You can set PWM frequencies with Viam through the [`GPIOPin` API](/dev/reference/apis/components/board/#api).
+You can set PWM frequencies with Viam through the [`GPIOPin` API](/reference/apis/components/board/#api).
 Refer to the [Espressif documentation for valid frequencies and duty resolutions](https://docs.espressif.com/projects/esp-idf/en/v5.4/esp32/api-reference/peripherals/ledc.html#supported-range-of-frequency-and-duty-resolutions).
 A configured `esp32` board can support a maximum of four different PWM frequencies simultaneously, as the boards only have four available timers.
 
@@ -194,7 +194,7 @@ Then, follow these requirements to change the PWM frequencies of a pin:
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/board/" customTitle="Board API" noimage="true" %}}
+{{% card link="/reference/apis/components/board/" customTitle="Board API" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{% card link="/tutorials/get-started/blink-an-led/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/board/fake.md b/docs/operate/reference/components/board/fake.md
index 894028b443..35a6fc334b 100644
--- a/docs/operate/reference/components/board/fake.md
+++ b/docs/operate/reference/components/board/fake.md
@@ -81,7 +81,7 @@ Configuring these attributes on your board allows you to integrate [analog-to-di
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/board/" customTitle="Board API" noimage="true" %}}
+{{% card link="/reference/apis/components/board/" customTitle="Board API" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{% card link="/tutorials/get-started/blink-an-led/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/button/_index.md b/docs/operate/reference/components/button/_index.md
index 31f1ff1b74..333bbf185c 100644
--- a/docs/operate/reference/components/button/_index.md
+++ b/docs/operate/reference/components/button/_index.md
@@ -43,7 +43,7 @@ There is currently no support for this component compatible with the Micro-RDK.
 
 ## API
 
-The [button API](/dev/reference/apis/components/button/) supports the following methods:
+The [button API](/reference/apis/components/button/) supports the following methods:
 
 {{< readfile "/static/include/components/apis/generated/button-table.md" >}}
 
diff --git a/docs/operate/reference/components/camera/_index.md b/docs/operate/reference/components/camera/_index.md
index 4002c3d606..bcc94b3306 100644
--- a/docs/operate/reference/components/camera/_index.md
+++ b/docs/operate/reference/components/camera/_index.md
@@ -58,7 +58,7 @@ For additional configuration information, click on the model name:
 
 ## API
 
-The [camera API](/dev/reference/apis/components/camera/) supports the following methods:
+The [camera API](/reference/apis/components/camera/) supports the following methods:
 
 {{< readfile "/static/include/components/apis/generated/camera-table.md" >}}
 
@@ -80,7 +80,7 @@ If none of these steps work, reach out to us on the [Community Discord](https://
 When working with a [camera](/operate/reference/components/camera/) component, depending on the camera, you may need to explicitly provide some camera-specific configuration parameters.
 
 Check the specifications for your camera, and manually provide configuration parameters such as width and height to the camera component configuration panel.
-On the **CONFIGURE** page, find your camera, then fill in your camera's specific configuration either using the **Show more** button to show the relevant configuration options, or the **{}** (Switch to Advanced) button in the top right of the component panel to enter these attributes manually.
+On the **CONFIGURE** page, find your camera, then fill in your camera's specific configuration either using the **Show more** button to show the relevant configuration options, or the **JSON** button to enter these attributes manually.
 Provide at least the width and height values to start.
 
 {{% /expand%}}
@@ -101,13 +101,13 @@ If you are running into this issue, consider the following solutions:
 For general configuration, development, and usage info, see:
 
 {{< cards >}}
-{{% card link="/data-ai/capture-data/capture-sync/" noimage="true" %}}
+{{% card link="/data/capture-sync/capture-and-sync-data/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
 
 You can also use the camera component with the following services:
 
-- [Data management service](/data-ai/capture-data/capture-sync/): To capture and sync the camera's data
+- [Data management service](/data/capture-sync/capture-and-sync-data/): To capture and sync the camera's data
 - [Vision service](/operate/reference/services/vision/): To use computer vision to interpret the camera stream
 - [SLAM service](/operate/reference/services/slam/): For mapping (with a depth camera)
 
diff --git a/docs/operate/reference/components/camera/calibrate.md b/docs/operate/reference/components/camera/calibrate.md
index 2249cc79db..07c954147d 100644
--- a/docs/operate/reference/components/camera/calibrate.md
+++ b/docs/operate/reference/components/camera/calibrate.md
@@ -113,6 +113,6 @@ The following is a full example config:
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/camera/" customTitle="Camera API" noimage="true" %}}
-{{% card link="/data-ai/capture-data/capture-sync/" noimage="true" %}}
+{{% card link="/reference/apis/components/camera/" customTitle="Camera API" noimage="true" %}}
+{{% card link="/data/capture-sync/capture-and-sync-data/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/camera/esp32-camera.md b/docs/operate/reference/components/camera/esp32-camera.md
index 54fcd48139..5f90943043 100644
--- a/docs/operate/reference/components/camera/esp32-camera.md
+++ b/docs/operate/reference/components/camera/esp32-camera.md
@@ -40,7 +40,7 @@ Finish building and flashing custom firmware, then return to this guide.
 
 {{< alert title="Data management not supported" color="caution" >}}
 
-The `esp32-camera` camera model does not currently support the [data management service](/data-ai/capture-data/capture-sync/).
+The `esp32-camera` camera model does not currently support the [data management service](/data/capture-sync/capture-and-sync-data/).
 
 {{< /alert >}}
 
@@ -200,6 +200,6 @@ The following attributes are available for `esp32-camera` cameras:
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/camera/" customTitle="Camera API" noimage="true" %}}
-{{% card link="/data-ai/capture-data/capture-sync/" noimage="true" %}}
+{{% card link="/reference/apis/components/camera/" customTitle="Camera API" noimage="true" %}}
+{{% card link="/data/capture-sync/capture-and-sync-data/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/camera/fake-micro-server.md b/docs/operate/reference/components/camera/fake-micro-server.md
index c86260dbfe..a59768e31d 100644
--- a/docs/operate/reference/components/camera/fake-micro-server.md
+++ b/docs/operate/reference/components/camera/fake-micro-server.md
@@ -65,6 +65,6 @@ You can change the refresh frequency as needed to change bandwidth.
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/camera/" customTitle="Camera API" noimage="true" %}}
-{{% card link="/data-ai/capture-data/capture-sync/" noimage="true" %}}
+{{% card link="/reference/apis/components/camera/" customTitle="Camera API" noimage="true" %}}
+{{% card link="/data/capture-sync/capture-and-sync-data/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/camera/fake.md b/docs/operate/reference/components/camera/fake.md
index 05c940dd92..fffd1adad4 100644
--- a/docs/operate/reference/components/camera/fake.md
+++ b/docs/operate/reference/components/camera/fake.md
@@ -78,6 +78,6 @@ You can change the refresh frequency as needed to change bandwidth.
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/camera/" customTitle="Camera API" noimage="true" %}}
-{{% card link="/data-ai/capture-data/capture-sync/" noimage="true" %}}
+{{% card link="/reference/apis/components/camera/" customTitle="Camera API" noimage="true" %}}
+{{% card link="/data/capture-sync/capture-and-sync-data/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/camera/ffmpeg.md b/docs/operate/reference/components/camera/ffmpeg.md
index 1c14de692e..ab5f4dd893 100644
--- a/docs/operate/reference/components/camera/ffmpeg.md
+++ b/docs/operate/reference/components/camera/ffmpeg.md
@@ -121,6 +121,6 @@ The following attributes are available for `ffmpeg` cameras:
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/camera/" customTitle="Camera API" noimage="true" %}}
-{{% card link="/data-ai/capture-data/capture-sync/" noimage="true" %}}
+{{% card link="/reference/apis/components/camera/" customTitle="Camera API" noimage="true" %}}
+{{% card link="/data/capture-sync/capture-and-sync-data/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/camera/image-file.md b/docs/operate/reference/components/camera/image-file.md
index 860dbfcdf1..8c152d1015 100644
--- a/docs/operate/reference/components/camera/image-file.md
+++ b/docs/operate/reference/components/camera/image-file.md
@@ -93,6 +93,6 @@ If you then also configure a `pointcloud_file_path` on your camera, Viam will tr
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/camera/" customTitle="Camera API" noimage="true" %}}
-{{% card link="/data-ai/capture-data/capture-sync/" noimage="true" %}}
+{{% card link="/reference/apis/components/camera/" customTitle="Camera API" noimage="true" %}}
+{{% card link="/data/capture-sync/capture-and-sync-data/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/camera/transform.md b/docs/operate/reference/components/camera/transform.md
index b970c9fabf..c4f9082c88 100644
--- a/docs/operate/reference/components/camera/transform.md
+++ b/docs/operate/reference/components/camera/transform.md
@@ -328,6 +328,6 @@ This feature is useful for when the camera is installed upside down or sideways
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/camera/" customTitle="Camera API" noimage="true" %}}
-{{% card link="/data-ai/capture-data/capture-sync/" noimage="true" %}}
+{{% card link="/reference/apis/components/camera/" customTitle="Camera API" noimage="true" %}}
+{{% card link="/data/capture-sync/capture-and-sync-data/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/camera/webcam.md b/docs/operate/reference/components/camera/webcam.md
index 5d0c48b6ae..3f6ee8bc98 100644
--- a/docs/operate/reference/components/camera/webcam.md
+++ b/docs/operate/reference/components/camera/webcam.md
@@ -115,9 +115,7 @@ To add and use the service:
    {{<imgproc src="/components/camera/webcam-discovery-test.png" alt="The test panel for the find-webcams service." resize="1100x" style="max-width:600px" class="shadow imgzoom" >}}
 
 1. Click the **Copy attributes** button for the camera you want to use.
-1. Click the **{}** icon in the upper right corner of the camera component configuration.
-
-   {{<imgproc src="/components/camera/advanced-config.png" resize="x1100" declaredimensions=true alt="The switch to advanced button." style="width:200px" class="shadow" >}}
+1. Click the **JSON** button in the upper right corner of the camera component configuration.
 
 1. Paste the copied attributes.
 1. Click **Save**.
@@ -278,7 +276,7 @@ If you are using a CSI camera v1.3 or v2.0, or v3.0 with a Raspberry Pi, use the
 For CSI cameras used with Jetsons, use the `viam:camera:csi` model provided by the same module.
 
 For Raspberry Pi AI cameras like the IMX500 AI camera, use a module such as [this `viam-pi-ai-camera` vision service](https://github.com/HipsterBrown/viam-pi-ai-camera).
-For more information about the vision service, see [run inference](https://docs.viam.com/data-ai/ai/run-inference/).
+For more information about the vision service, see [run inference](https://docs.viam.com/vision/detect/).
 {{% /expand%}}
 
 {{% expand "High CPU usage" %}}
@@ -320,6 +318,6 @@ Ensure that your terminal application has camera access enabled.
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/camera/" customTitle="Camera API" noimage="true" %}}
-{{% card link="/data-ai/capture-data/capture-sync/" noimage="true" %}}
+{{% card link="/reference/apis/components/camera/" customTitle="Camera API" noimage="true" %}}
+{{% card link="/data/capture-sync/capture-and-sync-data/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/component/_index.md b/docs/operate/reference/components/component/_index.md
index e5e2473e6a..feedf5ef60 100644
--- a/docs/operate/reference/components/component/_index.md
+++ b/docs/operate/reference/components/component/_index.md
@@ -64,7 +64,7 @@ Add services commonly used with the component.
 
 ## API
 
-The [COMPONENT API](/dev/reference/apis/components/encoder/) supports the following methods:
+The [COMPONENT API](/reference/apis/components/encoder/) supports the following methods:
 
 _Writing Instructions: Use the method names in the [protobuf](https://github.com/viamrobotics/api/blob/main/component/board/v1/board_grpc.pb.go), not the Python or Go-specific method names._
 _Use an included snippet so you can add it to <file>/program/apis/</file>._
@@ -84,6 +84,6 @@ If none of these steps work, reach out to us on the [Community Discord](https://
 
 ## Next steps
 
-To get started using your COMPONENT, see the [COMPONENT API](/dev/reference/apis/components/camera/) or check out one of these guides:
+To get started using your COMPONENT, see the [COMPONENT API](/reference/apis/components/camera/) or check out one of these guides:
 
 <!-- ADD CARDS -->
diff --git a/docs/operate/reference/components/component/board1.md b/docs/operate/reference/components/component/board1.md
index 9074475c3c..3b50eab4e1 100644
--- a/docs/operate/reference/components/component/board1.md
+++ b/docs/operate/reference/components/component/board1.md
@@ -34,7 +34,7 @@ Enter a name or use the suggested name for your board and click **Create**.
 
 ![An example configuration for a <board-model> board.](/components/board/pi-ui-config.png)
 
-Click the **{}** (Switch to Advanced) button in the top right of the component panel to edit your board's attributes with JSON, according to the following table.
+Click the **JSON** button in the top right of the component panel to edit your board's attributes with JSON, according to the following table.
 
 {{% /tab %}}
 {{% tab name="JSON Template" %}}
diff --git a/docs/operate/reference/components/encoder/_index.md b/docs/operate/reference/components/encoder/_index.md
index 169503d801..325c0f572a 100644
--- a/docs/operate/reference/components/encoder/_index.md
+++ b/docs/operate/reference/components/encoder/_index.md
@@ -67,7 +67,7 @@ For additional configuration information, click on the model name:
 
 ## API
 
-The [encoder API](/dev/reference/apis/components/encoder/) supports the following methods:
+The [encoder API](/reference/apis/components/encoder/) supports the following methods:
 
 {{< readfile "/static/include/components/apis/generated/encoder-table.md" >}}
 
@@ -94,6 +94,6 @@ For general configuration, development, and usage info, see:
 
 You can also use the encoder component with the following services:
 
-- [Data management service](/data-ai/capture-data/capture-sync/): To capture and sync the encoder's data
+- [Data management service](/data/capture-sync/capture-and-sync-data/): To capture and sync the encoder's data
 - [Motion service](/operate/reference/services/motion/): To move machines or components of machines
 - [Navigation service](/operate/reference/services/navigation/): To navigate with GPS
diff --git a/docs/operate/reference/components/encoder/arduino.md b/docs/operate/reference/components/encoder/arduino.md
index 31f2e2c4d6..a7e3ea96e7 100644
--- a/docs/operate/reference/components/encoder/arduino.md
+++ b/docs/operate/reference/components/encoder/arduino.md
@@ -64,7 +64,7 @@ The following attributes are available for `arduino` encoders:
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/encoder/" customTitle="Encoder API" noimage="true" %}}
+{{% card link="/reference/apis/components/encoder/" customTitle="Encoder API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/encoder/fake.md b/docs/operate/reference/components/encoder/fake.md
index 9d782607c9..3ee7145524 100644
--- a/docs/operate/reference/components/encoder/fake.md
+++ b/docs/operate/reference/components/encoder/fake.md
@@ -70,7 +70,7 @@ The ticks count is displayed.
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/encoder/" customTitle="Encoder API" noimage="true" %}}
+{{% card link="/reference/apis/components/encoder/" customTitle="Encoder API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/encoder/incremental-micro-rdk.md b/docs/operate/reference/components/encoder/incremental-micro-rdk.md
index 684e96e99d..7d879a4913 100644
--- a/docs/operate/reference/components/encoder/incremental-micro-rdk.md
+++ b/docs/operate/reference/components/encoder/incremental-micro-rdk.md
@@ -94,7 +94,7 @@ The following attributes are available for `incremental` encoders:
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/encoder/" customTitle="Encoder API" noimage="true" %}}
+{{% card link="/reference/apis/components/encoder/" customTitle="Encoder API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/encoder/incremental.md b/docs/operate/reference/components/encoder/incremental.md
index e8110f2719..0f5ba866c3 100644
--- a/docs/operate/reference/components/encoder/incremental.md
+++ b/docs/operate/reference/components/encoder/incremental.md
@@ -102,7 +102,7 @@ Viam also supports a model of encoder called [`"single"`](../single/) which requ
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/encoder/" customTitle="Encoder API" noimage="true" %}}
+{{% card link="/reference/apis/components/encoder/" customTitle="Encoder API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/encoder/single-micro-rdk.md b/docs/operate/reference/components/encoder/single-micro-rdk.md
index a84e552a11..d96301b775 100644
--- a/docs/operate/reference/components/encoder/single-micro-rdk.md
+++ b/docs/operate/reference/components/encoder/single-micro-rdk.md
@@ -59,7 +59,7 @@ The following attributes are available for `single` encoders:
 | Name | Type | Required? | Description |
 | ---- | ---- | --------- | ----------- |
 | `pin` | object | **Required** | GPIO number of the pin to which the encoder is wired. |
-| `dir_flip` | boolean | **Required** | If the encoder's count should increment or decrement in its initial state before a [`SetPower()`](/dev/reference/apis/components/motor/#setpower) call is made to an encoded [motor](/operate/reference/components/motor/). `true` implies decrement. |
+| `dir_flip` | boolean | **Required** | If the encoder's count should increment or decrement in its initial state before a [`SetPower()`](/reference/apis/components/motor/#setpower) call is made to an encoded [motor](/operate/reference/components/motor/). `true` implies decrement. |
 
 {{< readfile "/static/include/components/test-control/encoder-control.md" >}}
 
@@ -72,7 +72,7 @@ The following attributes are available for `single` encoders:
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/encoder/" customTitle="Encoder API" noimage="true" %}}
+{{% card link="/reference/apis/components/encoder/" customTitle="Encoder API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/encoder/single.md b/docs/operate/reference/components/encoder/single.md
index e3c142108d..09b1a986ed 100644
--- a/docs/operate/reference/components/encoder/single.md
+++ b/docs/operate/reference/components/encoder/single.md
@@ -71,7 +71,7 @@ Viam also supports a model of encoder called [`"incremental"`](../incremental/)
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/encoder/" customTitle="Encoder API" noimage="true" %}}
+{{% card link="/reference/apis/components/encoder/" customTitle="Encoder API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/gantry/_index.md b/docs/operate/reference/components/gantry/_index.md
index c55a0cfefe..8b86a76e76 100644
--- a/docs/operate/reference/components/gantry/_index.md
+++ b/docs/operate/reference/components/gantry/_index.md
@@ -59,7 +59,7 @@ There is currently no support for this component compatible with the Micro-RDK.
 
 ## API
 
-The [gantry API](/dev/reference/apis/components/gantry/) supports the following methods:
+The [gantry API](/reference/apis/components/gantry/) supports the following methods:
 
 {{< readfile "/static/include/components/apis/generated/gantry-table.md" >}}
 
diff --git a/docs/operate/reference/components/gantry/fake.md b/docs/operate/reference/components/gantry/fake.md
index 4aa6a0f429..d905da2e6f 100644
--- a/docs/operate/reference/components/gantry/fake.md
+++ b/docs/operate/reference/components/gantry/fake.md
@@ -55,7 +55,7 @@ See [GitHub](https://github.com/viamrobotics/rdk/blob/main/components/gantry/fak
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/gantry/" customTitle="Gantry API" noimage="true" %}}
+{{% card link="/reference/apis/components/gantry/" customTitle="Gantry API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/gantry/multi-axis.md b/docs/operate/reference/components/gantry/multi-axis.md
index eae8d587cf..45e80f3f67 100644
--- a/docs/operate/reference/components/gantry/multi-axis.md
+++ b/docs/operate/reference/components/gantry/multi-axis.md
@@ -218,7 +218,7 @@ The following attributes are available for `multi-axis` gantries:
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/gantry/" customTitle="Gantry API" noimage="true" %}}
+{{% card link="/reference/apis/components/gantry/" customTitle="Gantry API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/gantry/single-axis.md b/docs/operate/reference/components/gantry/single-axis.md
index b19315a61b..71a1da0636 100644
--- a/docs/operate/reference/components/gantry/single-axis.md
+++ b/docs/operate/reference/components/gantry/single-axis.md
@@ -81,7 +81,7 @@ The following attributes are available for `single-axis` gantries:
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/gantry/" customTitle="Gantry API" noimage="true" %}}
+{{% card link="/reference/apis/components/gantry/" customTitle="Gantry API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/generic/_index.md b/docs/operate/reference/components/generic/_index.md
index 2788585b68..2dad5b2838 100644
--- a/docs/operate/reference/components/generic/_index.md
+++ b/docs/operate/reference/components/generic/_index.md
@@ -19,9 +19,9 @@ date: "2024-10-21"
 # SMEs:
 ---
 
-Generic components provide an API for running model-specific commands using [`DoCommand`](/dev/reference/apis/components/generic/#docommand).
+Generic components provide an API for running model-specific commands using [`DoCommand`](/reference/apis/components/generic/#docommand).
 
-If you have a physical device or a program that does not fit into any of the provided [components APIs](/dev/reference/apis/#component-apis), use a generic component.
+If you have a physical device or a program that does not fit into any of the provided [components APIs](/reference/apis/#component-apis), use a generic component.
 
 For example, if you want to use an LED display, you need functionality that isn't currently exposed in an existing API.
 Instead, you can use the generic component API to add support for your unique type of hardware, like LED displays, to your machine.
@@ -34,7 +34,7 @@ If you are adding new high-level software functionality, rather than supporting
 The generic component API only supports the `DoCommand` method.
 If you use the generic API, your module needs to define any and all component functionality and pass it through `DoCommand`.
 
-Whenever possible, it is best to use an [existing component API](/dev/reference/apis/#component-apis) instead of generic so that you do not have to replicate code.
+Whenever possible, it is best to use an [existing component API](/reference/apis/#component-apis) instead of generic so that you do not have to replicate code.
 If you want to use most of an existing API but need just a few other functions, try using the `DoCommand` endpoint and extra parameters to add custom functionality to an existing API, instead of using the generic component.
 
 {{% /alert %}}
@@ -74,7 +74,7 @@ You will need to [recompile and flash your ESP32 yourself](/operate/install/setu
 
 ## API
 
-The [generic API](/dev/reference/apis/components/generic/) supports the following methods:
+The [generic API](/reference/apis/components/generic/) supports the following methods:
 
 {{< readfile "/static/include/components/apis/generated/generic_component-table.md" >}}
 
diff --git a/docs/operate/reference/components/generic/fake.md b/docs/operate/reference/components/generic/fake.md
index fec52f1146..5be945be98 100644
--- a/docs/operate/reference/components/generic/fake.md
+++ b/docs/operate/reference/components/generic/fake.md
@@ -52,7 +52,7 @@ See [GitHub](https://github.com/viamrobotics/rdk/blob/main/components/generic/fa
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/generic/" customTitle="Generic API" noimage="true" %}}
+{{% card link="/reference/apis/components/generic/" customTitle="Generic API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/gripper/_index.md b/docs/operate/reference/components/gripper/_index.md
index 5dcd8f4127..ac309aed1b 100644
--- a/docs/operate/reference/components/gripper/_index.md
+++ b/docs/operate/reference/components/gripper/_index.md
@@ -50,7 +50,7 @@ There is currently no support for this component compatible with the Micro-RDK.
 
 ## API
 
-The [gripper API](/dev/reference/apis/components/gripper/) supports the following methods:
+The [gripper API](/reference/apis/components/gripper/) supports the following methods:
 
 {{< readfile "/static/include/components/apis/generated/gripper-table.md" >}}
 
diff --git a/docs/operate/reference/components/gripper/fake.md b/docs/operate/reference/components/gripper/fake.md
index e2e5f10429..aed8b8c6ad 100644
--- a/docs/operate/reference/components/gripper/fake.md
+++ b/docs/operate/reference/components/gripper/fake.md
@@ -55,7 +55,7 @@ See [GitHub](https://github.com/viamrobotics/rdk/blob/main/components/gripper/fa
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/gripper/" customTitle="Gripper API" noimage="true" %}}
+{{% card link="/reference/apis/components/gripper/" customTitle="Gripper API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/tutorials/services/plan-motion-with-arm-gripper/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/input-controller/_index.md b/docs/operate/reference/components/input-controller/_index.md
index 5ae3b87955..261cde8e49 100644
--- a/docs/operate/reference/components/input-controller/_index.md
+++ b/docs/operate/reference/components/input-controller/_index.md
@@ -20,10 +20,10 @@ The input controller API provides an API for configuring callbacks for events, a
 
 If you have a keyboard, mouse, elevator button panel, light power switch, joystick, gamepad, or video game controllers with which you want to control a robotic base, use an input controller component.
 
-This component supports devices like gamepads and joysticks that contain one or more [`Control`s](/dev/reference/apis/components/input-controller/#control-field) representing the individual axes and buttons on the device.
-To use the controller's inputs, you must [register callback functions](/dev/reference/apis/components/input-controller/#registercontrolcallback) to the [`Control`s](/dev/reference/apis/components/input-controller/#control-field) with the [`input` API](/dev/reference/apis/components/input-controller/).
+This component supports devices like gamepads and joysticks that contain one or more [`Control`s](/reference/apis/components/input-controller/#control-field) representing the individual axes and buttons on the device.
+To use the controller's inputs, you must [register callback functions](/reference/apis/components/input-controller/#registercontrolcallback) to the [`Control`s](/reference/apis/components/input-controller/#control-field) with the [`input` API](/reference/apis/components/input-controller/).
 
-The callback functions can then handle the [Events](/dev/reference/apis/components/input-controller/#getevents) that are sent when the `Control` is activated or moved.
+The callback functions can then handle the [Events](/reference/apis/components/input-controller/#getevents) that are sent when the `Control` is activated or moved.
 For example, when a specific button is pushed, the callback function registered to it can move another component, or print a specific output.
 
 The [base remote control service](/operate/reference/services/base-rc/) implements an input controller as a remote control for a base.
@@ -58,7 +58,7 @@ There is currently no support for this component compatible with the Micro-RDK.
 
 ## API
 
-The [input controller API](/dev/reference/apis/components/input-controller/) supports the following methods:
+The [input controller API](/reference/apis/components/input-controller/) supports the following methods:
 
 {{< readfile "/static/include/components/apis/generated/input_controller-table.md" >}}
 
diff --git a/docs/operate/reference/components/input-controller/fake.md b/docs/operate/reference/components/input-controller/fake.md
index 18716e5ad8..1fb4fce05d 100644
--- a/docs/operate/reference/components/input-controller/fake.md
+++ b/docs/operate/reference/components/input-controller/fake.md
@@ -15,8 +15,8 @@ toc_hide: true
 
 Configuring a `fake` input controller allows you to test an input controller communicating with your machine, without any physical hardware.
 
-This controller can have [Controls](/dev/reference/apis/components/input-controller/#control-field) defined in `attributes`, as seen in the "JSON Template" tab below.
-However, these Controls only ever return a single `PositionChangeAbs` event on the X axis, with the [Event.value](/dev/reference/apis/components/input-controller/#event-object) stuck at 0.7.
+This controller can have [Controls](/reference/apis/components/input-controller/#control-field) defined in `attributes`, as seen in the "JSON Template" tab below.
+However, these Controls only ever return a single `PositionChangeAbs` event on the X axis, with the [Event.value](/reference/apis/components/input-controller/#event-object) stuck at 0.7.
 
 {{< tabs >}}
 {{% tab name="Config Builder" %}}
@@ -63,7 +63,7 @@ The following attributes are available for `fake` input controllers:
 | ---- | ---- | --------- | ----------- |
 | `callback_delay_sec` | float | **Required** | The number of seconds between callbacks getting triggered. Random between 1 and 2 if not specified. `0` is not valid and will be overwritten by a random delay. |
 | `event_value` | float | Optional | Set the value of events returned. Random between -1 and 1 if not specified. |
-| `controls` | array | Optional | Set the [Controls](/dev/reference/apis/components/input-controller/#control-field) that are present on the controller. |
+| `controls` | array | Optional | Set the [Controls](/reference/apis/components/input-controller/#control-field) that are present on the controller. |
 
 {{< readfile "/static/include/components/test-control/input-controller-control.md" >}}
 
@@ -76,7 +76,7 @@ The following attributes are available for `fake` input controllers:
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/input-controller/" customTitle="Input controller API" noimage="true" %}}
+{{% card link="/reference/apis/components/input-controller/" customTitle="Input controller API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/tutorials/control/gamepad/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/input-controller/gamepad.md b/docs/operate/reference/components/input-controller/gamepad.md
index 2e7b40d91c..1be284e5da 100644
--- a/docs/operate/reference/components/input-controller/gamepad.md
+++ b/docs/operate/reference/components/input-controller/gamepad.md
@@ -87,7 +87,7 @@ You can also try setting `auto_reconnect` to `True`.
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/input-controller/" customTitle="Input controller API" noimage="true" %}}
+{{% card link="/reference/apis/components/input-controller/" customTitle="Input controller API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/tutorials/control/gamepad/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/input-controller/gpio.md b/docs/operate/reference/components/input-controller/gpio.md
index 60255f67fc..9179c7c5b8 100644
--- a/docs/operate/reference/components/input-controller/gpio.md
+++ b/docs/operate/reference/components/input-controller/gpio.md
@@ -28,8 +28,8 @@ Enter a name or use the suggested name for your input controller and click **Cre
 
 ![An example configuration for a GPIO input controller component](/components/input-controller/gpio-input-controller-ui-config.png)
 
-Click **{}** (Switch to advanced) to edit buttons and axes.
-Copy and paste the following attribute template into your input controller's **Attributes** box.
+Click **JSON** to edit buttons and axes.
+Copy and paste the following attribute template into the JSON editor.
 Then remove and fill in the attributes as applicable to your input controller, according to the table below.
 
 {{< tabs >}}
@@ -210,8 +210,8 @@ The following attributes are available for `gpio` input controllers:
 | Name | Type | Required? | Description |
 | ---- | ---- | --------- | ----------- |
 | `board` | string | **Required**| The name of the board component with GPIO or ADC pins to use as the controlling device. |
-| `buttons` | object | **Required** | The [Buttons](/dev/reference/apis/components/input-controller/#button-controls) available for control. These should be connected to the GPIO/ADC board. <br><br> <b>Each button has the following fields:</b> <br><ul><li><code>name</code>: Name of the Digital Interrupt the button/switch is connected to, as configured on the board component.</li><li><code>control</code>: The [Control](/dev/reference/apis/components/input-controller/#control-field) type to use when reporting events as this button's state is changed.</li><li><code>invert</code>: Boolean indicating if the digital input (high/low) should be inverted when reporting button Control value indicating button state.<br> This option is given because digital switches vary between high, `1`, and low, `0`, as their default at rest.<ul><li>*true:* `0` is pressed, and `1` is released.</li><li>*false (default):* `0` is released, and `1` is pressed.</li></ul></li><li><code>debounce_ms</code>: How many milliseconds to wait for the interrupt to settle. This is needed because some switches can be electrically noisy.</li></ul> |
-| `axes` | object | **Required** | The [Axes](/dev/reference/apis/components/input-controller/#axis-controls) available for control. These should be connected to the GPIO/ADC board.<br><br>**Each axis has the following fields:**<ul><li><code>name</code>: Name of the Analog Reader that reports ADC values for the axis Control, as configured on the board component.</li><li><code>control</code>: The [Control](/dev/reference/apis/components/input-controller/#control-field) type to use when reporting events as this axis's position is changed.</li><li><code>min</code>: The minimum ADC value that the analog reader can report as this axis's position changes. </li><li><code>max</code>: The maximum ADC value that the analog reader can report as this axis's position changes.</li><li><code>deadzone</code>: The absolute ADC value change from the neutral `0` point to still consider as a neutral position. This option is given so tiny wiggles on loose controls don't result in events being reported.</li><li><code>min_change</code>: The minimum absolute ADC value change from the previous ADC value reading that can occur before reporting a new [`PositionChangeAbs Event`](/dev/reference/apis/components/input-controller/#event-object). This option is given so tiny wiggles on loose controls don't result in events being reported.</li><li><code>bidirectional</code>: Boolean indicating if the axis changes position in 1 direction, like on an analog trigger or pedal, or 2, like on an analog control stick.<ul><li>*true:* The axis should report center, `0`, as halfway between the min/max ADC values.</li><li>*false:* `0` is still the neutral point of the axis, but only positive change values can be reported.</li></ul></li><li><code>poll_hz</code>: How many times per second to check for a new ADC reading that can generate an event.</li><li><code>invert</code>: Boolean indicating if the direction of the axis should be flipped when translating ADC value readings to the axis Control value indicating position change.<ul><li>*true:* flips the direction of the axis so that the minimum ADC value is reported as the maximum axis Control value.</li><li>*false:* keeps the direction of the axis the same, so that the minimum ADC value is reported as the minimum axis Control value.</li></ul></li></ul> |
+| `buttons` | object | **Required** | The [Buttons](/reference/apis/components/input-controller/#button-controls) available for control. These should be connected to the GPIO/ADC board. <br><br> <b>Each button has the following fields:</b> <br><ul><li><code>name</code>: Name of the Digital Interrupt the button/switch is connected to, as configured on the board component.</li><li><code>control</code>: The [Control](/reference/apis/components/input-controller/#control-field) type to use when reporting events as this button's state is changed.</li><li><code>invert</code>: Boolean indicating if the digital input (high/low) should be inverted when reporting button Control value indicating button state.<br> This option is given because digital switches vary between high, `1`, and low, `0`, as their default at rest.<ul><li>*true:* `0` is pressed, and `1` is released.</li><li>*false (default):* `0` is released, and `1` is pressed.</li></ul></li><li><code>debounce_ms</code>: How many milliseconds to wait for the interrupt to settle. This is needed because some switches can be electrically noisy.</li></ul> |
+| `axes` | object | **Required** | The [Axes](/reference/apis/components/input-controller/#axis-controls) available for control. These should be connected to the GPIO/ADC board.<br><br>**Each axis has the following fields:**<ul><li><code>name</code>: Name of the Analog Reader that reports ADC values for the axis Control, as configured on the board component.</li><li><code>control</code>: The [Control](/reference/apis/components/input-controller/#control-field) type to use when reporting events as this axis's position is changed.</li><li><code>min</code>: The minimum ADC value that the analog reader can report as this axis's position changes. </li><li><code>max</code>: The maximum ADC value that the analog reader can report as this axis's position changes.</li><li><code>deadzone</code>: The absolute ADC value change from the neutral `0` point to still consider as a neutral position. This option is given so tiny wiggles on loose controls don't result in events being reported.</li><li><code>min_change</code>: The minimum absolute ADC value change from the previous ADC value reading that can occur before reporting a new [`PositionChangeAbs Event`](/reference/apis/components/input-controller/#event-object). This option is given so tiny wiggles on loose controls don't result in events being reported.</li><li><code>bidirectional</code>: Boolean indicating if the axis changes position in 1 direction, like on an analog trigger or pedal, or 2, like on an analog control stick.<ul><li>*true:* The axis should report center, `0`, as halfway between the min/max ADC values.</li><li>*false:* `0` is still the neutral point of the axis, but only positive change values can be reported.</li></ul></li><li><code>poll_hz</code>: How many times per second to check for a new ADC reading that can generate an event.</li><li><code>invert</code>: Boolean indicating if the direction of the axis should be flipped when translating ADC value readings to the axis Control value indicating position change.<ul><li>*true:* flips the direction of the axis so that the minimum ADC value is reported as the maximum axis Control value.</li><li>*false:* keeps the direction of the axis the same, so that the minimum ADC value is reported as the minimum axis Control value.</li></ul></li></ul> |
 
 {{< readfile "/static/include/components/test-control/input-controller-control.md" >}}
 
@@ -224,7 +224,7 @@ The following attributes are available for `gpio` input controllers:
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/input-controller/" customTitle="Input controller API" noimage="true" %}}
+{{% card link="/reference/apis/components/input-controller/" customTitle="Input controller API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/tutorials/control/gamepad/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/input-controller/mux.md b/docs/operate/reference/components/input-controller/mux.md
index c05bdc58ca..dc9e158184 100644
--- a/docs/operate/reference/components/input-controller/mux.md
+++ b/docs/operate/reference/components/input-controller/mux.md
@@ -126,7 +126,7 @@ This tells the program loading the config to fully load the source components fi
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/input-controller/" customTitle="Input controller API" noimage="true" %}}
+{{% card link="/reference/apis/components/input-controller/" customTitle="Input controller API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/tutorials/control/gamepad/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/input-controller/webgamepad.md b/docs/operate/reference/components/input-controller/webgamepad.md
index 395dae2c9d..30a4b9de3a 100644
--- a/docs/operate/reference/components/input-controller/webgamepad.md
+++ b/docs/operate/reference/components/input-controller/webgamepad.md
@@ -73,7 +73,7 @@ For your security, the browser won't report a gamepad until an input has been se
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/input-controller/" customTitle="Input controller API" noimage="true" %}}
+{{% card link="/reference/apis/components/input-controller/" customTitle="Input controller API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/tutorials/control/gamepad/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/motor/_index.md b/docs/operate/reference/components/motor/_index.md
index c198b814cb..2b77a6e444 100644
--- a/docs/operate/reference/components/motor/_index.md
+++ b/docs/operate/reference/components/motor/_index.md
@@ -55,7 +55,7 @@ For additional configuration information, click on the model name:
 
 ## API
 
-The [motor API](/dev/reference/apis/components/motor/) supports the following methods:
+The [motor API](/reference/apis/components/motor/) supports the following methods:
 
 {{< readfile "/static/include/components/apis/generated/motor-table.md" >}}
 
diff --git a/docs/operate/reference/components/motor/dmc4000.md b/docs/operate/reference/components/motor/dmc4000.md
index f2402c31e2..667584a49c 100644
--- a/docs/operate/reference/components/motor/dmc4000.md
+++ b/docs/operate/reference/components/motor/dmc4000.md
@@ -280,6 +280,6 @@ resp, err := myMotorComponent.DoCommand(ctx, map[string]interface{}{"command": "
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/motor/" customTitle="Motor API" noimage="true" %}}
+{{% card link="/reference/apis/components/motor/" customTitle="Motor API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/motor/encoded-motor.md b/docs/operate/reference/components/motor/encoded-motor.md
index 831e57dc4a..4860a14487 100644
--- a/docs/operate/reference/components/motor/encoded-motor.md
+++ b/docs/operate/reference/components/motor/encoded-motor.md
@@ -177,7 +177,7 @@ Use the buttons to try turning your motor forwards or backwards at different pow
 
 ![Motor control panel.](/components/motor/control.png)
 
-For example, a rover with encoded motors following both an [angular](/dev/reference/apis/components/base/#spin) and [linear](/dev/reference/apis/components/base/#movestraight) velocity command:
+For example, a rover with encoded motors following both an [angular](/reference/apis/components/base/#spin) and [linear](/reference/apis/components/base/#movestraight) velocity command:
 
 {{<gif webm_src="/components/encoded-motor/base_moving.webm" mp4_src="/components/encoded-motor/base-moving.mp4" alt="A Viam rover turning in a half circle" max-width="400px" >}}
 
@@ -200,6 +200,6 @@ If the motor does not appear on the **CONTROL** tab, or if you notice unexpected
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/motor/" customTitle="Motor API" noimage="true" %}}
+{{% card link="/reference/apis/components/motor/" customTitle="Motor API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/motor/fake.md b/docs/operate/reference/components/motor/fake.md
index d82f2f7032..9ab5120cc7 100644
--- a/docs/operate/reference/components/motor/fake.md
+++ b/docs/operate/reference/components/motor/fake.md
@@ -84,7 +84,7 @@ However, if you would like to mock up a virtual placeholder for a real, physical
 | `max_power_pct` | float | Optional | Range is 0.06 to 1.0; sets a limit on maximum power percentage sent to the motor. <br> Default: `1.0` |
 | `pwm_freq` | int | Optional | Sets the PWM pulse frequency in Hz. Many motors operate optimally in the kHz range. <br> Default: `800` |
 | `encoder` | string | Optional | The name of an encoder attached to this motor. See [encoded motor](/operate/reference/components/motor/encoded-motor/). *If an encoder is configured on a `fake` motor, `ticks_per_rotation` becomes required.* |
-| `max_rpm` | float | Optional | An estimate of the max revolutions per minute (RPM) the motor will run at with full power under no load. The [`GoFor`](/dev/reference/apis/components/motor/#gofor) method calculates how much power to send to the motor as a percentage of `max_rpm`. If unknown, you can set it to 100, which will mean that giving 40 as the `rpm` argument to `GoFor` or `GoTo` will set it to 40% speed. *For non-encoded fake motors, this is required or a default is assigned.* <br> Default: `100` |
+| `max_rpm` | float | Optional | An estimate of the max revolutions per minute (RPM) the motor will run at with full power under no load. The [`GoFor`](/reference/apis/components/motor/#gofor) method calculates how much power to send to the motor as a percentage of `max_rpm`. If unknown, you can set it to 100, which will mean that giving 40 as the `rpm` argument to `GoFor` or `GoTo` will set it to 40% speed. *For non-encoded fake motors, this is required or a default is assigned.* <br> Default: `100` |
 | `ticks_per_rotation` | int | Optional* | **Required for calculations if an encoder is configured.* For a stepper motor, the number of steps in one full rotation (200 is common). For an encoded motor, how many encoder ticks in one full rotation. See data sheet (for a real motor). |
 | `dir_flip` | bool | Optional | Flips the direction of "forward" versus "backward" rotation. <br> Default: `false` |
 | `pins` | object | Optional | A struct that holds pin configuration information. |
@@ -124,6 +124,6 @@ Use the buttons to try turning your motor forwards or backwards at different pow
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/motor/" customTitle="Motor API" noimage="true" %}}
+{{% card link="/reference/apis/components/motor/" customTitle="Motor API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/motor/gpio-micro-rdk.md b/docs/operate/reference/components/motor/gpio-micro-rdk.md
index 518b37d1cd..6cf6f64115 100644
--- a/docs/operate/reference/components/motor/gpio-micro-rdk.md
+++ b/docs/operate/reference/components/motor/gpio-micro-rdk.md
@@ -165,6 +165,6 @@ See [PWM signals on `esp32` pins](/operate/reference/components/board/esp32/#pwm
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/motor/" customTitle="Motor API" noimage="true" %}}
+{{% card link="/reference/apis/components/motor/" customTitle="Motor API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/motor/gpio.md b/docs/operate/reference/components/motor/gpio.md
index 08410d30e3..5a09c940aa 100644
--- a/docs/operate/reference/components/motor/gpio.md
+++ b/docs/operate/reference/components/motor/gpio.md
@@ -126,7 +126,7 @@ The following attributes are available for `gpio` motors:
 | Name | Type | Required? | Description |
 | ---- | ---- | --------- | ----------- |
 | `board` | string | **Required** | `name` of the [board](/operate/reference/components/board/) to which the motor driver is wired. |
-| `max_rpm` | int | **Required** | This is an estimate of the maximum RPM the motor will run at with full power under no load. The [`GoFor`](/dev/reference/apis/components/motor/#gofor) method calculates how much power to send to the motor as a percentage of `max_rpm`. If unknown, you can set it to 100, which will mean that giving 40 as the `rpm` argument to `GoFor` or `GoTo` will set it to 40% speed. ***Not required** or available for [encoded](/operate/reference/components/motor/encoded-motor/) `gpio` motors.* |
+| `max_rpm` | int | **Required** | This is an estimate of the maximum RPM the motor will run at with full power under no load. The [`GoFor`](/reference/apis/components/motor/#gofor) method calculates how much power to send to the motor as a percentage of `max_rpm`. If unknown, you can set it to 100, which will mean that giving 40 as the `rpm` argument to `GoFor` or `GoTo` will set it to 40% speed. ***Not required** or available for [encoded](/operate/reference/components/motor/encoded-motor/) `gpio` motors.* |
 | `pins` | object | **Required** | A structure that holds pin configuration information; [see below](#pins). |
 | `min_power_pct` | float | Optional | Sets a limit on minimum power percentage sent to the motor. <br> Default: `0.0` |
 | `max_power_pct` | float | Optional | Range is 0.06 to 1.0; sets a limit on maximum power percentage sent to the motor. <br> Default: `1.0` |
@@ -212,6 +212,6 @@ Only the output side of the driver board is different in that more wires connect
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/motor/" customTitle="Motor API" noimage="true" %}}
+{{% card link="/reference/apis/components/motor/" customTitle="Motor API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/motor/gpiostepper.md b/docs/operate/reference/components/motor/gpiostepper.md
index cbc10911c5..8b4b789afc 100644
--- a/docs/operate/reference/components/motor/gpiostepper.md
+++ b/docs/operate/reference/components/motor/gpiostepper.md
@@ -144,6 +144,6 @@ See the data sheet of your stepper motor and stepper motor driver for informatio
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/motor/" customTitle="Motor API" noimage="true" %}}
+{{% card link="/reference/apis/components/motor/" customTitle="Motor API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/movement-sensor/_index.md b/docs/operate/reference/components/movement-sensor/_index.md
index f5dc96a722..5b7efdc2ff 100644
--- a/docs/operate/reference/components/movement-sensor/_index.md
+++ b/docs/operate/reference/components/movement-sensor/_index.md
@@ -55,7 +55,7 @@ For additional configuration information, click on the model name:
 
 ## API
 
-The [movement sensor API](/dev/reference/apis/components/movement-sensor/) supports the following methods:
+The [movement sensor API](/reference/apis/components/movement-sensor/) supports the following methods:
 
 Different movement sensors provide different data, so be aware that not all of the methods below are supported by all movement sensors.
 
@@ -86,12 +86,12 @@ For general configuration and development info, see:
 {{< cards >}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
-{{% card link="/data-ai/capture-data/capture-sync/" noimage="true" %}}
+{{% card link="/data/capture-sync/capture-and-sync-data/" noimage="true" %}}
 {{< /cards >}}
 
 To capture data from the movement sensor or use it for motion, see the following services:
 
-- [data management service](/data-ai/capture-data/capture-sync/): to capture and sync the movement sensor's data
+- [data management service](/data/capture-sync/capture-and-sync-data/): to capture and sync the movement sensor's data
 - [motion service](/operate/reference/services/motion/): to move machines or components of machines
 - [navigation service](/operate/reference/services/navigation/): to navigate with GPS
 - [SLAM service](/operate/reference/services/slam/): for mapping
diff --git a/docs/operate/reference/components/movement-sensor/accel-adxl345-micro-rdk.md b/docs/operate/reference/components/movement-sensor/accel-adxl345-micro-rdk.md
index 73aa3e5350..8625311b46 100644
--- a/docs/operate/reference/components/movement-sensor/accel-adxl345-micro-rdk.md
+++ b/docs/operate/reference/components/movement-sensor/accel-adxl345-micro-rdk.md
@@ -141,7 +141,7 @@ This panel presents the data collected by the movement sensor.
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/movement-sensor/" customTitle="Movement sensor API" noimage="true" %}}
+{{% card link="/reference/apis/components/movement-sensor/" customTitle="Movement sensor API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/movement-sensor/fake.md b/docs/operate/reference/components/movement-sensor/fake.md
index 67733cf860..df727b03f0 100644
--- a/docs/operate/reference/components/movement-sensor/fake.md
+++ b/docs/operate/reference/components/movement-sensor/fake.md
@@ -81,7 +81,7 @@ The sections in the panel include the position, orientation, angular velocity, l
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/movement-sensor/" customTitle="Movement sensor API" noimage="true" %}}
+{{% card link="/reference/apis/components/movement-sensor/" customTitle="Movement sensor API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/movement-sensor/gyro-mpu6050-micro-rdk.md b/docs/operate/reference/components/movement-sensor/gyro-mpu6050-micro-rdk.md
index 3a2f9dd5b2..453d3a6cf2 100644
--- a/docs/operate/reference/components/movement-sensor/gyro-mpu6050-micro-rdk.md
+++ b/docs/operate/reference/components/movement-sensor/gyro-mpu6050-micro-rdk.md
@@ -141,7 +141,7 @@ The sections in the panel include the angular velocity and linear acceleration.
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/movement-sensor/" customTitle="Movement sensor API" noimage="true" %}}
+{{% card link="/reference/apis/components/movement-sensor/" customTitle="Movement sensor API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/movement-sensor/merged.md b/docs/operate/reference/components/movement-sensor/merged.md
index 440e59f3de..a429a4b02f 100644
--- a/docs/operate/reference/components/movement-sensor/merged.md
+++ b/docs/operate/reference/components/movement-sensor/merged.md
@@ -92,7 +92,7 @@ For example:
 Configure an array of the `name` of each movement sensor you want to add to your machine as a merged resource in the attributes of the `merged` movement sensor model:
 
 - The name of each attribute represents the `Property` that the particular movement sensor supports, or the type of reading or measurement that it takes.
-- Get the properties supported by each model from its [model configuration documentation](/operate/reference/components/movement-sensor/#configuration), or by calling [`GetProperties()`](/dev/reference/apis/components/movement-sensor/#getproperties) on the sensor.
+- Get the properties supported by each model from its [model configuration documentation](/operate/reference/components/movement-sensor/#configuration), or by calling [`GetProperties()`](/reference/apis/components/movement-sensor/#getproperties) on the sensor.
 - Put the `name` of each movement sensor into the attribute array for the type of reading it supports.
   You can use the same sensor for multiple attributes if it supports multiple properties.
 
@@ -124,7 +124,7 @@ This panel presents the data collected by the movement sensor.
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/movement-sensor/" customTitle="Movement sensor API" noimage="true" %}}
+{{% card link="/reference/apis/components/movement-sensor/" customTitle="Movement sensor API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/movement-sensor/wheeled-odometry.md b/docs/operate/reference/components/movement-sensor/wheeled-odometry.md
index 5cc7675a0a..d44f64e231 100644
--- a/docs/operate/reference/components/movement-sensor/wheeled-odometry.md
+++ b/docs/operate/reference/components/movement-sensor/wheeled-odometry.md
@@ -27,8 +27,8 @@ _Wheeled odometry_ is the estimation of the rate of change of position, orientat
 Because of this method of estimation, you don't have to have a specific piece of movement sensor hardware to implement `wheeled-odometry` on your machine.
 This model uses [encoders](/operate/reference/components/encoder/) from [position reporting motors](/operate/reference/components/motor/) to get an odometry estimate of a wheeled base as it moves.
 
-With a configured `wheeled-odometry` movement sensor, your machine calculates an estimation of the position, orientation, linear velocity, and angular velocity of the wheeled base each time `time_interval_msec` elapses during a [session](/dev/reference/apis/sessions/).
-You can access these readings through the [movement sensor API](/dev/reference/apis/components/movement-sensor/#api).
+With a configured `wheeled-odometry` movement sensor, your machine calculates an estimation of the position, orientation, linear velocity, and angular velocity of the wheeled base each time `time_interval_msec` elapses during a [session](/reference/apis/sessions/).
+You can access these readings through the [movement sensor API](/reference/apis/components/movement-sensor/#api).
 For the best accuracy with odometry calculations, it is recommended you configure a time interval of less than `1000` milliseconds.
 
 After configuring a `wheeled-odometry` movement sensor, you can operate your base with Viam's built-in services like the [navigation service](/operate/reference/services/navigation/).
@@ -38,7 +38,7 @@ After configuring a `wheeled-odometry` movement sensor, you can operate your bas
 To prepare your machine, attach [encoders](/operate/reference/components/encoder/) to each of the position-reporting motors on your base to measure their rotation.
 
 - Select and configure motors that can report their own position, like [`gpio` motors](/operate/reference/components/motor/gpio/) with [encoders](/operate/reference/components/encoder/#configuration), or the [`odrive` module](https://github.com/viam-modules/odrive).
-  You can access this property of a configured motor through the [motor API's `GetProperties()`](/dev/reference/apis/components/motor/#getproperties).
+  You can access this property of a configured motor through the [motor API's `GetProperties()`](/reference/apis/components/motor/#getproperties).
 - Configure your rover as a [wheeled base component](/operate/reference/components/base/wheeled/).
   Make sure to configure the base width and circumference, as these measurements as a property of the base are vital for accurate odometry estimations by your movement sensor.
   This movement sensor accesses these values through the base's `GetProperties()` API method.
@@ -128,7 +128,7 @@ This panel presents the data collected by the movement sensor.
 For more configuration and usage info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/movement-sensor/" customTitle="Movement sensor API" noimage="true" %}}
+{{% card link="/reference/apis/components/movement-sensor/" customTitle="Movement sensor API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/power-sensor/_index.md b/docs/operate/reference/components/power-sensor/_index.md
index 3404549989..87844a85b0 100644
--- a/docs/operate/reference/components/power-sensor/_index.md
+++ b/docs/operate/reference/components/power-sensor/_index.md
@@ -51,7 +51,7 @@ There is currently no support for this component compatible with the Micro-RDK.
 
 ## API
 
-The [power sensor API](/dev/reference/apis/components/power-sensor/) supports the following methods:
+The [power sensor API](/reference/apis/components/power-sensor/) supports the following methods:
 
 {{< readfile "/static/include/components/apis/generated/power_sensor-table.md" >}}
 
@@ -73,7 +73,7 @@ For general configuration and development info, see:
 {{< cards >}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
-{{% card link="/data-ai/capture-data/capture-sync/" noimage="true" %}}
+{{% card link="/data/capture-sync/capture-and-sync-data/" noimage="true" %}}
 {{< /cards >}}
 
-To capture data from the power sensor and sync it in the cloud, see the [data management service](/data-ai/capture-data/capture-sync/).
+To capture data from the power sensor and sync it in the cloud, see the [data management service](/data/capture-sync/capture-and-sync-data/).
diff --git a/docs/operate/reference/components/power-sensor/fake.md b/docs/operate/reference/components/power-sensor/fake.md
index 2d18a4b504..f5397b9ca6 100644
--- a/docs/operate/reference/components/power-sensor/fake.md
+++ b/docs/operate/reference/components/power-sensor/fake.md
@@ -54,7 +54,7 @@ No attributes are available for `fake` power sensors.
 For general configuration and development info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/power-sensor/" customTitle="Power sensor API" noimage="true" %}}
+{{% card link="/reference/apis/components/power-sensor/" customTitle="Power sensor API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/sensor/_index.md b/docs/operate/reference/components/sensor/_index.md
index 234c71e14e..3d5b11da1d 100644
--- a/docs/operate/reference/components/sensor/_index.md
+++ b/docs/operate/reference/components/sensor/_index.md
@@ -67,7 +67,7 @@ If none of the existing models fit your use case, you can [create a modular reso
 
 ## API
 
-The [sensor API](/dev/reference/apis/components/sensor/) supports the following methods:
+The [sensor API](/reference/apis/components/sensor/) supports the following methods:
 
 {{< readfile "/static/include/components/apis/generated/sensor-table.md" >}}
 
@@ -82,7 +82,7 @@ For general configuration and development info, see:
 {{< cards >}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
-{{% card link="/data-ai/capture-data/capture-sync/" noimage="true" %}}
+{{% card link="/data/capture-sync/capture-and-sync-data/" noimage="true" %}}
 {{< /cards >}}
 
-To capture data from the sensor, see the [data management service](/data-ai/capture-data/capture-sync/).
+To capture data from the sensor, see the [data management service](/data/capture-sync/capture-and-sync-data/).
diff --git a/docs/operate/reference/components/sensor/fake.md b/docs/operate/reference/components/sensor/fake.md
index db088ebe70..52ac4a5242 100644
--- a/docs/operate/reference/components/sensor/fake.md
+++ b/docs/operate/reference/components/sensor/fake.md
@@ -45,7 +45,7 @@ No attributes are available for `fake` sensors.
 
 {{% alert title="Info" color="info" %}}
 
-A call to [`Readings()`](/dev/reference/apis/components/sensor/#getreadings) on a `fake` sensor always returns readings of `{"a":1, "b":2, "c":3}`.
+A call to [`Readings()`](/reference/apis/components/sensor/#getreadings) on a `fake` sensor always returns readings of `{"a":1, "b":2, "c":3}`.
 
 {{% /alert %}}
 
@@ -59,10 +59,10 @@ A call to [`Readings()`](/dev/reference/apis/components/sensor/#getreadings) on
 
 ## Next steps
 
-Check out the [sensor API](/dev/reference/apis/components/sensor/) or check out one of these guides:
+Check out the [sensor API](/reference/apis/components/sensor/) or check out one of these guides:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/sensor/" customTitle="Sensor API" noimage="true" %}}
-{{% card link="/data-ai/capture-data/capture-sync/" noimage="true" %}}
+{{% card link="/reference/apis/components/sensor/" customTitle="Sensor API" noimage="true" %}}
+{{% card link="/data/capture-sync/capture-and-sync-data/" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/sensor/ultrasonic-micro-rdk.md b/docs/operate/reference/components/sensor/ultrasonic-micro-rdk.md
index c1bb76f711..cd75fb2c49 100644
--- a/docs/operate/reference/components/sensor/ultrasonic-micro-rdk.md
+++ b/docs/operate/reference/components/sensor/ultrasonic-micro-rdk.md
@@ -117,10 +117,10 @@ The following attributes are available for `ultrasonic` sensors:
 
 ## Next steps
 
-Check out the [sensor API](/dev/reference/apis/components/sensor/) or check out one of these guides:
+Check out the [sensor API](/reference/apis/components/sensor/) or check out one of these guides:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/sensor/" customTitle="Sensor API" noimage="true" %}}
-{{% card link="/data-ai/capture-data/capture-sync/" noimage="true" %}}
+{{% card link="/reference/apis/components/sensor/" customTitle="Sensor API" noimage="true" %}}
+{{% card link="/data/capture-sync/capture-and-sync-data/" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/servo/_index.md b/docs/operate/reference/components/servo/_index.md
index 3773965a9e..2705e3972e 100644
--- a/docs/operate/reference/components/servo/_index.md
+++ b/docs/operate/reference/components/servo/_index.md
@@ -55,7 +55,7 @@ For additional configuration information, click on the model name:
 
 ## API
 
-The [servo API](/dev/reference/apis/components/servo/) supports the following methods:
+The [servo API](/reference/apis/components/servo/) supports the following methods:
 
 {{< readfile "/static/include/components/apis/generated/servo-table.md" >}}
 
diff --git a/docs/operate/reference/components/servo/fake.md b/docs/operate/reference/components/servo/fake.md
index 92738e1014..0f8d673803 100644
--- a/docs/operate/reference/components/servo/fake.md
+++ b/docs/operate/reference/components/servo/fake.md
@@ -55,7 +55,7 @@ See [GitHub](https://github.com/viamrobotics/rdk/blob/main/components/servo/fake
 For general configuration and development info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/servo/" customTitle="Servo API" noimage="true" %}}
+{{% card link="/reference/apis/components/servo/" customTitle="Servo API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/servo/gpio-micro-rdk.md b/docs/operate/reference/components/servo/gpio-micro-rdk.md
index b83fb5af6a..67d1aec457 100644
--- a/docs/operate/reference/components/servo/gpio-micro-rdk.md
+++ b/docs/operate/reference/components/servo/gpio-micro-rdk.md
@@ -153,7 +153,7 @@ Refer to your servo's data sheet for [pulse-width modulation (PWM)](https://docs
 For general configuration and development info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/servo/" customTitle="Servo API" noimage="true" %}}
+{{% card link="/reference/apis/components/servo/" customTitle="Servo API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/servo/gpio.md b/docs/operate/reference/components/servo/gpio.md
index a810b2a6c9..a8024f4f57 100644
--- a/docs/operate/reference/components/servo/gpio.md
+++ b/docs/operate/reference/components/servo/gpio.md
@@ -114,7 +114,7 @@ Refer to your servo's data sheet for [pulse-width modulation (PWM)](https://docs
 For general configuration and development info, see:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/servo/" customTitle="Servo API" noimage="true" %}}
+{{% card link="/reference/apis/components/servo/" customTitle="Servo API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{% card link="/operate/control/web-app/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/components/switch/_index.md b/docs/operate/reference/components/switch/_index.md
index ce4d0bff0b..0fc2b15728 100644
--- a/docs/operate/reference/components/switch/_index.md
+++ b/docs/operate/reference/components/switch/_index.md
@@ -47,7 +47,7 @@ There is currently no support for this component compatible with the Micro-RDK.
 
 ## API
 
-The [switch API](/dev/reference/apis/components/switch/) supports the following methods:
+The [switch API](/reference/apis/components/switch/) supports the following methods:
 
 {{< readfile "/static/include/components/apis/generated/switch-table.md" >}}
 
diff --git a/docs/operate/reference/components/switch/fake.md b/docs/operate/reference/components/switch/fake.md
index c4e7d317f6..377e209886 100644
--- a/docs/operate/reference/components/switch/fake.md
+++ b/docs/operate/reference/components/switch/fake.md
@@ -93,9 +93,9 @@ If your fake switch is not working as expected:
 
 ## Next steps
 
-Check out the [switch API](/dev/reference/apis/components/switch/) or check out one of these guides:
+Check out the [switch API](/reference/apis/components/switch/) or check out one of these guides:
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/components/switch/" customTitle="Switch API" noimage="true" %}}
+{{% card link="/reference/apis/components/switch/" customTitle="Switch API" noimage="true" %}}
 {{% card link="/operate/modules/configure-modules/" noimage="true" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/kinematic-chain-config.md b/docs/operate/reference/kinematic-chain-config.md
index 3ff8656d09..d3dc8e633e 100644
--- a/docs/operate/reference/kinematic-chain-config.md
+++ b/docs/operate/reference/kinematic-chain-config.md
@@ -17,7 +17,7 @@ If you are developing a new {{< glossary_tooltip term_id="modular-resource" text
 
 The [motion service](/operate/reference/services/motion/) uses these intermediate reference frames when calculating movements.
 
-For example, an [arm](/operate/reference/components/arm/) has a reference frame originating where the arm is attached to a surface, but it also has links and joints whose frames of reference matter when attempting to move the arm to a [pose](/operate/mobility/orientation-vector/) with [`MoveToPosition()`](/dev/reference/apis/components/arm/#movetoposition).
+For example, an [arm](/operate/reference/components/arm/) has a reference frame originating where the arm is attached to a surface, but it also has links and joints whose frames of reference matter when attempting to move the arm to a [pose](/operate/mobility/orientation-vector/) with [`MoveToPosition()`](/reference/apis/components/arm/#movetoposition).
 
 This file can be a JSON file like [this xArm6 file](https://github.com/viam-modules/viam-ufactory-xarm/blob/main/arm/xarm6_kinematics.json), or a [<file>.URDF</file> file](https://industrial-training-master.readthedocs.io/en/melodic/_source/session3/Intro-to-URDF.html).
 
@@ -34,8 +34,8 @@ Additionally, if you are making your own robot and defining new drivers, incorre
 {{% alert title="Info" color="info" %}}
 
 These reference frames are ingested by the frame system.
-They are not exposed in the [client SDKs](/dev/reference/sdks/), with one exception.
-If your resource is an [arm component](/operate/reference/components/arm/), you can use the [`GetKinematics()`](/dev/reference/apis/components/arm/#getkinematics) method to access its kinematics information.
+They are not exposed in the [client SDKs](/reference/sdks/), with one exception.
+If your resource is an [arm component](/operate/reference/components/arm/), you can use the [`GetKinematics()`](/reference/apis/components/arm/#getkinematics) method to access its kinematics information.
 
 {{% /alert %}}
 
diff --git a/docs/operate/reference/prepare/odroid-c4-setup.md b/docs/operate/reference/prepare/odroid-c4-setup.md
index baa8108a57..a74c812816 100644
--- a/docs/operate/reference/prepare/odroid-c4-setup.md
+++ b/docs/operate/reference/prepare/odroid-c4-setup.md
@@ -71,7 +71,7 @@ sudo apt update && sudo apt upgrade
 {{< cards >}}
 {{% card link="/operate/modules/configure-modules/" %}}
 {{% card link="/operate/hello-world/tutorial-desk-safari/" %}}
-{{% card link="/dev/tools/tutorials/" %}}
+{{% card link="/tutorials/" %}}
 {{< /cards >}}
 
 ## Troubleshooting
diff --git a/docs/operate/reference/prepare/pumpkin.md b/docs/operate/reference/prepare/pumpkin.md
index 5fb939e4eb..74f8e9c55a 100644
--- a/docs/operate/reference/prepare/pumpkin.md
+++ b/docs/operate/reference/prepare/pumpkin.md
@@ -256,7 +256,7 @@ Copy and paste the following json object into your board's attributes field.
 {{< cards >}}
 {{% card link="/operate/modules/configure-modules/" %}}
 {{% card link="/operate/hello-world/tutorial-desk-safari/" %}}
-{{% card link="/dev/tools/tutorials/" %}}
+{{% card link="/tutorials/" %}}
 {{< /cards >}}
 
 ## Need assistance?
diff --git a/docs/operate/reference/services/base-rc/_index.md b/docs/operate/reference/services/base-rc/_index.md
index 681ccf6de4..5da5e84b5e 100644
--- a/docs/operate/reference/services/base-rc/_index.md
+++ b/docs/operate/reference/services/base-rc/_index.md
@@ -127,7 +127,7 @@ The base remote control service supports the following methods:
 
 The following code examples assume that you have a machine configured with a [base](/operate/reference/components/base/) named `"my_base"`, [input controller](/operate/reference/components/input-controller/) named `"my_controller"`, and base remote control service named `"my_base_rc_service"`.
 Make sure to add the required code to connect to your machine and import any required packages at the top of your code file.
-Go to your machine's **CONNECT** tab and select the **SDK code sample** page for sample code to connect to your machine.
+Go to your machine's **CONNECT** tab and select **API keys** to get your credentials, then use the code sample to connect to your machine.
 
 {{% /alert %}}
 
diff --git a/docs/operate/reference/services/discovery/_index.md b/docs/operate/reference/services/discovery/_index.md
index 3362aabeac..2d37e22b75 100644
--- a/docs/operate/reference/services/discovery/_index.md
+++ b/docs/operate/reference/services/discovery/_index.md
@@ -32,7 +32,7 @@ Users of your module can then:
 
 To see this in action, see [webcam discovery](/operate/reference/components/camera/webcam/#find-a-video-path-using-a-discovery-service) as an example.
 
-To interact with a discovery service programmatically, use the [discovery service API](/dev/reference/apis/services/discovery/).
+To interact with a discovery service programmatically, use the [discovery service API](/reference/apis/services/discovery/).
 
 ## Configuration
 
@@ -64,6 +64,6 @@ There is currently no support for this component compatible with the Micro-RDK.
 
 ## API
 
-The [discovery service API](/dev/reference/apis/services/discovery/) supports the following methods:
+The [discovery service API](/reference/apis/services/discovery/) supports the following methods:
 
 {{< readfile "/static/include/services/apis/generated/discovery-table.md" >}}
diff --git a/docs/operate/reference/services/frame-system/_index.md b/docs/operate/reference/services/frame-system/_index.md
index b4683643f1..8f791a618f 100644
--- a/docs/operate/reference/services/frame-system/_index.md
+++ b/docs/operate/reference/services/frame-system/_index.md
@@ -45,7 +45,7 @@ You can configure a reference frame within the frame system for each of your mac
 
 1. Find the configuration card for the component you want to add a frame to.
 
-1. Click **+ Add frame**.
+1. Click the **Frame** button.
 
 1. Leave the default values, or edit the frame configuration.
    The frame configuration is a JSON object with the following parameters:
@@ -179,13 +179,13 @@ The resulting tree of reference frames looks like:
 
 ## Access the frame system
 
-The [Machine Management API](/dev/reference/apis/robot/) supplies the following methods to interact with the frame system:
+The [Machine Management API](/reference/apis/robot/) supplies the following methods to interact with the frame system:
 
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----- | ----------- |
-| [`FrameSystemConfig`](/dev/reference/apis/robot/#framesystemconfig) | Return a topologically sorted list of all the reference frames monitored by the frame system. |
-| [`TransformPose`](/dev/reference/apis/robot/#transformpose) | Transform a given source Pose from the original reference frame to a new destination reference frame. |
+| [`FrameSystemConfig`](/reference/apis/robot/#framesystemconfig) | Return a topologically sorted list of all the reference frames monitored by the frame system. |
+| [`TransformPose`](/reference/apis/robot/#transformpose) | Transform a given source Pose from the original reference frame to a new destination reference frame. |
 
 ## Additional transforms
 
@@ -203,9 +203,9 @@ The frame system uses the supplemental transform to determine where the arm shou
 
 ### Transform usage
 
-- You can pass a detected object's frame information to the `supplemental_transforms` parameter in your calls to Viam's motion service's [`GetPose`](/dev/reference/apis/services/motion/#getpose) method.
+- You can pass a detected object's frame information to the `supplemental_transforms` parameter in your calls to Viam's motion service's [`GetPose`](/reference/apis/services/motion/#getpose) method.
 - Functions of some services and components also take in a `WorldState` parameter, which includes a `transforms` property.
-- [`TransformPose`](/dev/reference/apis/robot/#transformpose) has the option to take in these additional transforms.
+- [`TransformPose`](/reference/apis/robot/#transformpose) has the option to take in these additional transforms.
 
 ### Visualize components and frames
 
diff --git a/docs/operate/reference/services/generic/_index.md b/docs/operate/reference/services/generic/_index.md
index e60495bcf6..1f15466d65 100644
--- a/docs/operate/reference/services/generic/_index.md
+++ b/docs/operate/reference/services/generic/_index.md
@@ -18,9 +18,9 @@ date: "2022-01-01"
 # SMEs:
 ---
 
-The _generic_ service API enables you to add support for unique types of services that do not already have an [appropriate API](/dev/reference/apis/#service-apis) defined for them.
+The _generic_ service API enables you to add support for unique types of services that do not already have an [appropriate API](/reference/apis/#service-apis) defined for them.
 
-For example, when writing code to manage [simultaneous localization and mapping (SLAM)](/operate/reference/services/slam/) for your machine, it makes sense to use the existing [SLAM API](/dev/reference/apis/services/slam/#api), which provides specific functionality required for generating accurate maps of an environment.
+For example, when writing code to manage [simultaneous localization and mapping (SLAM)](/operate/reference/services/slam/) for your machine, it makes sense to use the existing [SLAM API](/reference/apis/services/slam/#api), which provides specific functionality required for generating accurate maps of an environment.
 However, if you want to create a new service to monitor your machine's CPU and RAM usage for example, you need very different functionality that isn't currently exposed in any API.
 Instead, you can use the generic service API to add support for your unique type of service, like local system monitoring, to your machine.
 
@@ -34,7 +34,7 @@ There are no built-in generic service models (other than `fake`).
 The generic service API only supports the `DoCommand` method.
 If you use the generic API, your module needs to define any and all service functionality and pass it through `DoCommand`.
 
-Whenever possible, it is best to use an [existing service API](/dev/reference/apis/services/) instead of generic so that you do not have to replicate code.
+Whenever possible, it is best to use an [existing service API](/reference/apis/services/) instead of generic so that you do not have to replicate code.
 If you want to use most of an existing API but need just a few other functions, try using the `DoCommand` endpoint and extra parameters to add custom functionality to an existing API, instead of using the generic service.
 
 {{% /alert %}}
@@ -47,7 +47,7 @@ If you want to use most of an existing API but need just a few other functions,
 
 ## API
 
-The [generic service API](/dev/reference/apis/services/generic/) supports the following method:
+The [generic service API](/reference/apis/services/generic/) supports the following method:
 
 {{< readfile "/static/include/services/apis/generated/generic_service-table.md" >}}
 
diff --git a/docs/operate/reference/services/motion/_index.md b/docs/operate/reference/services/motion/_index.md
index 3b3ae097ad..005b4edef6 100644
--- a/docs/operate/reference/services/motion/_index.md
+++ b/docs/operate/reference/services/motion/_index.md
@@ -159,7 +159,7 @@ You'll also need to check for it in your validate function, since it is not buil
 
 ## API
 
-The [motion service API](/dev/reference/apis/services/motion/) supports the following methods:
+The [motion service API](/reference/apis/services/motion/) supports the following methods:
 
 {{< readfile "/static/include/services/apis/generated/motion-table.md" >}}
 
diff --git a/docs/operate/reference/services/motion/constraints.md b/docs/operate/reference/services/motion/constraints.md
index c6d3a7e51e..b4d92d07ed 100644
--- a/docs/operate/reference/services/motion/constraints.md
+++ b/docs/operate/reference/services/motion/constraints.md
@@ -13,7 +13,7 @@ date: "2022-01-01"
 ---
 
 You can constrain the motion of your machine using the motion service's built-in constraint options.
-Constraints are passed as arguments to the [`Move`](/dev/reference/apis/services/motion/#move) method.
+Constraints are passed as arguments to the [`Move`](/reference/apis/services/motion/#move) method.
 
 The following constraints are available:
 
diff --git a/docs/operate/reference/services/navigation/_index.md b/docs/operate/reference/services/navigation/_index.md
index e6f7cc69d2..7bc2912cad 100644
--- a/docs/operate/reference/services/navigation/_index.md
+++ b/docs/operate/reference/services/navigation/_index.md
@@ -20,23 +20,23 @@ date: "2022-01-01"
 The navigation service is the stateful definition of Viam's [motion service](/operate/reference/services/motion/).
 It uses GPS to autonomously navigate a rover [base](/operate/reference/components/base/) to user-defined waypoints.
 
-Configure your base with a navigation service, add waypoints, and set the mode of the service to [**Waypoint**](/dev/reference/apis/services/navigation/#setmode) to move your rover along a defined path at your desired motion configuration.
+Configure your base with a navigation service, add waypoints, and set the mode of the service to [**Waypoint**](/reference/apis/services/navigation/#setmode) to move your rover along a defined path at your desired motion configuration.
 
 ## Requirements
 
 You must configure a [base](/operate/reference/components/base/) with [movement sensors](/operate/reference/components/movement-sensor/) as part of your machine to configure a navigation service.
 
-To use the navigation service, configure a stack of movement sensors that implement the following methods in their {{< glossary_tooltip term_id="model" text="models'" >}} implementations of the [movement sensor API](/dev/reference/apis/components/movement-sensor/#api):
+To use the navigation service, configure a stack of movement sensors that implement the following methods in their {{< glossary_tooltip term_id="model" text="models'" >}} implementations of the [movement sensor API](/reference/apis/components/movement-sensor/#api):
 
-- [`GetPosition()`](/dev/reference/apis/components/movement-sensor/#getposition)
-- [`GetCompassHeading()`](/dev/reference/apis/components/movement-sensor/#getcompassheading)
-- [`GetProperties()`](/dev/reference/apis/components/movement-sensor/#getproperties)
+- [`GetPosition()`](/reference/apis/components/movement-sensor/#getposition)
+- [`GetCompassHeading()`](/reference/apis/components/movement-sensor/#getcompassheading)
+- [`GetProperties()`](/reference/apis/components/movement-sensor/#getproperties)
 
 The base should implement the following:
 
-- [`SetVelocity()`](/dev/reference/apis/components/base/#setvelocity)
-- [`GetGeometries()`](/dev/reference/apis/components/base/#getgeometries)
-- [`GetProperties()`](/dev/reference/apis/components/base/#getproperties)
+- [`SetVelocity()`](/reference/apis/components/base/#setvelocity)
+- [`GetGeometries()`](/reference/apis/components/base/#getgeometries)
+- [`GetProperties()`](/reference/apis/components/base/#getproperties)
 
 See [navigation concepts](#navigation-concepts) for more info on how to implement and use movement sensors taking these measurements.
 
@@ -180,7 +180,7 @@ To make sure your rover base's autonomous GPS navigation with the navigation ser
 Add [reference frames](/operate/reference/services/frame-system/#configuration) to your rover [base](/operate/reference/components/base/) and [movement sensor](/operate/reference/components/movement-sensor/) configurations:
 
 - Navigate to the **CONFIGURE** tab of your machine's page.
-- Find your base configuration card and click **+ Add frame**.
+- Find your base configuration card and click the **Frame** button.
 - Since you haven't adjusted any parameters yet, the default reference frame will be shown for your base:
 
   {{<imgproc src="/services/navigation/select-base-frame.png" resize="700x" style="width: 300px" alt="Frame card for a base with the default reference frame settings">}}
@@ -194,7 +194,7 @@ Add [reference frames](/operate/reference/services/frame-system/#configuration)
 
   {{<imgproc src="/services/navigation/configure-base-geometry.png" resize="700x" style="width: 300px" alt="The frame card for the base.">}}
 
-- Add a frame to your movement sensor configuration by clicking **+ Add frame**.
+- Add a frame to your movement sensor configuration by clicking the **Frame** button.
 - Set the `parent` within the frame card to the name of your base.
 - Give the movement sensor a `translation` that reflects where it is mounted on your base, measuring the coordinates with respect to the origin of the base.
   In other words, designate the base origin as `(0,0,0)` and measure the distance between that and the origin of the sensor to obtain the coordinates.
@@ -221,7 +221,7 @@ Then, to calibrate your frame system for the most accurate autonomous GPS naviga
 
 ## API
 
-The [navigation service API](/dev/reference/apis/services/navigation/) supports the following methods:
+The [navigation service API](/reference/apis/services/navigation/) supports the following methods:
 
 {{< readfile "/static/include/services/apis/generated/navigation-table.md" >}}
 
@@ -267,7 +267,7 @@ heading, err := gps.CompassHeading(context.Background(), nil)
 Use compass heading readings to determine the _bearing_ of your machine, or, the [cardinal direction](https://en.wikipedia.org/wiki/Cardinal_direction) that your machine is facing.
 
 To read compass headings, [configure a capable movement sensor](/operate/reference/components/movement-sensor/#configuration) on your machine.
-Then use the movement sensor API's [`GetCompassHeading()`](/dev/reference/apis/components/movement-sensor/#getcompassheading) method to get readings from the sensor.
+Then use the movement sensor API's [`GetCompassHeading()`](/reference/apis/components/movement-sensor/#getcompassheading) method to get readings from the sensor.
 
 ### Orientation
 
@@ -291,7 +291,7 @@ The `GetOrientation` readings will report orientations relative to that initial
 
 To read orientation, first [configure a capable movement sensor](/operate/reference/components/movement-sensor/#configuration) on your machine.
 Additionally, follow [these instructions](/operate/reference/services/frame-system/#configuration) to configure the geometries of each component of your machine within the frame system.
-Then use the movement sensor API's [`GetOrientation()`](/dev/reference/apis/components/movement-sensor/#getorientation) method to get orientation readings.
+Then use the movement sensor API's [`GetOrientation()`](/reference/apis/components/movement-sensor/#getorientation) method to get orientation readings.
 
 ### Angular velocity
 
@@ -312,7 +312,7 @@ angularVelocity, err := imu.AngularVelocity(context.Background(), nil)
 Use angular velocity readings to determine the speed and direction at which your machine is rotating.
 
 To get an angular velocity reading, first [configure a capable movement sensor](/operate/reference/components/movement-sensor/#configuration) on your machine.
-Then use the movement sensor API's [`GetAngularVelocity()`](/dev/reference/apis/components/movement-sensor/#getangularvelocity) method to get angular velocity readings from the sensor.
+Then use the movement sensor API's [`GetAngularVelocity()`](/reference/apis/components/movement-sensor/#getangularvelocity) method to get angular velocity readings from the sensor.
 
 ### Position
 
@@ -334,7 +334,7 @@ Use position readings to determine the GPS coordinates of an object in 3D space
 These position readings reflect the _absolute_ position of components.
 
 To get a position, [configure a capable movement sensor](/operate/reference/components/movement-sensor/#configuration) on your machine.
-Then use the movement sensor API's [`GetPosition()`](/dev/reference/apis/components/movement-sensor/#getposition) method to get position readings from the sensor.
+Then use the movement sensor API's [`GetPosition()`](/reference/apis/components/movement-sensor/#getposition) method to get position readings from the sensor.
 
 ### Linear velocity
 
@@ -355,7 +355,7 @@ linearVelocity, err := imu.LinearVelocity(context.Background(), nil)
 Use linear velocity readings to determine the speed at which your machine is moving through space.
 
 To get linear velocity, [configure a capable movement sensor](/operate/reference/components/movement-sensor/#configuration) on your machine.
-Then use the movement sensor API's [`GetLinearVelocity()`](/dev/reference/apis/components/movement-sensor/#getlinearvelocity) method to get linear velocity readings from the sensor.
+Then use the movement sensor API's [`GetLinearVelocity()`](/reference/apis/components/movement-sensor/#getlinearvelocity) method to get linear velocity readings from the sensor.
 
 ### Linear acceleration
 
@@ -376,7 +376,7 @@ linearAcceleration, err := imu.LinearAcceleration(context.Background(), nil)
 You can use linear acceleration readings to determine the rate of change of the [linear velocity](/operate/reference/services/navigation/#linear-velocity) of your machine, or, the acceleration at which your machine is moving through space.
 
 To get linear acceleration, [configure a capable movement sensor](/operate/reference/components/movement-sensor/#configuration) on your machine.
-Then use the movement sensor API's [`GetLinearAcceleration()`](/dev/reference/apis/components/movement-sensor/#getlinearacceleration) method to get linear acceleration readings from the sensor.
+Then use the movement sensor API's [`GetLinearAcceleration()`](/reference/apis/components/movement-sensor/#getlinearacceleration) method to get linear acceleration readings from the sensor.
 
 ## Next steps
 
diff --git a/docs/operate/reference/services/slam/_index.md b/docs/operate/reference/services/slam/_index.md
index ff85464c65..30ac5e2281 100644
--- a/docs/operate/reference/services/slam/_index.md
+++ b/docs/operate/reference/services/slam/_index.md
@@ -55,7 +55,7 @@ Click the model name for configuration instructions.
 
 ## API
 
-The [SLAM service API](/dev/reference/apis/services/slam/) supports the following methods:
+The [SLAM service API](/reference/apis/services/slam/) supports the following methods:
 
 {{< readfile "/static/include/services/apis/generated/slam-table.md" >}}
 
@@ -70,6 +70,6 @@ While in a slam session, you should:
 - use a machine that can go smoothly over bumps and transitions between flooring areas
 - drive at a moderate speed
 - when using a wheeled base, try to include an [odometry movement sensor](/operate/reference/components/movement-sensor/wheeled-odometry/). This helps the SLAM algorithm keep track of where the machine is moving.
-- it is important to note that the [adxl345 accelerometer](https://github.com/viam-modules/analog-devices/) on the [Viam Rover 1](/dev/reference/try-viam/rover-resources/rover-tutorial-1/) **will not** satisfy the movement sensor requirement.
+- it is important to note that the [adxl345 accelerometer](https://github.com/viam-modules/analog-devices/) on the [Viam Rover 1](/try/rover-resources/rover-tutorial-1/) **will not** satisfy the movement sensor requirement.
 
 You can find additional assistance in the [Troubleshooting section](/manage/troubleshoot/troubleshoot/).
diff --git a/docs/operate/reference/services/slam/cartographer/_index.md b/docs/operate/reference/services/slam/cartographer/_index.md
index be0fbd5e3d..61453bedff 100644
--- a/docs/operate/reference/services/slam/cartographer/_index.md
+++ b/docs/operate/reference/services/slam/cartographer/_index.md
@@ -116,7 +116,7 @@ To create a new map, follow the instructions below.
    - **Maximum range (meters)**: Set the maximum range of your `rplidar`.
      See [config params](#config_params) for suggested values for RPLidar A1 and A3.
 
-   If you would like to tune additional Cartographer parameters, you can the click **{}** button to switch to the advanced view, then edit the `config_params` from there.
+   If you would like to tune additional Cartographer parameters, click the **JSON** button to switch to the JSON editor, then edit the `config_params` from there.
    See the [`config_params`](#config_params) section for more information on the other parameters.
 
    To save your changes, click the **Save** button in the top right corner of the page.
@@ -125,7 +125,7 @@ To create a new map, follow the instructions below.
 
 3. (Optional) Configure cartographer to use cloudSLAM:
 
-   On the `SLAM` service configuration pane, click the **{}** button to switch to advanced views and set the `use_cloud_slam` field to **true**. This setting disables local mapping to limit cpu usage in favor of using cloudSLAM.
+   On the `SLAM` service configuration pane, click the **JSON** button to switch to the JSON editor and set the `use_cloud_slam` field to **true**. This setting disables local mapping to limit CPU usage in favor of using cloudSLAM.
 
    In addition, your configured LiDAR camera and movement sensor must have data capture enabled. See the [cloudSLAM](../cloudslam/) documentation for more information on how to configure the feature on your machine and how to use cloudSLAM.
 
@@ -295,7 +295,7 @@ In the meantime, your machine will show up at the map's origin (with the `(x,y)`
 
 ### Localize only
 
-In this mode, the `cartographer` module on your machine executes the Cartographer algorithm to find its position on a map. This mode is better when using [motion planning's MoveOnMap](/dev/reference/apis/services/motion/#moveonmap) because the map will not be modified.
+In this mode, the `cartographer` module on your machine executes the Cartographer algorithm to find its position on a map. This mode is better when using [motion planning's MoveOnMap](/reference/apis/services/motion/#moveonmap) because the map will not be modified.
 
 1.  Configure your `cartographer` SLAM service:
 
diff --git a/docs/operate/reference/services/slam/cloudslam/_index.md b/docs/operate/reference/services/slam/cloudslam/_index.md
index 0858570e61..f138047bad 100644
--- a/docs/operate/reference/services/slam/cloudslam/_index.md
+++ b/docs/operate/reference/services/slam/cloudslam/_index.md
@@ -19,7 +19,7 @@ SLAM Algorithms can have varying levels of resource requirements in order to run
 In order to better support running SLAM on resource limited machines, Viam provides a service to run SLAM algorithms for machines in the cloud as well as management of the maps generated in their location.
 
 CloudSLAM can be used with both a live machine or with previously captured data in your location.
-In [live mode](#mapping-with-a-live-machine-online-mode) using the [data management service](/data-ai/capture-data/capture-sync/) and the [cloudslam-wrapper](https://github.com/viam-modules/cloudslam-wrapper) module, Viam takes your LiDAR camera and movement sensor data from your local machine and sends it to the cloudslam server.
+In [live mode](#mapping-with-a-live-machine-online-mode) using the [data management service](/data/capture-sync/capture-and-sync-data/) and the [cloudslam-wrapper](https://github.com/viam-modules/cloudslam-wrapper) module, Viam takes your LiDAR camera and movement sensor data from your local machine and sends it to the cloudslam server.
 The CloudSLAM server will then process that data and produce a map that can then be used on any machine in your location.
 When using an [offline machine](#using-previously-captured-data-offline-mode), you can select data from specific sensors over a period of time to build a map with.
 
@@ -76,8 +76,8 @@ To use CloudSLAM on a live machine, you must meet the following requirements:
 To use CloudSLAM you must enable data capture and configure your `cloudslam-wrapper` SLAM service:
 
 {{< alert title="Tip: Managing Data Capture" color="tip" >}}
-Note that when the [data management service](/data-ai/capture-data/capture-sync/) is enabled, it continuously monitors and syncs your machine’s sensor data while the machine is running.
-To avoid incurring charges while not in use, [turn off data capture for your sensors](/data-ai/capture-data/capture-sync/#stop-data-capture-or-data-sync) once you have finished your SLAM session.
+Note that when the [data management service](/data/capture-sync/capture-and-sync-data/) is enabled, it continuously monitors and syncs your machine’s sensor data while the machine is running.
+To avoid incurring charges while not in use, [turn off data capture for your sensors](/data/capture-sync/capture-and-sync-data/#stop-data-capture-or-data-sync) once you have finished your SLAM session.
 {{< /alert >}}
 
 {{< tabs name="Create new map">}}
@@ -92,7 +92,7 @@ To avoid incurring charges while not in use, [turn off data capture for your sen
 
    On the panel that appears, you can manage the capturing and syncing functions.
    You can also specify the **directory**, the sync **interval**, and any **tags** to apply to captured data.
-   See the [data management service](/data-ai/capture-data/capture-sync/) for more information.
+   See the [data management service](/data/capture-sync/capture-and-sync-data/) for more information.
 
 2. Enable data capture for your camera, and for your movement sensor if you would like to use IMU data, odometry data, or both:
 
@@ -175,7 +175,7 @@ You _do not_ need to configure data capture on the individual IMU and odometer.
 
 5. Configure Cartographer to use cloudslam.
 
-   In your `cartographer` config card, click the **{}** button to switch to advanced views and set the `use_cloud_slam` field to **true**. This setting disables local mapping to limit cpu usage in favor of using cloudslam.
+   In your `cartographer` config card, click the **JSON** button to switch to the JSON editor and set the `use_cloud_slam` field to **true**. This setting disables local mapping to limit CPU usage in favor of using cloudslam.
 
 {{% /tab %}}
 {{% tab name="JSON Example" %}}
@@ -183,7 +183,7 @@ You _do not_ need to configure data capture on the individual IMU and odometer.
 This example JSON configuration:
 
 - adds the `viam:rplidar`, `viam:cartographer`, and `viam:cloudslam-wrapper` modules
-- configures the `viam:slam:cartographer`, `viam:cloudslam-wrapper:cloudslam`, and the [data management](/data-ai/capture-data/capture-sync/) services
+- configures the `viam:slam:cartographer`, `viam:cloudslam-wrapper:cloudslam`, and the [data management](/data/capture-sync/capture-and-sync-data/) services
 - adds a `viam:lidar:rplidar` camera with data capture configured
 
   ```json {class="line-numbers linkable-line-numbers"}
@@ -357,7 +357,7 @@ Example of previously captured IMU data:
 From your machine's **Location** page, click **View SLAM library**, and click **Make new map** on the top right and specify a map name or click **Update map** next to an existing map.
 
 1. Enter the **Machine name**, **Camera name**, and optionally the **Movement Sensor name** of the components whose previously captured data you want to use to create or update a map.
-   If your machine has been deleted, you can alternatively specify the [**machine ID**](/dev/reference/apis/fleet/#find-machine-id).
+   If your machine has been deleted, you can alternatively specify the [**machine ID**](/reference/apis/fleet/#find-machine-id).
 2. Select the timeframe of the data you'd like to use.
 3. At the bottom, you can see the total number of PCD files and movement sensor data points that will be processed.
 4. Click **Generate map**.
@@ -432,10 +432,10 @@ The following attributes are available for `viam:cloudslam-wrapper:cloudslam`
 | `slam_service` | string | **Required** | The name of the SLAM Service on the machine to use with cloudslam. |
 | `api_key` | string | **Required** | An [API key](/manage/manage/access/) with location owner or higher permission. |
 | `api_key_id` | string | **Required** | The associated API key ID with the API key. |
-| `organization_id` | string | **Required** | The organization ID of your [organization](/dev/reference/glossary/#organization). |
-| `location_id` | string | **Required** | The location ID of your [location](/dev/reference/glossary/#location). |
-| `machine_id` | string | **Required** | The machine ID of your [machine](/dev/reference/apis/fleet/#find-machine-id). |
-| `machine_part_id` | string | Optional | The machine part ID of your [machine part](/dev/reference/apis/fleet/#find-machine-id). Used for local package creation and updating mode. |
+| `organization_id` | string | **Required** | The organization ID of your [organization](/reference/glossary/#organization). |
+| `location_id` | string | **Required** | The location ID of your [location](/reference/glossary/#location). |
+| `machine_id` | string | **Required** | The machine ID of your [machine](/reference/apis/fleet/#find-machine-id). |
+| `machine_part_id` | string | Optional | The machine part ID of your [machine part](/reference/apis/fleet/#find-machine-id). Used for local package creation and updating mode. |
 | `viam_version` | string | Optional | The version of viam-server to use with CloudSLAM. Defaults to `stable`. |
 | `slam_version` | string | Optional | The version of cartographer to use with CloudSLAM. Defaults to `stable`. |
 | `camera_freq_hz` | float | Optional | The expected capture frequency for your camera/lidar components. Defaults to `5`. |
diff --git a/docs/operate/reference/services/vision/detector_3d_segmenter.md b/docs/operate/reference/services/vision/detector_3d_segmenter.md
index 7940e33ece..2449a20af9 100644
--- a/docs/operate/reference/services/vision/detector_3d_segmenter.md
+++ b/docs/operate/reference/services/vision/detector_3d_segmenter.md
@@ -14,9 +14,9 @@ aliases:
 # SMEs: Bijan, Khari
 ---
 
-_Changed in [RDK v0.2.36 and API v0.1.118](/dev/reference/changelog/#vision-service)_
+_Changed in [RDK v0.2.36 and API v0.1.118](/reference/changelog/#vision-service)_
 
-The `detector_3d_segmenter` vision service model takes 2D bounding boxes from an [object detector](/dev/reference/apis/services/vision/#detections), and, using the intrinsic parameters of the chosen camera, projects the pixels in the bounding box to points in 3D space.
+The `detector_3d_segmenter` vision service model takes 2D bounding boxes from an [object detector](/reference/apis/services/vision/#detections), and, using the intrinsic parameters of the chosen camera, projects the pixels in the bounding box to points in 3D space.
 If the chosen camera is not equipped to do projections from 2D to 3D, then this vision model will fail.
 The label and the pixels associated with the 2D detections become the label and point cloud associated with the 3D segmenter.
 
@@ -104,7 +104,7 @@ Click the **Save** button in the top right corner of the page and proceed to [te
 
 ## Test your segmenter
 
-The following code uses the [`GetObjectPointClouds`](/dev/reference/apis/services/vision/#getobjectpointclouds) method to run a segmenter vision model on an image from the machine's camera `"cam1"`:
+The following code uses the [`GetObjectPointClouds`](/reference/apis/services/vision/#getobjectpointclouds) method to run a segmenter vision model on an image from the machine's camera `"cam1"`:
 
 {{< tabs >}}
 {{% tab name="Python" %}}
diff --git a/docs/operate/reference/services/vision/mlmodel.md b/docs/operate/reference/services/vision/mlmodel.md
index 81c7ad4cbd..d41feb41cb 100644
--- a/docs/operate/reference/services/vision/mlmodel.md
+++ b/docs/operate/reference/services/vision/mlmodel.md
@@ -16,7 +16,7 @@ aliases:
 # SMEs: Bijan, Khari
 ---
 
-_Changed in [RDK v0.2.36 and API v0.1.118](/dev/reference/changelog/#vision-service)_
+_Changed in [RDK v0.2.36 and API v0.1.118](/reference/changelog/#vision-service)_
 
 The `mlmodel` {{< glossary_tooltip term_id="model" text="model" >}} of the Viam vision service supports machine learning detectors and classifiers that draw bounding boxes or return class labels based on a deployed TensorFlow Lite, TensorFlow, PyTorch, or ONNX ML model.
 
@@ -29,14 +29,14 @@ Before configuring your `mlmodel` detector or classifier, you need to:
 
 <h4>1. Train or upload an ML model</h4>
 
-You can add an [existing model](/data-ai/ai/deploy/) or [train a TensorFlow or a TensorFlow Lite](/data-ai/train/train-tf-tflite/) or [another model](/data-ai/train/train/) for object detection and classification using your data in the [Viam Cloud](/data-ai/capture-data/capture-sync/).
+You can add an [existing model](/vision/configure/) or [train a TensorFlow or a TensorFlow Lite](/train/train-a-model/) or [another model](/train/custom-training-scripts/) for object detection and classification using your data in the [Viam Cloud](/data/capture-sync/capture-and-sync-data/).
 
 {{% /manualcard %}}
 {{% manualcard %}}
 
 <h4>2. Deploy your ML model</h4>
 
-To use ML models with your machine, use a suitable [ML model service](/data-ai/ai/deploy/) to deploy and run the model.
+To use ML models with your machine, use a suitable [ML model service](/vision/configure/) to deploy and run the model.
 
 {{% /manualcard %}}
 {{< /cards >}}
@@ -58,7 +58,7 @@ Select the ML model service your model is deployed on from the **ML Model** drop
 Add a default camera for the vision service to use.
 
 Edit other attributes as applicable according to the table below.
-You can edit optional attributes in raw JSON by clicking **{}** (Switch to advanced) on the right side of your service panel.
+You can edit optional attributes in raw JSON by clicking **JSON** on the right side of your service panel.
 
 {{% /tab %}}
 {{% tab name="JSON Template" %}}
@@ -130,7 +130,7 @@ The following attributes are available for an `mlmodel` detector or classifier:
 <!-- prettier-ignore -->
 | Parameter | Type | Required? | Description |
 | --------- | ---- | --------- | ----------- |
-| `mlmodel_name` | string | **Required** | The name of the [ML model service](/data-ai/ai/deploy/) you want to use the model from. |
+| `mlmodel_name` | string | **Required** | The name of the [ML model service](/vision/configure/) you want to use the model from. |
 | `camera_name` | string | Optional | The default camera to use for calls to  `DetectionsFromCamera`, `ClassificationsFromCamera`, or `GetObjectPointClouds`. |
 | `remap_output_names` | object | Optional | The names of your output tensors, mapped to the service requirements. See [Tensor names](#tensor-names) for more information. |
 | `remap_input_names` | object | Optional | The name of your input tensor, mapped to the service requirements. See [Tensor names](#tensor-names) for more information. |
@@ -152,7 +152,7 @@ Both the `mlmodel` detector and classifier require that the input and output ten
   - The _input tensor_ must be named `image`
   - The _output tensor_ must be named `probability`
 
-If you [trained a TensforFLow or TensorFlow Lite ML model using Viam](/data-ai/train/train-tf-tflite/), your `mlmodel` tensors are already named in this fashion, and you can proceed to [test your detector or classifier](#test-your-detector-or-classifier).
+If you [trained a TensforFLow or TensorFlow Lite ML model using Viam](/train/train-a-model/), your `mlmodel` tensors are already named in this fashion, and you can proceed to [test your detector or classifier](#test-your-detector-or-classifier).
 However, if you uploaded your own ML model, or are using one from the [registry](https://app.viam.com/registry), you may need to remap your tensor names to meet this requirement, and should follow the instructions to [remap tensor names](#remap-tensor-names).
 
 #### Remap tensor names
@@ -227,7 +227,7 @@ The feature is only available for classifiers that were uploaded after September
 
 {{<gif webm_src="/services/vision/mug-classifier.webm" mp4_src="/services/vision/mug-classifier.mp4" alt="A classification model run against an image containing a mug." max-width="250px" class="alignright">}}
 
-If you have images stored in the [Viam Cloud](/data-ai/capture-data/capture-sync/), you can run your classifier against your images.
+If you have images stored in the [Viam Cloud](/data/capture-sync/capture-and-sync-data/), you can run your classifier against your images.
 
 1. Navigate to the [Data tab](https://app.viam.com/data/view) and click on the **Images** subtab.
 2. Click on an image to open the side menu, and select the **Actions** tab under the **Data** tab.
diff --git a/docs/operate/reference/viam-micro-server/_index.md b/docs/operate/reference/viam-micro-server/_index.md
index 6bc5596337..7be6825f87 100644
--- a/docs/operate/reference/viam-micro-server/_index.md
+++ b/docs/operate/reference/viam-micro-server/_index.md
@@ -28,19 +28,19 @@ For most use cases, you will [build your own firmware](/operate/install/setup-mi
 
 ## Support
 
-[Client API](/dev/reference/apis/) usage with the Micro-RDK currently supports the following {{< glossary_tooltip term_id="resource" text="resources" >}}:
+[Client API](/reference/apis/) usage with the Micro-RDK currently supports the following {{< glossary_tooltip term_id="resource" text="resources" >}}:
 
 {{< cards >}}
-{{% relatedcard link="/dev/reference/apis/components/base/" %}}
-{{% relatedcard link="/dev/reference/apis/components/board/" %}}
-{{% relatedcard link="/dev/reference/apis/components/camera/" %}}
-{{% relatedcard link="/dev/reference/apis/components/encoder/" %}}
-{{% relatedcard link="/dev/reference/apis/components/movement-sensor/" %}}
-{{% relatedcard link="/dev/reference/apis/components/motor/" %}}
-{{% relatedcard link="/dev/reference/apis/components/sensor/" %}}
-{{% relatedcard link="/dev/reference/apis/components/servo/" %}}
-{{% relatedcard link="/dev/reference/apis/components/generic/" %}}
-{{% relatedcard link="/dev/reference/apis/services/data/" %}}
+{{% relatedcard link="/reference/apis/components/base/" %}}
+{{% relatedcard link="/reference/apis/components/board/" %}}
+{{% relatedcard link="/reference/apis/components/camera/" %}}
+{{% relatedcard link="/reference/apis/components/encoder/" %}}
+{{% relatedcard link="/reference/apis/components/movement-sensor/" %}}
+{{% relatedcard link="/reference/apis/components/motor/" %}}
+{{% relatedcard link="/reference/apis/components/sensor/" %}}
+{{% relatedcard link="/reference/apis/components/servo/" %}}
+{{% relatedcard link="/reference/apis/components/generic/" %}}
+{{% relatedcard link="/reference/apis/services/data/" %}}
 {{< /cards >}}
 
 ## Next steps
diff --git a/docs/operate/reference/viam-server/_index.md b/docs/operate/reference/viam-server/_index.md
index 2429214255..0547b67c83 100644
--- a/docs/operate/reference/viam-server/_index.md
+++ b/docs/operate/reference/viam-server/_index.md
@@ -79,7 +79,7 @@ Alternatively, if you are having issues with a module, try the **Restart module*
 
 There are a few updates that may make your machine temporarily unavailable:
 
-- [`viam-agent` updating itself](/manage/reference/viam-agent/#version_control-version-management-for-viam-agent-and-viam-server)
+- [`viam-agent` updating itself](/manage/reference/viam-agent/#version-control)
 - [`viam-agent` updating `viam-server`](/manage/reference/viam-agent/#update-or-downgrade-viam-server-with-viam-agent)
 - configuration updates
 
@@ -466,7 +466,7 @@ Note that this method may not work for versions that are too old, as Homebrew do
 ## Next steps
 
 {{< cards >}}
-{{% card link="/dev/reference/apis/" %}}
+{{% card link="/reference/apis/" %}}
 {{% card link="/operate/modules/configure-modules/" %}}
 {{% card link="/operate/install/setup/" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/viam-server/debug-endpoints.md b/docs/operate/reference/viam-server/debug-endpoints.md
index 1ec7219b3e..c1c5271ff2 100644
--- a/docs/operate/reference/viam-server/debug-endpoints.md
+++ b/docs/operate/reference/viam-server/debug-endpoints.md
@@ -88,7 +88,7 @@ Available layout options include:
 ## Next Steps
 
 {{< cards >}}
-{{% card link="/manage/troubleshoot/troubleshoot/" %}}
+{{% card link="/monitor/troubleshoot/" %}}
 {{% card link="/operate/reference/viam-server/manage-viam-server/" %}}
-{{% card link="/dev/tools/common-errors/" %}}
+{{% card link="/monitor/troubleshoot/" %}}
 {{< /cards >}}
diff --git a/docs/operate/reference/viam-server/manage-viam-server.md b/docs/operate/reference/viam-server/manage-viam-server.md
index 0439fc21b1..2a3a4397ad 100644
--- a/docs/operate/reference/viam-server/manage-viam-server.md
+++ b/docs/operate/reference/viam-server/manage-viam-server.md
@@ -155,7 +155,7 @@ Follow the manual steps to update the standalone version.
 {{% tab name="Installed with viam-agent" %}}
 
 By default, `viam-agent` automatically upgrades to the latest stable version of `viam-server`.
-You can change this behavior in the [`version_control` settings of your machine](/manage/reference/viam-agent/#version_control-version-management-for-viam-agent-and-viam-server).
+You can change this behavior in the [`version_control` settings of your machine](/manage/reference/viam-agent/#version-control).
 For example, the following `version_control` configuration will always update to the latest stable release of `viam-agent` and the latest development release of `viam-server`:
 
 ```json {class="line-numbers linkable-line-numbers" data-line=""}
@@ -212,7 +212,7 @@ We recommend running `brew upgrade viam-server` on a regular basis.
 {{< tabs >}}
 {{% tab name="Installed with viam-agent" %}}
 
-To disable automatic updates, configure the [`version_control` settings of your machine](/manage/reference/viam-agent/#version_control-version-management-for-viam-agent-and-viam-server) to a specific version number.
+To disable automatic updates, configure the [`version_control` settings of your machine](/manage/reference/viam-agent/#version-control) to a specific version number.
 For example, the following `version_control` configuration pins `viam-server` to version `0.52.1`, preventing `viam-server` from updating to a more recent version:
 
 ```json {class="line-numbers linkable-line-numbers" data-line=""}
diff --git a/docs/organization/_index.md b/docs/organization/_index.md
new file mode 100644
index 0000000000..eb365f296f
--- /dev/null
+++ b/docs/organization/_index.md
@@ -0,0 +1,10 @@
+---
+linkTitle: "Admin and access"
+title: "Admin and access"
+weight: 225
+layout: "docs"
+type: "docs"
+no_list: true
+manualLink: "/organization/overview/"
+description: "Manage access, roles, authentication, data regions, and billing for your organization."
+---
diff --git a/docs/manage/manage/access.md b/docs/organization/access.md
similarity index 79%
rename from docs/manage/manage/access.md
rename to docs/organization/access.md
index 088e011911..5aa4a6eea1 100644
--- a/docs/manage/manage/access.md
+++ b/docs/organization/access.md
@@ -1,7 +1,7 @@
 ---
 linkTitle: "Control access"
-title: "Manage Access with Role-Based Access Control"
-weight: 20
+title: "Manage access with role-based access control"
+weight: 10
 layout: "docs"
 type: "docs"
 no_list: true
@@ -12,7 +12,10 @@ aliases:
 ---
 
 To collaborate with others on your machines, you can grant users permissions for individual machines or entire locations.
-You can use the [web UI](https://app.viam.com) or the [Viam mobile app](/manage/troubleshoot/teleoperate/default-interface/#viam-mobile-app) to grant or revoke organization owner or operator access to users or API keys.
+You can use the [web UI](https://app.viam.com) or the Viam mobile app to grant or revoke organization owner or operator access to users or API keys.
+
+For an overview of the resource hierarchy and how permissions work at each level, see [Organizations, locations, and access](/organization/overview/).
+For details on what each role can do, see [Permissions](/organization/rbac/).
 
 ## Grant access
 
@@ -34,7 +37,7 @@ You must have the **Owner** role to be able to grant permissions.
 
 7. Select a role to assign to the user.
 
-   For more information on roles and the permissions they provide, see [Manage access with Role-Based Access Control](/manage/manage/rbac/).
+   For more information on roles and the permissions they provide, see [Manage access with Role-Based Access Control](/organization/rbac/).
 
 8. Click **invite**.
 
@@ -67,13 +70,10 @@ You must have the **Owner** role to be able to limit permissions.
 2. Click on **Settings**.
 3. Find the **Members** section of the organization settings page.
 4. Click on the user to open the access settings for the user.
-5. Either change the role of the user from owner to operator with the dropdown or click on **Limit access** and change the resource the user has [access](/manage/manage/rbac/).
+5. Either change the role of the user from owner to operator with the dropdown or click on **Limit access** and change the resource the user has [access](/organization/rbac/).
    You can also remove the user by clicking on **Remove user**.
    {{< imgproc alt="The user invitation menu on the Organization settings page." src="/fleet/app-usage/limit-access.png" resize="800x" declaredimensions=true class="shadow" >}}
 
-{{< table >}}
-{{< /table >}}
-
 ### Remove an organization from a shared location
 
 You must have the **Owner** role to be able to share locations.
@@ -85,6 +85,13 @@ You must have the **Owner** role to be able to share locations.
 5. Click the **X** to the right of the organization you want to remove.
 6. Click **Remove**.
 
+## Manage API key access
+
+You can also grant access through [API keys](/organization/api-keys/) scoped to an organization, location, or machine.
+API keys are useful for programmatic access from SDK scripts, CI/CD pipelines, and automated workflows.
+
+See [Manage API keys](/organization/api-keys/) for instructions on creating, rotating, and revoking API keys.
+
 ## Collaborate safely
 
 When you or your collaborators change the configuration of a machine or a group of machines, `viam-server` automatically synchronizes the configuration and updates the running resources within 15 seconds.
@@ -97,4 +104,4 @@ You can also revert to an earlier configuration from the History tab.
 If someone updates the configuration and saves it while you are editing, Viam will show you a warning that your configuration is out of date when you try to save.
 {{% /hiddencontent %}}
 
-Machine [configuration](/operate/modules/configure-modules/) and machine [code](/dev/reference/sdks/) is intentionally kept separate, allowing you to keep track of versioning and debug issues separately.
+Machine [configuration](/hardware/configure-hardware/) and machine [code](/reference/sdks/) is intentionally kept separate, allowing you to keep track of versioning and debug issues separately.
diff --git a/docs/organization/api-keys.md b/docs/organization/api-keys.md
new file mode 100644
index 0000000000..4024bde9a3
--- /dev/null
+++ b/docs/organization/api-keys.md
@@ -0,0 +1,225 @@
+---
+linkTitle: "Manage API keys"
+title: "Manage API keys"
+weight: 25
+layout: "docs"
+type: "docs"
+no_list: true
+description: "Create, rotate, and manage API keys for programmatic access to your organization, locations, and machines."
+---
+
+API keys provide programmatic access to your Viam resources.
+Each API key is scoped to a specific level of the [resource hierarchy](/organization/overview/) and assigned a role, so you can control exactly what it can access.
+
+Use API keys to authenticate SDK connections, CLI scripts, and automated workflows.
+
+## Choose the right scope
+
+Every API key is scoped to an organization, location, or machine, and assigned an Owner or Operator role.
+Follow the principle of least privilege: grant the narrowest scope that lets the key do its job.
+
+| Use case                                 | Recommended scope   |
+| ---------------------------------------- | ------------------- |
+| SDK connection to one machine            | Machine, Operator   |
+| Automated deployment script for one site | Location, Owner     |
+| CI/CD pipeline for module uploads        | Organization, Owner |
+| Monitoring dashboard for a location      | Location, Operator  |
+
+For details on what each role can do, see [Permissions](/organization/rbac/).
+
+## Create an API key
+
+{{< tabs >}}
+{{% tab name="Web UI" %}}
+
+1. Navigate to the level where you want to create the key:
+   - **Organization**: Click the organization name in the top navigation bar, then **Settings**. Find the **API keys** section.
+   - **Machine**: Navigate to the machine's page and click the **CONNECT** tab.
+1. Click **Generate key** or **Add key**.
+1. Give the key a descriptive name (for example, `production-deploy-script` or `warehouse-monitoring`).
+1. Copy the key and key ID immediately. You will not be able to see the key again.
+
+{{% /tab %}}
+{{% tab name="CLI" %}}
+
+Create a key at the organization, location, or machine level:
+
+```sh {class="command-line" data-prompt="$" data-output="2-3"}
+viam organizations api-key create --org-id <org-id> --name "deploy-pipeline"
+Key ID: xxxx-xxxx
+Key: xxxx-xxxx-xxxx
+```
+
+```sh {class="command-line" data-prompt="$" data-output="2-3"}
+viam locations api-key create --location-id <location-id> --name "warehouse-monitoring"
+Key ID: xxxx-xxxx
+Key: xxxx-xxxx-xxxx
+```
+
+```sh {class="command-line" data-prompt="$" data-output="2-3"}
+viam machines api-key create --machine-id <machine-id> --name "arm-control"
+Key ID: xxxx-xxxx
+Key: xxxx-xxxx-xxxx
+```
+
+{{% /tab %}}
+{{% tab name="Python" %}}
+
+```python
+from viam.app.app_client import APIKeyAuthorization
+from viam.app.viam_client import ViamClient
+
+client = await ViamClient.create_from_dial_options(...)
+api_key, api_key_id = await client.app_client.create_key(
+    org_id="<org-id>",
+    authorizations=[
+        APIKeyAuthorization(
+            role="owner",
+            resource_type="location",
+            resource_id="<location-id>"
+        )
+    ],
+    name="warehouse-monitoring"
+)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+{{< alert title="Important" color="note" >}}
+Store your API key securely.
+Viam does not store the key value after creation.
+If you lose it, you must rotate or create a new key.
+{{< /alert >}}
+
+## List API keys
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+keys = await client.app_client.list_keys(org_id="<org-id>")
+for key in keys:
+    print(f"{key.api_key_id}: {key.name}")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+keys, err := client.ListKeys(ctx, "<org-id>")
+for _, key := range keys {
+    fmt.Printf("%s: %s\n", key.APIKeyID, key.Name)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Rotate a key
+
+Key rotation lets you generate a new key value while keeping the same authorizations.
+This is useful for periodic credential rotation or when a key may have been exposed.
+
+To rotate without downtime:
+
+1. Create a new key with the same scope and role.
+1. Update all consumers (scripts, SDK connections) to use the new key.
+1. Verify the new key works.
+1. Delete the old key.
+
+You can also rotate in place with the SDK, which generates a new key value and invalidates the old one immediately:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+new_key, new_key_id = await client.app_client.rotate_key(id="<api-key-id>")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+newKey, newKeyID, err := client.RotateKey(ctx, "<api-key-id>")
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+{{< alert title="Caution" color="caution" >}}
+`rotate_key` invalidates the old key immediately.
+Any consumer still using the old key will lose access.
+For zero-downtime rotation, use the create-then-delete approach instead.
+{{< /alert >}}
+
+## Rename a key
+
+Give a key a more descriptive name:
+
+```go
+err := client.RenameKey(ctx, "<api-key-id>", "new-descriptive-name")
+```
+
+{{< alert title="Note" color="note" >}}
+`RenameKey` is currently available in the Go SDK only.
+{{< /alert >}}
+
+## Delete a key
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+await client.app_client.delete_key(id="<api-key-id>")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+err := client.DeleteKey(ctx, "<api-key-id>")
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Use an API key
+
+### SDK connection
+
+Use an API key to connect to a machine from your code:
+
+```python
+from viam.robot.client import RobotClient
+
+opts = RobotClient.Options.with_api_key(
+    api_key="<your-api-key>",
+    api_key_id="<your-api-key-id>"
+)
+robot = await RobotClient.at_address("<machine-address>", opts)
+```
+
+### CLI authentication
+
+Authenticate the CLI with an API key:
+
+```sh {class="command-line" data-prompt="$"}
+viam login api-key --key-id <key-id> --key <key>
+```
+
+To manage multiple API keys, use CLI profiles:
+
+```sh {class="command-line" data-prompt="$"}
+viam profiles add --profile-name production --key-id <key-id> --key <key>
+```
+
+See [CLI authentication](/organization/overview/#cli-authentication) for more details.
+
+## Best practices
+
+- **Name keys descriptively.** Include the purpose and scope: `production-deploy-ci`, `warehouse-3-monitoring`, `dev-testing`.
+- **Use the narrowest scope possible.** A script that only reads sensor data from one machine should use a machine-scoped Operator key, not an org-scoped Owner key.
+- **Rotate keys periodically.** Use the create-then-delete pattern to avoid downtime.
+- **Revoke keys when people leave.** List all keys with `list_keys` and delete any associated with departed team members.
+- **Do not commit keys to version control.** Use environment variables or secret management tools.
diff --git a/docs/organization/billing.md b/docs/organization/billing.md
new file mode 100644
index 0000000000..eecd026def
--- /dev/null
+++ b/docs/organization/billing.md
@@ -0,0 +1,106 @@
+---
+linkTitle: "Billing"
+title: "Billing and payment"
+weight: 50
+layout: "docs"
+type: "docs"
+description: "View usage, manage payment methods, download invoices, and set billing alerts for your organization."
+aliases:
+  - /fleet/billing/
+  - /billing/
+  - /manage/reference/billing/
+  - /reference/account/billing/
+---
+
+The billing page shows your organization's current usage, payment method, and invoice history.
+You must be an organization owner to access it.
+
+To open the billing page, click the organization name in the top navigation bar and select **Payment and billing**.
+
+## Understand your usage
+
+The billing page displays three sections about your current and upcoming charges:
+
+**Current month usage**: your total charges so far for the current billing period.
+
+**Next invoice**: the date and estimated amount of your next invoice.
+
+**Monthly usage breakdown**: an itemized list of charges by resource type.
+Each line shows the resource, the quantity used, and the cost.
+Resource types include:
+
+| Category      | Resources                                                                                                                  |
+| ------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Storage       | Image and video data, tabular/JSON data, recent data, pipeline sink data, packages, config history, logs, ML training logs |
+| Compute       | Standard compute, recent data compute, pipeline sink compute                                                               |
+| Data transfer | Cloud data upload, cloud data egress, binary data egress, tabular data egress                                              |
+| Other         | Remote control sessions, per-machine charges, trigger notifications                                                        |
+
+For pricing details, see [Viam pricing](https://www.viam.com/product/pricing).
+
+## Manage your payment method
+
+The billing page shows the payment method on file: the last four digits and expiration date for a credit card, or the account type and last four digits for a US bank account.
+
+### Add a payment method
+
+1. On the billing page, under **Payment method**, click **Add payment method**.
+1. Enter your credit card details or US bank account information.
+1. Submit the form.
+
+### Replace a payment method
+
+To replace the payment method on file, remove the existing one and add a new one:
+
+1. Under **Payment method**, click **Remove payment method**.
+1. Confirm the removal in the dialog.
+1. Click **Add payment method** and enter the new payment details.
+
+Add the new payment method immediately after removing the old one.
+Organizations without a valid payment method may experience service limitations.
+
+## View and download invoices
+
+The **Invoices** section lists all invoices for your organization.
+Each invoice shows:
+
+| Column    | Description                                                            |
+| --------- | ---------------------------------------------------------------------- |
+| Date      | The billing period end date                                            |
+| Amount    | The total charge for that period                                       |
+| Status    | **Paid**, **Overdue**, **Free** (no charge), or **Payment Processing** |
+| Paid date | When payment was received                                              |
+| Download  | Link to download the invoice as a PDF                                  |
+
+Invoices are generated monthly or annually depending on your billing configuration.
+
+To download an invoice, click **Download (PDF)** next to the billing period you need.
+
+### Overdue invoices
+
+If your organization has an overdue balance, a banner appears at the top of the billing page.
+Contact [billing@viam.com](mailto:billing@viam.com) to resolve overdue payments.
+
+## Set billing alerts
+
+You can receive an email notification when your monthly spend exceeds a threshold you set:
+
+1. Scroll to the bottom of the billing page.
+1. Click **Set amount**.
+1. Enter a monthly threshold in dollars.
+
+When your current month's usage exceeds this amount, you receive an email notification.
+
+## Free credits
+
+If your organization has free trial credits, a banner at the top of the billing page shows the remaining credit amount.
+Usage within the credit amount does not require a payment method on file.
+
+## Help
+
+For questions about your bill, email [billing@viam.com](mailto:billing@viam.com).
+Expect a response within 1 to 3 business days.
+
+## Programmatic access
+
+You can retrieve billing information programmatically using the [billing client API](/reference/apis/billing-client/).
diff --git a/docs/manage/manage/data-regions.md b/docs/organization/data-regions.md
similarity index 68%
rename from docs/manage/manage/data-regions.md
rename to docs/organization/data-regions.md
index 76051b6b47..9b916bba82 100644
--- a/docs/manage/manage/data-regions.md
+++ b/docs/organization/data-regions.md
@@ -2,22 +2,24 @@
 title: "Choose data region"
 linkTitle: "Choose data region"
 description: "Configure where in the world Viam stores your cloud data."
-weight: 30
+weight: 40
 type: "docs"
 tags: ["data region", "region", "data continent", "compliance", "performance"]
 ---
 
 When you specify a data region, Viam stores all data captured by your machines in that region.
+This includes sensor readings, images, and other captured data.
+Choosing the right region helps you meet data residency requirements and can reduce latency for data queries.
+
 By default, new organizations store data in North America.
-Locations shared across multiple organizations store data in the primary organization region.
+Locations shared across multiple organizations store data in the primary organization's region.
 
 ## Supported regions
 
 Viam supports the following data regions:
 
-- **North America** (`us-central`):
-
-- **Europe** (`eu-west`):
+- **North America** (`us-central`): Data is stored in Google Cloud Platform's `us-central1` region. This is the default for new organizations.
+- **Europe** (`eu-west`): Data is stored in Google Cloud Platform's `europe-west4` region. Choose this region if you need to keep data within the EU to meet GDPR or other data residency requirements.
 
 ## Set organization data region
 
@@ -39,21 +41,21 @@ Once you sync data in an organization, you cannot change the data region.
 {{% /tab %}}
 {{% tab name="Python" %}}
 
-You can check your organization's data region using [`get_organization`](/dev/reference/apis/fleet/#getorganization), and set your organization's data region using [`update_organization`](/dev/reference/apis/fleet/#updateorganization):
+You can check your organization's data region using [`get_organization`](/reference/apis/fleet/), and set your organization's data region using [`update_organization`](/reference/apis/fleet/):
 
 {{< read-code-snippet file="/static/include/examples-generated/data-region.snippet.data-region.py" lang="python" class="line-numbers linkable-line-numbers" data-line="34-37" >}}
 
 {{% /tab %}}
 {{% tab name="Go" %}}
 
-You can check your organization's data region using [`GetOrganization`](/dev/reference/apis/fleet/#getorganization), and set your organization's data region using [`UpdateOrganization`](/dev/reference/apis/fleet/#updateorganization):
+You can check your organization's data region using [`GetOrganization`](/reference/apis/fleet/), and set your organization's data region using [`UpdateOrganization`](/reference/apis/fleet/):
 
 {{< read-code-snippet file="/static/include/examples-generated/data-region.snippet.data-region.go" lang="python" class="line-numbers linkable-line-numbers" data-line="36-40" >}}
 
 {{% /tab %}}
 {{% tab name="TypeScript" %}}
 
-You can check your organization's data region using [`getOrganization`](/dev/reference/apis/fleet/#getorganization), and set your organization's data region using [`UpdateOrganization`](/dev/reference/apis/fleet/#updateorganization):
+You can check your organization's data region using [`getOrganization`](/reference/apis/fleet/), and set your organization's data region using [`UpdateOrganization`](/reference/apis/fleet/):
 
 {{< read-code-snippet file="/static/include/examples-generated/data-region.snippet.data-region.ts" lang="python" class="line-numbers linkable-line-numbers" data-line="23-28" >}}
 
diff --git a/docs/manage/manage/oauth.md b/docs/organization/oauth.md
similarity index 88%
rename from docs/manage/manage/oauth.md
rename to docs/organization/oauth.md
index 294d0022e5..41c8316ae9 100644
--- a/docs/manage/manage/oauth.md
+++ b/docs/organization/oauth.md
@@ -1,7 +1,7 @@
 ---
 title: "Authenticate end users with OAuth"
 linkTitle: "OAuth"
-weight: 60
+weight: 30
 layout: "docs"
 type: "docs"
 description: "Create a branded login screen for your application."
@@ -9,8 +9,12 @@ images: ["/operate/oauth.png"]
 date: "2025-01-22"
 ---
 
-You can use Viam to manage your user authentication.
-This guide will show you how to create a branded login screen.
+If you are building a product on Viam, you can set up branded authentication for your end users.
+This guide shows you how to create a branded login screen using Viam's OAuth integration, which is built on [FusionAuth](https://fusionauth.io/).
+
+{{< alert title="Note" color="note" >}}
+This feature is for authenticating **your product's end users**, not for signing into the Viam app itself.
+{{< /alert >}}
 
 {{<imgproc src="/operate/oauth.png" resize="1000x" declaredimensions=true alt="Example Oauth login screen" style="width:600px" class="imgzoom shadow">}}
 
@@ -26,7 +30,7 @@ viam organization logo set --logo-path=logo.png --org-id=<org-id>
 Successfully set the logo for organization <org-id> to logo at file-path: logo.png
 ```
 
-You must have [owner permissions](/manage/manage/rbac/#organization-settings-and-roles) on the organization.
+You must have [owner permissions](/organization/rbac/#organization-settings-and-roles) on the organization.
 
 {{% /tablestep %}}
 {{% tablestep %}}
@@ -60,7 +64,7 @@ viam organization auth-service oauth-app create --client-authentication=required
     --client-name="OAuth Test App" --enabled-grants="password, authorization_code" \
     --logout-uri="https://logoipsum.com/logout" --origin-uris="https://logoipsum.com,http://localhost:3000" \
     --pkce=not_required --redirect-uris="https://logoipsum.com/oauth-redirect,http://localhost:3000/oauth-redirect" \
-    --url-validation=allow_wildcards --invite-redirect-uri="https://logoipsum.com" --org-id=<org-id>
+    --url-validation=allow_wildcards --org-id=<org-id>
 Successfully created OAuth app OAuth Test App with client ID <client-id> and client secret <secret-token>
 ```
 
@@ -73,12 +77,11 @@ Successfully created OAuth app OAuth Test App with client ID <client-id> and cli
 | `--client-name` | The name for the OAuth application. | **Required** |
 | `--enabled-grants` | Comma-separated enabled grants for the OAuth application. Options: `unspecified`, `refresh_token`, `password`, `implicit`, `device_code`, `authorization_code`. | **Required** |
 | `--logout-uri` | The logout uri for the OAuth application. | **Required** |
-| `--org-id` |  The organization ID that is tied to the OAuth application. | **Required** |
+| `--org-id` | The organization ID that is tied to the OAuth application. | **Required** |
 | `--origin-uris` | Comma-separated origin URIs for the OAuth application. | **Required** |
 | `--pkce` | Proof Key for Code Exchange (PKCE) for the OAuth application. Options: `unspecified`, `required`, `not_required`, `not_required_when_using_client_authentication`. Default: `unspecified`. | **Required** |
 | `--redirect-uris` | Comma-separated redirect URIs for the OAuth application. | **Required** |
 | `--url-validation` | URL validation for the OAuth application. Options: `unspecified`, `exact_match`, `allow_wildcards`. Default: `unspecified`. | **Required** |
-| `--invite-redirect-uri` | The redirect link to send a user when they accept an org invite. | Optional |
 
 {{% /expand%}}
 
@@ -99,7 +102,6 @@ Client Authentication: required
 PKCE (Proof Key for Code Exchange): not_required
 URL Validation Policy: allow_wildcards
 Logout URL: https://logoipsum.com/logout
-Invite Redirect URL: https://logoipsum.com
 Redirect URLs: https://logoipsum.com/oauth-redirect, http://localhost:3000/oauth-redirect
 Origin URLs: https://logoipsum.com, http://localhost:3000
 Enabled Grants: authorization_code, password
diff --git a/docs/organization/overview.md b/docs/organization/overview.md
new file mode 100644
index 0000000000..7bb6b8465f
--- /dev/null
+++ b/docs/organization/overview.md
@@ -0,0 +1,214 @@
+---
+linkTitle: "Overview"
+title: "Organizations, locations, and access"
+weight: 5
+layout: "docs"
+type: "docs"
+no_list: true
+description: "Understand how Viam organizes machines into organizations and locations, and how access control works at each level."
+aliases:
+  - /cloud/machines/
+  - /fleet/robots/
+  - /fleet/machines/
+  - /cloud/locations/
+  - /fleet/locations/
+  - /cloud/organizations/
+  - /fleet/organizations/
+  - /fleet/account/
+  - /cloud/account/
+---
+
+Viam organizes your machines into a three-level hierarchy: organizations contain locations, and locations contain machines.
+This hierarchy is also the foundation for access control.
+You grant permissions at any level, and they apply to everything within that level.
+
+## Organization, location, and machine hierarchy
+
+{{<imgproc src="/fleet/fleet.svg" class="fill aligncenter" resize="800x" style="width: 600px" declaredimensions=true alt="Two locations within an organization">}}
+
+**Organizations** are the top-level grouping.
+An organization typically represents a company or team.
+Each organization has its own members, API keys, billing, and data region.
+
+**Locations** group machines within an organization.
+A location can represent a physical site, a project, or any logical grouping that makes sense for your fleet.
+You can nest locations up to three levels deep to create sub-groupings.
+
+**Machines** are individual devices running `viam-server`.
+Each machine belongs to exactly one location.
+
+### How the hierarchy affects access
+
+When you grant a user or API key access at a given level, the permissions apply to everything below it:
+
+- **Organization-level access** grants access to all locations and machines in the organization.
+- **Location-level access** grants access to all machines in that location and its sub-locations.
+- **Machine-level access** grants access to only that specific machine.
+
+This means you can use the hierarchy to approximate team boundaries even without an explicit team or group feature.
+For example, create a "Production" location and a "Testing" location, then grant field operators access only to "Production."
+
+For details on what each role can do, see [Permissions](/organization/rbac/).
+
+### Choose your structure
+
+Before connecting devices, decide how you want to group your machines:
+
+- **By physical site**: one location per office, warehouse, or deployment site.
+- **By project or environment**: locations for "Production," "Staging," and "Development."
+- **By customer**: if you deploy machines to customers, one location per customer lets you share access with that customer's organization.
+
+You can combine these approaches using nested locations.
+For example, a "Chicago warehouse" location could contain "Floor 1" and "Floor 2" sub-locations.
+
+## Create and manage organizations
+
+### Create an organization
+
+1. Log into [the Viam app](https://app.viam.com).
+1. Click the organization dropdown in the top navigation bar and click the **+** button.
+1. Name the organization.
+1. From the **Data region** dropdown, choose where Viam should store your data. See [Choose data region](/organization/data-regions/).
+1. Click **Create**.
+
+### Rename an organization
+
+You must be an organization owner.
+
+1. Click the organization name in the top navigation bar and click **Settings**.
+1. In the **Details** section, change the name and click **Rename**.
+
+{{< alert title="Caution" color="caution" >}}
+If your organization owns modules or packages in the Viam Registry, the namespace changes automatically.
+You must update any configurations that reference your modules using the old namespace.
+{{< /alert >}}
+
+### Delete an organization
+
+1. Delete all locations in the organization.
+1. Click the organization name in the top navigation bar and click **Settings**.
+1. At the bottom of the page, click **Delete organization**.
+
+## Create and manage locations
+
+### Create a location
+
+1. Click the organization name in the top navigation bar and click **Locations**.
+   A default location called `First Location` is created automatically for new organizations.
+   Use the **...** menu to rename it.
+1. To create additional locations, click **+ Add location**.
+
+### Create sub-locations
+
+1. Create a new location using **+ Add location**.
+1. On the new location's page, click the **...** menu and click **Move**.
+1. Choose a parent location.
+
+You can nest locations up to three levels deep.
+
+### Move a machine to a different location
+
+Organization owners and location owners can move machines between locations.
+
+1. Navigate to your machine's page.
+1. Click the **...** button in the upper-right corner.
+1. Select **Move to a new location**.
+1. Choose the destination location and confirm.
+
+{{< alert title="Important" color="caution" >}}
+Moving a machine changes its network address and its access permissions.
+Users with access to the old location lose access, and users with access to the new location gain access.
+Historical data stays associated with the original location.
+{{< /alert >}}
+
+### Share a location with another organization
+
+To give another organization access to a location, see [Share a location with an organization](/organization/access/#share-a-location-with-an-organization).
+
+## Your account
+
+### Create an account and log in
+
+Navigate to [app.viam.com](https://app.viam.com).
+Click **Sign Up** to create an account using Google, GitHub, Apple, or email.
+If you already have an account, click **Log In**.
+
+To reset a forgotten password, click **Forgot password** on the login page.
+
+{{< alert title="Note" color="note" >}}
+Accounts created from different authentication providers (for example, Google and email) are separate accounts, even if they use the same email address.
+{{< /alert >}}
+
+### Sign out
+
+Click your profile icon in the upper-right corner and click **Sign out**.
+
+### Delete your account
+
+Contact [contact@viam.com](mailto:contact@viam.com) to delete your account.
+Account deletion may result in destruction of associated content.
+
+### CLI authentication
+
+You can authenticate with the Viam CLI using either interactive login or an API key:
+
+```sh {class="command-line" data-prompt="$"}
+viam login
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam login api-key --key-id <key-id> --key <key>
+```
+
+To check who you are currently authenticated as:
+
+```sh {class="command-line" data-prompt="$"}
+viam whoami
+```
+
+If you work with multiple organizations or API keys, you can set up CLI profiles to switch between credentials:
+
+```sh {class="command-line" data-prompt="$"}
+viam profiles add --profile-name production --key-id <key-id> --key <key>
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam profiles list
+```
+
+You can also set default org and location for CLI commands:
+
+```sh {class="command-line" data-prompt="$"}
+viam defaults set-org --org-id <org-id>
+```
+
+```sh {class="command-line" data-prompt="$"}
+viam defaults set-location --location-id <location-id>
+```
+
+For the full CLI reference, see [CLI](/cli/reference/).
+
+## FAQ
+
+### Can I move a location to a different organization?
+
+No.
+You can [share a location](/organization/access/#share-a-location-with-an-organization) with another organization, but the location stays in its original organization.
+Machines in a shared location continue to use the primary organization for data association, private ML models, and registry items.
+
+### Can I rename my organization after creation?
+
+Yes, if you are an organization owner.
+See [Rename an organization](#rename-an-organization).
+
+### Can I move a machine across organizations?
+
+No.
+You can only move a machine to a different location within the same organization.
+To transfer a machine to another organization, you would need to set up a new machine in the target organization and reconfigure it.
+
+## Next steps
+
+- [Control access](/organization/access/) to your machines by granting and revoking permissions.
+- [Manage API keys](/organization/api-keys/) for programmatic and CLI access.
+- Review the [permissions reference](/organization/rbac/) to understand what each role can do.
diff --git a/docs/manage/manage/rbac.md b/docs/organization/rbac.md
similarity index 82%
rename from docs/manage/manage/rbac.md
rename to docs/organization/rbac.md
index 76d9b78f15..17414d2ff6 100644
--- a/docs/manage/manage/rbac.md
+++ b/docs/organization/rbac.md
@@ -1,26 +1,33 @@
 ---
-title: "Role-Based Access Control"
+title: "Role-based access control"
 linkTitle: "Permissions"
 description: "Fleet and data management permissions."
-weight: 30
+weight: 20
 type: "docs"
 tags: ["data management", "cloud", "app", "fleet management"]
 aliases:
   - /fleet/rbac/
 date: "2022-01-01"
 no_list: true
-# updated: ""  # When the content was last entirely checked
-# SME: Devin Hilly
 ---
 
-Role-Based Access Control (RBAC) is a way to enforce security by assigning organization members or API keys roles that confer permissions.
+Role-Based Access Control (RBAC) is a way to enforce security by assigning organization members or [API keys](/organization/api-keys/) roles that confer permissions.
 You can assign an owner or an operator role for an {{< glossary_tooltip term_id="organization" text="organization" >}}, {{< glossary_tooltip term_id="location" text="location" >}}, or {{< glossary_tooltip term_id="machine" text="machine" >}}.
 
 - **Owner**: Can see and edit every tab on the machine page and perform equivalent operations from the APIs.
-- **Operator**: Can see and use only the [**CONTROL**](/manage/troubleshoot/teleoperate/default-interface/#web-ui) tab and perform equivalent operations from the APIs.
-  Cannot see or edit the **CONFIGURE**, [**LOGS**](/manage/troubleshoot/troubleshoot/#check-logs), or **CONNECT** tabs.
+- **Operator**: Can see and use only the **CONTROL** tab and perform equivalent operations from the APIs.
+  Cannot see or edit the **CONFIGURE**, **LOGS**, or **CONNECT** tabs.
 
-The following sections describe the permissions for each user role when it comes to managing machines, locations, organizations, fragments, and data.
+Because roles are assigned at a specific level in the [resource hierarchy](/organization/overview/), you can combine the two roles with the three levels to create fine-grained access patterns:
+
+| Goal                                           | Assign this                                                     |
+| ---------------------------------------------- | --------------------------------------------------------------- |
+| Software team manages all machines at a site   | Location Owner                                                  |
+| Field operator monitors and controls machines  | Machine Operator (per machine) or Location Operator             |
+| Org admin manages billing, members, and config | Organization Owner                                              |
+| Monitoring dashboard reads data from a site    | Location Operator (using an [API key](/organization/api-keys/)) |
+
+The following sections describe the full permissions for each role and level.
 
 ## Machines
 
@@ -37,7 +44,7 @@ Permissions for managing {{< glossary_tooltip term_id="machine" text="machines"
 | Edit {{< glossary_tooltip term_id="part" text="part" >}} name | **Yes** | No | **Yes** | No | **Yes** | No |
 | Restart the machine | **Yes** | No | **Yes** | No | **Yes** | No |
 | Edit a machine config (including data capture and sync) | **Yes** | No | **Yes** | No | **Yes** | No |
-| Can read and write metadata | **Yes** | No  | **Yes** | No | **Yes** | No |
+| Can read and write metadata | **Yes** | No | **Yes** | No | **Yes** | No |
 
 ## Locations
 
@@ -55,7 +62,7 @@ Permissions for managing {{< glossary_tooltip term_id="location" text="locations
 | Add a shared location | **Yes** | No | **Yes** | No | No | No |
 | Remove a shared location | **Yes** | No | **Yes** | No | No | No |
 | Use Try Viam from within the org\* | **Yes** | No | No | No | No | No |
-| Can read and write metadata | **Yes** | No  | **Yes** | No | **Yes** | No |
+| Can read and write metadata | **Yes** | No | **Yes** | No | **Yes** | No |
 
 If a user has access to a child location but not its parent location, the user cannot see machines in the parent location.
 
@@ -85,7 +92,7 @@ Permissions for managing org settings and user roles are as follows:
 | Create a new organization | **Yes** | **Yes** | **Yes** | **Yes** | **Yes** | **Yes** |
 | Delete modules | **Yes** | No | No | No | No | No |
 | Make public modules private | **Yes** | No | No | No | No | No |
-| Can read and write metadata | **Yes** | No  | **Yes** | No | **Yes** | No |
+| Can read and write metadata | **Yes** | No | **Yes** | No | **Yes** | No |
 
 \*For locations/machines they have access to
 
@@ -102,7 +109,7 @@ Permissions for managing {{< glossary_tooltip term_id="fragment" text="fragments
 
 ## Data and machine learning
 
-Permissions for [data management](/data-ai/capture-data/capture-sync/) and [machine learning](/data-ai/ai/deploy/) are as follows:
+Permissions for [data management](/data/) and [machine learning](/vision/configure/) are as follows:
 
 <!-- prettier-ignore -->
 | Permissions | Org owner | Org operator | Location owner | Location operator | Machine owner | Machine operator |
diff --git a/docs/manage/manage/white-labeled-billing.md b/docs/organization/white-labeled-billing.md
similarity index 84%
rename from docs/manage/manage/white-labeled-billing.md
rename to docs/organization/white-labeled-billing.md
index a1f2521e85..0e0cdcfc8b 100644
--- a/docs/manage/manage/white-labeled-billing.md
+++ b/docs/organization/white-labeled-billing.md
@@ -1,19 +1,19 @@
 ---
-title: "White-labeled Billing"
-linkTitle: "White-labeled Billing"
-weight: 70
+title: "White-labeled billing"
+linkTitle: "White-labeled billing"
+weight: 55
 layout: "docs"
 type: "docs"
-description: "Set up white-labeled billing."
+description: "Set up a branded billing dashboard with custom pricing for your customers."
 images: ["/operate/wlbilling.png"]
-date: "2025-01-31"
 aliases:
+  - /manage/manage/white-labeled-billing/
   - /manage/manage/white-labeled-billing
   - /manage/manage/white-labelled-billing/
 ---
 
 You can use Viam to bill your customers using your own logo.
-This guide will show you how to set up white-labeled billing.
+This guide shows you how to set up white-labeled billing.
 Once set up:
 
 - You will have a branded billing dashboard for each org
@@ -26,7 +26,7 @@ Once set up:
 
 {{< table >}}
 {{% tablestep start=1 %}}
-**Navigate to the organization settings page** through the menu in upper right corner of the page. Create a **Public namespace**.
+**Navigate to the organization settings page** through the menu in the upper right corner of the page. Create a **Public namespace**.
 
 {{% /tablestep %}}
 {{% tablestep %}}
@@ -38,7 +38,7 @@ viam organization logo set --logo-path logo.png --org-id <org-id>
 Successfully set the logo for organization <org-id> to logo at file-path: logo.png
 ```
 
-You must have [owner permissions](/manage/manage/rbac/#organization-settings-and-roles) on the organization.
+You must have [owner permissions](/organization/rbac/) on the organization.
 
 {{% /tablestep %}}
 {{% tablestep %}}
@@ -105,10 +105,9 @@ https://app.viam.com/billing/<public-namespace>?id=<org-id>
 
 To use custom billing, add a billing configuration to a fragment.
 
-1. Navigate to the **FLEET** page.
-1. Go to the [**FRAGMENTS** tab](https://app.viam.com/fragments).
+1. Navigate to the [**Fragments** page](https://app.viam.com/fragments).
 1. Select the fragment you use for your machines.
-1. Click **+** and add **Billing**
+1. Click **+** and add **Billing**.
 1. Adjust attributes as needed.
 1. Mark the fragment as public or unlisted.
 1. Save the fragment.
@@ -203,8 +202,8 @@ This configuration charges customers every 12 months, with upfront payment:
 <!-- prettier-ignore -->
 | Name | Type | Required? | Description |
 | ---- | ---- | --------- | ----------- |
-| `cost_per_month` | object | Optional | See [cost per month attributes](/manage/manage/white-labeled-billing/#click-to-view-cost-per-month-attributes). If specified, you cannot also specify `cost_per_year`. Default: `{}` (all machines cost `0`). |
-| `cost_per_year` | object | Optional | See [cost per year attributes](/manage/manage/white-labeled-billing/#click-to-view-cost-per-year-attributes). If specified, you cannot also specify `cost_per_month`. Default: `{}` (all machines cost `0`). |
+| `cost_per_month` | object | Optional | See [cost per month attributes](/organization/white-labeled-billing/#click-to-view-cost-per-month-attributes). If specified, you cannot also specify `cost_per_year`. Default: `{}` (all machines cost `0`). |
+| `cost_per_year` | object | Optional | See [cost per year attributes](/organization/white-labeled-billing/#click-to-view-cost-per-year-attributes). If specified, you cannot also specify `cost_per_month`. Default: `{}` (all machines cost `0`). |
 | `tier_name` | string | **Required** | The name of the billing tier. |
 | `description` | string | Optional | Description for the billing tier. Default: `""`. |
 | `tier_credit` | number | Optional | Credit that should be applied to final total for the org. Default: `0`. |
@@ -244,31 +243,30 @@ This configuration charges customers every 12 months, with upfront payment:
 
 ### How does reimbursement work for white-labeled billing?
 
-Payments for white-labeled billing go directly to Viam. To arrange reimbursement, please [contact us](mailto:support@viam.com).
+Payments for white-labeled billing go directly to Viam. To arrange reimbursement, [contact us](mailto:support@viam.com).
 
 ### Can I customize the billing page further?
 
-If you need further customization, please [contact us](mailto:support@viam.com).
+If you need further customization, [contact us](mailto:support@viam.com).
 
 ### How does renewal work?
 
 Renewal is automatic for upfront annual billing and for upfront monthly billing.
 For monthly billing after usage, if there is no usage, there is no charge.
-If the `per_machine` field is set, then a machine existing, is considered usage.
+If the `per_machine` field is set, then a machine existing is considered usage.
 
 ### When are invoices generated?
 
 - **Monthly billing (`in_arrears: true`)**: Invoices are generated on the first day of the month and customers are charged at the end of each month for the per machine cost and usage during that month.
-  For example, if you set up a machine on June 20, you'll get an invoice on July 1 for 10 days of usage. Then you'll get the next invoice on August 1 for the usage in July.
+  For example, if you set up a machine on June 20, you get an invoice on July 1 for 10 days of usage. Then you get the next invoice on August 1 for the usage in July.
 - **Monthly billing (`in_arrears: false`)**: Invoices are generated shortly after the billing fragment is added to the machine and customers are charged at the beginning of each new month of usage for the per machine cost.
-  For example, if you set up a monthly upfront machine on June 20, you'll get an invoice shortly after on the same day.
-  Then you'll get the next invoice on July 20, then August 20, and so on.
+  For example, if you set up a monthly upfront machine on June 20, you get an invoice shortly after on the same day.
+  Then you get the next invoice on July 20, then August 20, and so on.
 - **Annual billing (`in_arrears: false`)**: Invoices are generated shortly after the billing fragment is added to the machine and customers are charged at the beginning of each new year of usage for the per machine cost.
-  For example, if you set up an annual upfront machine on June 20, you'll get an invoice shortly after on the same day.
-  Then you'll get the next invoice on June 20 the following year.
+  For example, if you set up an annual upfront machine on June 20, you get an invoice shortly after on the same day.
+  Then you get the next invoice on June 20 the following year.
 
 ### Can customers switch between monthly and annual billing?
 
 Yes. However, switching billing fragments will result in the new charge immediately taking effect.
-We recommend that you wait until the end of the current billing cycle to remove the old billing
-fragment and assign the new billing fragment.
+Wait until the end of the current billing cycle to remove the old billing fragment and assign the new billing fragment.
diff --git a/docs/reference/_index.md b/docs/reference/_index.md
new file mode 100644
index 0000000000..ea27c06ffb
--- /dev/null
+++ b/docs/reference/_index.md
@@ -0,0 +1,82 @@
+---
+linkTitle: "Reference"
+title: "Reference"
+weight: 600
+layout: "docs"
+type: "docs"
+no_list: true
+noedit: true
+open_on_desktop: true
+description: "Technical reference documentation for the Viam platform: APIs, SDKs, components, services, and more."
+aliases:
+  - /reference/architecture/
+  - /reference/architecture/parts/
+  - /reference/architecture/machine-to-machine-comms/
+  - /architecture/
+  - /architecture/parts/
+  - /architecture/machine-to-machine-comms/
+  - /operate/reference/architecture/
+  - /operate/reference/architecture/parts/
+  - /operate/reference/architecture/machine-to-machine-comms/
+  - /dev/reference/architecture/
+  - /internals/robot-to-robot-comms/
+  - /internals/machine-to-machine-comms/
+  - /manage/parts-and-remotes/
+  - /build/configure/parts-and-remotes/
+  - /configure/parts/
+  - /build/configure/parts/
+  - /dev/
+  - /dev/reference/
+  - /dev/reference/contributing/
+  - /dev/tools/
+  - /dev/tools/contributing/
+  - /reference/account/
+  - /reference/account/accounts/
+  - /reference/account/billing/
+  - /reference/account/organize/
+  - /reference/advanced-modules/
+  - /reference/advanced-modules/create-subtype/
+  - /reference/advanced-modules/custom-components-remotes/
+  - /reference/advanced-modules/docker-modules/
+  - /reference/components/
+  - /reference/configuration/
+  - /reference/configuration/controls-package/
+  - /reference/configuration/kinematic-chain-config/
+  - /reference/configuration/mlmodel-design/
+  - /reference/configuration/slam-background/
+  - /reference/services/
+  - /reference/module-configuration/
+  - /reference/changelog/
+  - /dev/reference/changelog/
+  - /reference/platform/
+  - /reference/platform/viam-server/
+  - /reference/platform/viam-server/manage-viam-server/
+  - /reference/platform/viam-server/debug-endpoints/
+  - /reference/platform/viam-agent/
+  - /reference/platform/viam-agent/manage-viam-agent/
+  - /reference/platform/viam-micro-server/
+  - /operate/reference/viam-server/
+  - /operate/reference/viam-server/manage-viam-server/
+  - /operate/reference/viam-server/debug-endpoints/
+  - /operate/reference/viam-server/local-configuration-file/
+  - /manage/reference/viam-agent/
+  - /manage/reference/viam-agent/manage-viam-agent/
+  - /operate/install/setup-micro/
+  - /operate/reference/viam-micro-server/
+  - /operate/reference/viam-micro-server/viam-micro-server-troubleshooting/
+  - /internals/rdk/
+  - /architecture/rdk/
+  - /architecture/viam-server/
+  - /internals/local-configuration-file/
+  - /configure/agent/
+  - /installation/manage-viam-agent/
+  - /installation/microcontrollers/
+  - /installation/prepare/microcontrollers/
+  - /installation/viam-micro-server-setup/
+  - /installation/update/
+  - /installation/manage-viam-server/
+  - /build/micro-rdk/
+  - /get-started/installation/microcontrollers/
+  - /get-started/installation/manage-viam-server/
+  - /operate/get-started/setup-micro/
+---
diff --git a/docs/reference/apis/_index.md b/docs/reference/apis/_index.md
new file mode 100644
index 0000000000..22fb7b8b2b
--- /dev/null
+++ b/docs/reference/apis/_index.md
@@ -0,0 +1,103 @@
+---
+title: "Viam's Client APIs"
+linkTitle: "APIs"
+weight: 10
+type: "docs"
+description: "Access and control your machine or fleet with the SDKs' client libraries for the resource and robot APIs."
+images: ["/general/code.png"]
+tags: ["client", "sdk", "viam-server", "networking", "apis", "robot api"]
+aliases:
+  - /program/sdks/
+  - /program/apis/
+  - /build/program/apis/
+  - /appendix/apis/
+  - /reference/apis/services/SLAM/
+  - /reference/apis/services/slam/
+  - /dev/reference/apis/services/SLAM/
+  - /dev/reference/apis/services/slam/
+  - /appendix/apis/services/slam/
+no_list: true
+date: "2024-10-01"
+# updated: ""  # When the content was last entirely checked
+---
+
+Every Viam {{< glossary_tooltip term_id="resource" text="resource" >}} exposes an [application programming interface (API)](https://en.wikipedia.org/wiki/API) described through [protocol buffers](https://developers.google.com/protocol-buffers).
+
+The API methods provided by the SDKs for each of these resource APIs wrap gRPC client requests to the machine when you execute your program, providing you a convenient interface for accessing information about and controlling the {{< glossary_tooltip term_id="resource" text="resources" >}} you have [configured](/operate/modules/configure-modules/) on your machine.
+
+## Platform APIs
+
+{{< cards >}}
+{{% manualcard link="/reference/apis/fleet/" title="Fleet Management API" %}}
+
+Create and manage organizations, locations, and machines, get logs from individual machines, and manage fragments and permissions.
+
+{{% /manualcard %}}
+{{% manualcard link="/reference/apis/data-client/" title="Data Client API" %}}
+
+Upload, download, filter, tag or perform other tasks on data like images or sensor readings.
+
+{{% /manualcard %}}
+{{% manualcard link="/reference/apis/robot/" title="Machine Management API" %}}
+
+Manage your machines: connect to your machine, retrieve status information, and send commands remotely.
+
+{{% /manualcard %}}
+{{% manualcard link="/reference/apis/ml-training-client/" title="ML Training Client API" %}}
+
+Submit and manage ML training jobs running on Viam.
+
+{{% /manualcard %}}
+{{% manualcard link="/reference/apis/billing-client/" title="Billing Client API" %}}
+
+Retrieve billing information from Viam.
+
+{{% /manualcard %}}
+{{% manualcard link="/reference/apis/sessions/" title="Session Management API" %}}
+
+Manage sessions, heartbeats, and safety timeouts for connected clients.
+
+{{% /manualcard %}}
+
+{{< /cards >}}
+
+## Component APIs
+
+These APIs provide interfaces for controlling and getting information from the {{< glossary_tooltip term_id="component" text="components" >}} of a machine:
+
+{{< cards >}}
+{{< card link="/reference/apis/components/arm/" customTitle="Arm API" noimage="True" >}}
+{{< card link="/reference/apis/components/audio-in/" customTitle="Audio in API" noimage="True" >}}
+{{< card link="/reference/apis/components/audio-out/" customTitle="Audio out API" noimage="True" >}}
+{{< card link="/reference/apis/components/base/" customTitle="Base API" noimage="True" >}}
+{{< card link="/reference/apis/components/board/" customTitle="Board API" noimage="True" >}}
+{{< card link="/reference/apis/components/button/" customTitle="Button API" noimage="True" >}}
+{{< card link="/reference/apis/components/camera/" customTitle="Camera API" noimage="True" >}}
+{{< card link="/reference/apis/components/encoder/" customTitle="Encoder API" noimage="True" >}}
+{{< card link="/reference/apis/components/gantry/" customTitle="Gantry API" noimage="True" >}}
+{{< card link="/reference/apis/components/generic/" customTitle="Generic API" noimage="True" >}}
+{{< card link="/reference/apis/components/gripper/" customTitle="Gripper API" noimage="True" >}}
+{{< card link="/reference/apis/components/input-controller/" customTitle="Input controller API" noimage="True" >}}
+{{< card link="/reference/apis/components/motor/" customTitle="Motor API" noimage="True" >}}
+{{< card link="/reference/apis/components/movement-sensor/" customTitle="Movement sensor API" noimage="True" >}}
+{{< card link="/reference/apis/components/power-sensor/" customTitle="Power sensor API" noimage="True" >}}
+{{< card link="/reference/apis/components/sensor/" customTitle="Sensor API" noimage="True" >}}
+{{< card link="/reference/apis/components/servo/" customTitle="Servo API" noimage="True" >}}
+{{< card link="/reference/apis/components/switch/" customTitle="Switch API" noimage="True" >}}
+{{< /cards >}}
+
+## Service APIs
+
+These APIs provide interfaces for controlling and getting information from the services you configured on a machine.
+
+{{< cards >}}
+{{% card link="/reference/apis/services/data/" customTitle="Data management service API" noimage="True" %}}
+{{% card link="/reference/apis/services/vision/" customTitle="Vision service API" noimage="True" %}}
+{{% card link="/reference/apis/services/ml/" customTitle="ML model service API" noimage="True" %}}
+{{% card link="/reference/apis/services/motion/" customTitle="Motion service API" noimage="True" %}}
+{{% card link="/reference/apis/services/navigation/" customTitle="Navigation service API" noimage="True" %}}
+{{% card link="/reference/apis/services/generic/" customTitle="Generic service API" noimage="True" %}}
+{{% card link="/reference/apis/services/base-rc/" customTitle="Base Remote Control service API" noimage="True" %}}
+{{% card link="/reference/apis/services/discovery/" customTitle="Discovery service API" noimage="True" %}}
+{{% card link="/reference/apis/services/world-state-store/" customTitle="World state store service API" noimage="True" %}}
+{{< /cards >}}
diff --git a/docs/dev/reference/apis/billing-client.md b/docs/reference/apis/billing-client.md
similarity index 95%
rename from docs/dev/reference/apis/billing-client.md
rename to docs/reference/apis/billing-client.md
index 08abfabeb7..dc1864164c 100644
--- a/docs/dev/reference/apis/billing-client.md
+++ b/docs/reference/apis/billing-client.md
@@ -1,11 +1,12 @@
 ---
 title: "Retrieve billing information with Viam's billing client API"
 linkTitle: "Billing client"
-weight: 90
+weight: 60
 type: "docs"
 description: "Use the billing client API to retrieve billing information from Viam."
 tags: ["cloud", "sdk", "viam-server", "networking", "apis", "robot api"]
 aliases:
+  - /dev/reference/apis/billing-client/
   - /program/apis/billing-client/
   - /build/program/apis/billing-client/
   - /appendix/apis/billing-client/
@@ -23,9 +24,9 @@ The billing API supports the following methods:
 
 To use the billing client API, you need to instantiate a `ViamClient` and then instantiate a `BillingClient`.
 
-You need an API key and API key ID with [Org owner permissions](/manage/manage/rbac/#organization-settings-and-roles) to use the billing client API.
+You need an API key and API key ID with [Org owner permissions](/organization/rbac/#organization-settings-and-roles) to use the billing client API.
 To get an API key (and corresponding ID), use the [web UI](/operate/control/api-keys/#add-an-api-key)
-to the [Viam CLI](/dev/tools/cli/#create-an-organization-api-key).
+to the [Viam CLI](/cli/).
 
 {{< tabs >}}
 {{% tab name="From a client application" %}}
diff --git a/docs/dev/reference/apis/components/_index.md b/docs/reference/apis/components/_index.md
similarity index 72%
rename from docs/dev/reference/apis/components/_index.md
rename to docs/reference/apis/components/_index.md
index 6079148391..af19356c06 100644
--- a/docs/dev/reference/apis/components/_index.md
+++ b/docs/reference/apis/components/_index.md
@@ -4,9 +4,10 @@ title: "Component APIs"
 weight: 5
 empty_node: true
 layout: "empty"
-canonical: "/dev/reference/apis/"
+canonical: "/reference/apis/"
 type: "docs"
 aliases:
+  - /dev/reference/apis/components/
   - /appendix/apis/components/
   - /components/
 ---
diff --git a/docs/dev/reference/apis/components/arm.md b/docs/reference/apis/components/arm.md
similarity index 72%
rename from docs/dev/reference/apis/components/arm.md
rename to docs/reference/apis/components/arm.md
index f33d2a6257..ef6f8ab46e 100644
--- a/docs/dev/reference/apis/components/arm.md
+++ b/docs/reference/apis/components/arm.md
@@ -1,19 +1,20 @@
 ---
 title: "Arm API"
 linkTitle: "Arm"
-weight: 5
+weight: 10
 type: "docs"
 description: "Give commands to your arm components for linear motion planning."
 icon: true
 images: ["/icons/components/arm.svg"]
 date: "2022-01-01"
 aliases:
+  - /dev/reference/apis/components/arm/
   - /appendix/apis/components/arm/
 # updated: ""  # When the content was last entirely checked
 ---
 
-The arm API allows you to give commands to your [arm components](/operate/reference/components/arm/) for linear motion planning with self-collision prevention.
-If you want the arm to avoid obstacles, or you want to plan complex motion in an automated way, use the [motion API](/dev/reference/apis/services/motion/).
+The arm API allows you to give commands to your [arm components](/hardware/common-components/add-an-arm/) for linear motion planning with self-collision prevention.
+If you want the arm to avoid obstacles, or you want to plan complex motion in an automated way, use the [motion API](/reference/apis/services/motion/).
 
 The arm component supports the following methods:
 
diff --git a/docs/dev/reference/apis/components/audio-in.md b/docs/reference/apis/components/audio-in.md
similarity index 91%
rename from docs/dev/reference/apis/components/audio-in.md
rename to docs/reference/apis/components/audio-in.md
index 0bad0b6ccc..401af52b96 100644
--- a/docs/dev/reference/apis/components/audio-in.md
+++ b/docs/reference/apis/components/audio-in.md
@@ -1,13 +1,15 @@
 ---
 title: "Audio in API"
 linkTitle: "Audio in"
-weight: 10
+weight: 20
 type: "docs"
 description: "Give commands to your audio in components."
 icon: true
 # images: ["/icons/components/resource.svg"]
 date: "2025-11-12"
 # updated: ""  # When the content was last entirely checked
+aliases:
+  - /dev/reference/apis/components/audio-in/
 ---
 
 <!-- The audio in API allows you to give commands to your [audio in components](/operate/reference/components/audioIn/) for capturing audio.
diff --git a/docs/dev/reference/apis/components/audio-out.md b/docs/reference/apis/components/audio-out.md
similarity index 91%
rename from docs/dev/reference/apis/components/audio-out.md
rename to docs/reference/apis/components/audio-out.md
index 81aba663eb..7647606130 100644
--- a/docs/dev/reference/apis/components/audio-out.md
+++ b/docs/reference/apis/components/audio-out.md
@@ -1,13 +1,15 @@
 ---
 title: "Audio out API"
 linkTitle: "Audio out"
-weight: 10
+weight: 30
 type: "docs"
 description: "Give commands to your audio out components."
 icon: true
 # images: ["/icons/components/resource.svg"]
 date: "2025-11-12"
 # updated: ""  # When the content was last entirely checked
+aliases:
+  - /dev/reference/apis/components/audio-out/
 ---
 
 <!-- The audio in API allows you to give commands to your [audio out components](/operate/reference/components/audioOut/) for playing audio.
diff --git a/docs/dev/reference/apis/components/base.md b/docs/reference/apis/components/base.md
similarity index 94%
rename from docs/dev/reference/apis/components/base.md
rename to docs/reference/apis/components/base.md
index 1011cb655e..d8681866eb 100644
--- a/docs/dev/reference/apis/components/base.md
+++ b/docs/reference/apis/components/base.md
@@ -1,13 +1,14 @@
 ---
 title: "Base API"
 linkTitle: "Base"
-weight: 20
+weight: 40
 type: "docs"
 description: "Give commands for moving all configured components attached to a mobile platform as a whole without needing to send commands to individual components."
 icon: true
 images: ["/icons/components/base.svg"]
 date: "2022-01-01"
 aliases:
+  - /dev/reference/apis/components/base/
   - /appendix/apis/components/base/
 # updated: ""  # When the content was last entirely checked
 ---
diff --git a/docs/dev/reference/apis/components/board.md b/docs/reference/apis/components/board.md
similarity index 93%
rename from docs/dev/reference/apis/components/board.md
rename to docs/reference/apis/components/board.md
index d0249cb6bf..684b2ff0c7 100644
--- a/docs/dev/reference/apis/components/board.md
+++ b/docs/reference/apis/components/board.md
@@ -1,13 +1,14 @@
 ---
 title: "Board API"
 linkTitle: "Board"
-weight: 30
+weight: 50
 type: "docs"
 description: "Give commands for setting GPIO pins to high or low, setting PWM, and working with analog and digital interrupts."
 icon: true
 images: ["/icons/components/board.svg"]
 date: "2022-01-01"
 aliases:
+  - /dev/reference/apis/components/board/
   - /appendix/apis/components/board/
 # updated: ""  # When the content was last entirely checked
 ---
diff --git a/docs/dev/reference/apis/components/button.md b/docs/reference/apis/components/button.md
similarity index 90%
rename from docs/dev/reference/apis/components/button.md
rename to docs/reference/apis/components/button.md
index f2c5fb9bf3..b40a21e7e6 100644
--- a/docs/dev/reference/apis/components/button.md
+++ b/docs/reference/apis/components/button.md
@@ -1,13 +1,15 @@
 ---
 title: "Button API"
 linkTitle: "Button"
-weight: 35
+weight: 60
 type: "docs"
 description: "Give commands for getting presses from a physical button."
 icon: true
 images: ["/icons/components/button.svg"]
 date: "2025-02-20"
 # updated: ""  # When the content was last entirely checked
+aliases:
+  - /dev/reference/apis/components/button/
 ---
 
 The button API allows you to get button presses from your [button components](/operate/reference/components/button/).
diff --git a/docs/dev/reference/apis/components/camera.md b/docs/reference/apis/components/camera.md
similarity index 94%
rename from docs/dev/reference/apis/components/camera.md
rename to docs/reference/apis/components/camera.md
index b11f3a65e8..5e9f5aece0 100644
--- a/docs/dev/reference/apis/components/camera.md
+++ b/docs/reference/apis/components/camera.md
@@ -1,13 +1,14 @@
 ---
 title: "Camera API"
 linkTitle: "Camera"
-weight: 40
+weight: 70
 type: "docs"
 description: "Give commands for getting images or point clouds."
 icon: true
 images: ["/icons/components/camera.svg"]
 date: "2022-01-01"
 aliases:
+  - /dev/reference/apis/components/camera/
   - /appendix/apis/components/camera/
 # updated: ""  # When the content was last entirely checked
 ---
diff --git a/docs/dev/reference/apis/components/encoder.md b/docs/reference/apis/components/encoder.md
similarity index 77%
rename from docs/dev/reference/apis/components/encoder.md
rename to docs/reference/apis/components/encoder.md
index e1e8634cb4..6e7c851c9f 100644
--- a/docs/dev/reference/apis/components/encoder.md
+++ b/docs/reference/apis/components/encoder.md
@@ -1,18 +1,19 @@
 ---
 title: "Encoder API"
 linkTitle: "Encoder"
-weight: 50
+weight: 80
 type: "docs"
 description: "Give commands for getting the position of a motor or a joint in ticks or degrees."
 icon: true
 images: ["/icons/components/encoder.svg"]
 date: "2022-01-01"
 aliases:
+  - /dev/reference/apis/components/encoder/
   - /appendix/apis/components/encoder/
 # updated: ""  # When the content was last entirely checked
 ---
 
-The encoder API allows you to give commands to your [encoder components](/operate/reference/components/encoder/) for getting the position of a motor or a joint in ticks or degrees.
+The encoder API allows you to give commands to your [encoder components](/hardware/common-components/add-an-encoder/) for getting the position of a motor or a joint in ticks or degrees.
 
 The encoder component supports the following methods:
 
diff --git a/docs/dev/reference/apis/components/gantry.md b/docs/reference/apis/components/gantry.md
similarity index 92%
rename from docs/dev/reference/apis/components/gantry.md
rename to docs/reference/apis/components/gantry.md
index 3243fb49e8..2db1704f01 100644
--- a/docs/dev/reference/apis/components/gantry.md
+++ b/docs/reference/apis/components/gantry.md
@@ -1,13 +1,14 @@
 ---
 title: "Gantry API"
 linkTitle: "Gantry"
-weight: 60
+weight: 90
 type: "docs"
 description: "Give commands for coordinated control of one or more linear actuators."
 icon: true
 images: ["/icons/components/gantry.svg"]
 date: "2022-01-01"
 aliases:
+  - /dev/reference/apis/components/gantry/
   - /appendix/apis/components/gantry/
 # updated: ""  # When the content was last entirely checked
 ---
diff --git a/docs/dev/reference/apis/components/generic.md b/docs/reference/apis/components/generic.md
similarity index 90%
rename from docs/dev/reference/apis/components/generic.md
rename to docs/reference/apis/components/generic.md
index 385766002e..5a26bcffe3 100644
--- a/docs/dev/reference/apis/components/generic.md
+++ b/docs/reference/apis/components/generic.md
@@ -1,7 +1,7 @@
 ---
 title: "Control your generic component with the generic API"
 linkTitle: "Generic"
-weight: 70
+weight: 100
 type: "docs"
 description: "Give commands for running custom model-specific commands using DoCommand on your generic components."
 icon: true
@@ -12,7 +12,7 @@ aliases:
 # updated: ""  # When the content was last entirely checked
 ---
 
-The generic API allows you to give commands to your [generic components](/operate/reference/components/generic/) for running model-specific commands using [`DoCommand`](/dev/reference/apis/components/generic/#docommand).
+The generic API allows you to give commands to your [generic components](/operate/reference/components/generic/) for running model-specific commands using [`DoCommand`](/reference/apis/components/generic/#docommand).
 
 {{% alert title="Example usage" color="tip" %}}
 
diff --git a/docs/dev/reference/apis/components/gripper.md b/docs/reference/apis/components/gripper.md
similarity index 92%
rename from docs/dev/reference/apis/components/gripper.md
rename to docs/reference/apis/components/gripper.md
index 5a0d3e4649..aec533198f 100644
--- a/docs/dev/reference/apis/components/gripper.md
+++ b/docs/reference/apis/components/gripper.md
@@ -1,13 +1,14 @@
 ---
 title: "Control your gripper with the gripper API"
 linkTitle: "Gripper"
-weight: 80
+weight: 110
 type: "docs"
 description: "Give commands for opening and closing a gripper device."
 icon: true
 images: ["/icons/components/gripper.svg"]
 date: "2022-01-01"
 aliases:
+  - /dev/reference/apis/components/gripper/
   - /appendix/apis/components/gripper/
 # updated: ""  # When the content was last entirely checked
 ---
diff --git a/docs/dev/reference/apis/components/input-controller.md b/docs/reference/apis/components/input-controller.md
similarity index 96%
rename from docs/dev/reference/apis/components/input-controller.md
rename to docs/reference/apis/components/input-controller.md
index 9387466c61..1473b0e084 100644
--- a/docs/dev/reference/apis/components/input-controller.md
+++ b/docs/reference/apis/components/input-controller.md
@@ -2,7 +2,7 @@
 title: "Input controller API"
 linkTitle: "Input controller"
 titleMustBeLong: true
-weight: 90
+weight: 120
 type: "docs"
 description: "Give commands to register callbacks for events, allowing you to use input devices to control your machines."
 icon: true
@@ -13,7 +13,7 @@ aliases:
 # updated: ""  # When the content was last entirely checked
 ---
 
-The input controller API allows you to give commands to your [input controller components](/operate/reference/components/input-controller/) for configuring callbacks for events, allowing you to configure input devices to control your machines.
+The input controller API allows you to give commands to your [input controller components](/hardware/common-components/add-an-input-controller/) for configuring callbacks for events, allowing you to configure input devices to control your machines.
 
 The input controller component supports the following methods:
 
@@ -33,14 +33,14 @@ Each `Event` object represents a singular event from the input device, and has f
 
 1. `Time`: `time.Time` the event occurred.
 2. `Event`: `EventType` indicating the type of event (for example, a specific button press or axis movement).
-3. `Control`: `Control` indicating which [Axis](#axis-controls), [Button](/dev/reference/apis/components/input-controller/#button-controls), or Pedal on the controller has been changed.
-4. `Value`: `float64` indicating the position of an [Axis](/dev/reference/apis/components/input-controller/#axis-controls) or the state of a [Button](/dev/reference/apis/components/input-controller/#button-controls) on the specified control.
+3. `Control`: `Control` indicating which [Axis](#axis-controls), [Button](/reference/apis/components/input-controller/#button-controls), or Pedal on the controller has been changed.
+4. `Value`: `float64` indicating the position of an [Axis](/reference/apis/components/input-controller/#axis-controls) or the state of a [Button](/reference/apis/components/input-controller/#button-controls) on the specified control.
 
 #### EventType field
 
 A string-like type indicating the specific type of input event, such as a button press or axis movement.
 
-- To select for events of all type when registering callback function with [RegisterControlCallback](/dev/reference/apis/components/input-controller/#registercontrolcallback), you can use `AllEvents` as your `EventType`.
+- To select for events of all type when registering callback function with [RegisterControlCallback](/reference/apis/components/input-controller/#registercontrolcallback), you can use `AllEvents` as your `EventType`.
 - The registered function is then called in addition to any other callback functions you've registered, every time an `Event` happens on your controller.
   This is useful for debugging without interrupting normal controls, or for capturing extra or unknown events.
 
diff --git a/docs/dev/reference/apis/components/motor.md b/docs/reference/apis/components/motor.md
similarity index 92%
rename from docs/dev/reference/apis/components/motor.md
rename to docs/reference/apis/components/motor.md
index 7e2d26529b..a55631f3fa 100644
--- a/docs/dev/reference/apis/components/motor.md
+++ b/docs/reference/apis/components/motor.md
@@ -1,13 +1,14 @@
 ---
 title: "Motor API"
 linkTitle: "Motor"
-weight: 100
+weight: 130
 type: "docs"
 description: "Give commands to operate a motor or get its current status."
 icon: true
 images: ["/icons/components/motor.svg"]
 date: "2024-10-10"
 aliases:
+  - /dev/reference/apis/components/motor/
   - /appendix/apis/components/motor/
 # updated: ""  # When the content was last entirely checked
 ---
diff --git a/docs/dev/reference/apis/components/movement-sensor.md b/docs/reference/apis/components/movement-sensor.md
similarity index 95%
rename from docs/dev/reference/apis/components/movement-sensor.md
rename to docs/reference/apis/components/movement-sensor.md
index 04fb4fe8f5..cb56124b09 100644
--- a/docs/dev/reference/apis/components/movement-sensor.md
+++ b/docs/reference/apis/components/movement-sensor.md
@@ -1,13 +1,14 @@
 ---
 title: "Movement sensor API"
 linkTitle: "Movement sensor"
-weight: 110
+weight: 140
 type: "docs"
 description: "Give commands for getting the current GPS location, linear velocity and acceleration, angular velocity and acceleration and heading."
 icon: true
 images: ["/icons/components/imu.svg"]
 date: "2022-10-10"
 aliases:
+  - /dev/reference/apis/components/movement-sensor/
   - /appendix/apis/components/movement-sensor/
 # updated: ""  # When the content was last entirely checked
 ---
diff --git a/docs/dev/reference/apis/components/power-sensor.md b/docs/reference/apis/components/power-sensor.md
similarity index 92%
rename from docs/dev/reference/apis/components/power-sensor.md
rename to docs/reference/apis/components/power-sensor.md
index d7a5a06c37..ec67a74c0e 100644
--- a/docs/dev/reference/apis/components/power-sensor.md
+++ b/docs/reference/apis/components/power-sensor.md
@@ -1,13 +1,14 @@
 ---
 title: "Power sensor API"
 linkTitle: "Power sensor"
-weight: 120
+weight: 150
 type: "docs"
 description: "Commands for getting measurements of voltage, current, and power consumption."
 icon: true
 images: ["/icons/components/power-sensor.svg"]
 date: "2022-10-10"
 aliases:
+  - /dev/reference/apis/components/power-sensor/
   - /appendix/apis/components/power-sensor/
 # updated: ""  # When the content was last entirely checked
 ---
diff --git a/docs/dev/reference/apis/components/sensor.md b/docs/reference/apis/components/sensor.md
similarity index 91%
rename from docs/dev/reference/apis/components/sensor.md
rename to docs/reference/apis/components/sensor.md
index 8cd129532e..21c2ca57ef 100644
--- a/docs/dev/reference/apis/components/sensor.md
+++ b/docs/reference/apis/components/sensor.md
@@ -1,13 +1,14 @@
 ---
 title: "Sensor API"
 linkTitle: "Sensor"
-weight: 130
+weight: 160
 type: "docs"
 description: "Give commands for getting sensor readings."
 icon: true
 images: ["/icons/components/sensor.svg"]
 date: "2022-10-10"
 aliases:
+  - /dev/reference/apis/components/sensor/
   - /appendix/apis/components/sensor/
 # updated: ""  # When the content was last entirely checked
 ---
diff --git a/docs/dev/reference/apis/components/servo.md b/docs/reference/apis/components/servo.md
similarity index 80%
rename from docs/dev/reference/apis/components/servo.md
rename to docs/reference/apis/components/servo.md
index 0d20d7be3c..20a436c1a1 100644
--- a/docs/dev/reference/apis/components/servo.md
+++ b/docs/reference/apis/components/servo.md
@@ -1,20 +1,21 @@
 ---
 title: "Servo API"
 linkTitle: "Servo"
-weight: 140
+weight: 170
 type: "docs"
 description: "Give commands for controlling the angular position of a servo precisely or getting its current status."
 icon: true
 images: ["/icons/components/servo.svg"]
 date: "2022-10-10"
 aliases:
+  - /dev/reference/apis/components/servo/
   - /appendix/apis/components/servo/
 # updated: ""  # When the content was last entirely checked
 ---
 
 The servo API allows you to give commands to your [servo components](/operate/reference/components/servo/) for controlling the angular position of a hobby servo precisely or getting its current status.
 
-Industrial servos should use the [motor API](/dev/reference/apis/components/motor/) which provides more features than the servo API.
+Industrial servos should use the [motor API](/reference/apis/components/motor/) which provides more features than the servo API.
 
 The servo component supports the following methods:
 
diff --git a/docs/dev/reference/apis/components/switch.md b/docs/reference/apis/components/switch.md
similarity index 92%
rename from docs/dev/reference/apis/components/switch.md
rename to docs/reference/apis/components/switch.md
index 9c1b1b6e2a..23083e099a 100644
--- a/docs/dev/reference/apis/components/switch.md
+++ b/docs/reference/apis/components/switch.md
@@ -1,13 +1,15 @@
 ---
 title: "Switch API"
 linkTitle: "Switch"
-weight: 200
+weight: 180
 type: "docs"
 description: "Give commands for getting the state of a physical switch that has two or more discrete positions."
 icon: true
 images: ["/icons/components/switch.svg"]
 date: "2025-02-20"
 # updated: ""  # When the content was last entirely checked
+aliases:
+  - /dev/reference/apis/components/switch/
 ---
 
 The switch API allows you to give commands to your [switch components](/operate/reference/components/switch/) for reading the state of a physical switch that has multiple discrete positions.
diff --git a/docs/dev/reference/apis/data-client.md b/docs/reference/apis/data-client.md
similarity index 96%
rename from docs/dev/reference/apis/data-client.md
rename to docs/reference/apis/data-client.md
index 6c306e9083..0816fc4d47 100644
--- a/docs/dev/reference/apis/data-client.md
+++ b/docs/reference/apis/data-client.md
@@ -1,7 +1,7 @@
 ---
 title: "Upload and retrieve data with Viam's data client API"
 linkTitle: "Data client"
-weight: 10
+weight: 30
 type: "docs"
 description: "Use the data client API to upload and retrieve data directly."
 icon: true
@@ -18,6 +18,7 @@ tags:
     "data",
   ]
 aliases:
+  - /dev/reference/apis/data-client/
   - /program/apis/data-client/
   - /build/program/apis/data-client/
   - /appendix/apis/data-client/
@@ -46,9 +47,9 @@ Methods to work with datasets:
 
 To use the data client API, you need to instantiate a `ViamClient` and then instantiate a `DataClient`.
 
-You need an API key and API key ID with at least [Machine operator permissions](/manage/manage/rbac/#organization-settings-and-roles) to use the data client API.
+You need an API key and API key ID with at least [Machine operator permissions](/organization/rbac/#organization-settings-and-roles) to use the data client API.
 To get an API key (and corresponding ID), use the [web UI](/operate/control/api-keys/#add-an-api-key)
-to the [Viam CLI](/dev/tools/cli/#create-an-organization-api-key).
+to the [Viam CLI](/cli/).
 
 {{< tabs >}}
 {{% tab name="From a client application" %}}
diff --git a/docs/dev/reference/apis/fleet.md b/docs/reference/apis/fleet.md
similarity index 96%
rename from docs/dev/reference/apis/fleet.md
rename to docs/reference/apis/fleet.md
index b51c8b2cf8..c734be31a9 100644
--- a/docs/dev/reference/apis/fleet.md
+++ b/docs/reference/apis/fleet.md
@@ -1,7 +1,7 @@
 ---
 title: "Manage your fleet with Viam's fleet management API"
 linkTitle: "Fleet management"
-weight: 20
+weight: 10
 type: "docs"
 description: "Use the fleet management API with Viam's client SDKs to manage your machine fleet with code."
 tags:
@@ -39,9 +39,9 @@ The fleet management API supports the following methods:
 
 To use the fleet management API, you need to instantiate a `ViamClient` and then instantiate a `AppClient`.
 
-You need an API key and API key ID at least [Machine operator permissions](/manage/manage/rbac/#organization-settings-and-roles) to use the fleet management API.
+You need an API key and API key ID at least [Machine operator permissions](/organization/rbac/#organization-settings-and-roles) to use the fleet management API.
 To get an API key (and corresponding ID), use the [web UI](/operate/control/api-keys/#add-an-api-key)
-to the [Viam CLI](/dev/tools/cli/#create-an-organization-api-key).
+to the [Viam CLI](/cli/).
 
 {{< tabs >}}
 {{% tab name="From a client application" %}}
diff --git a/docs/dev/reference/apis/ml-training-client.md b/docs/reference/apis/ml-training-client.md
similarity index 95%
rename from docs/dev/reference/apis/ml-training-client.md
rename to docs/reference/apis/ml-training-client.md
index fcf3b95f46..ed67747c58 100644
--- a/docs/dev/reference/apis/ml-training-client.md
+++ b/docs/reference/apis/ml-training-client.md
@@ -1,11 +1,12 @@
 ---
 title: "Work with ML training jobs with Viam's ML training API"
 linkTitle: "ML training client"
-weight: 10
+weight: 40
 type: "docs"
 description: "Use the ML training client API to manage ML training jobs taking place in Viam's cloud app."
 tags: ["cloud", "sdk", "viam-server", "networking", "apis", "ml model", "ml"]
 aliases:
+  - /dev/reference/apis/ml-training-client/
   - /program/apis/ml_training-client/
   - /build/program/apis/ml-training-client/
   - /appendix/apis/ml-training-client/
@@ -23,9 +24,9 @@ The ML training client API supports the following methods:
 
 To use the ML training client API, you need to instantiate a `ViamClient` and then instantiate an `MLTrainingClient`.
 
-You need an API key and API key ID with [Org owner permissions](/manage/manage/rbac/#organization-settings-and-roles) to use the MLTraining client API.
+You need an API key and API key ID with [Org owner permissions](/organization/rbac/#organization-settings-and-roles) to use the MLTraining client API.
 To get an API key (and corresponding ID), use the [web UI](/operate/control/api-keys/#add-an-api-key)
-to the [Viam CLI](/dev/tools/cli/#create-an-organization-api-key).
+to the [Viam CLI](/cli/).
 
 {{< tabs >}}
 {{% tab name="From a client application" %}}
diff --git a/docs/dev/reference/apis/robot.md b/docs/reference/apis/robot.md
similarity index 89%
rename from docs/dev/reference/apis/robot.md
rename to docs/reference/apis/robot.md
index b3cc8a2eb1..291b8a1e62 100644
--- a/docs/dev/reference/apis/robot.md
+++ b/docs/reference/apis/robot.md
@@ -6,6 +6,7 @@ type: "docs"
 description: "How to use the machine API to monitor and manage your machines."
 tags: ["robot state", "sdk", "apis", "robot api"]
 aliases:
+  - /dev/reference/apis/robot/
   - /program/apis/robot/
   - /build/program/apis/robot/
   - /appendix/apis/robot/
@@ -13,7 +14,7 @@ date: "2022-01-01"
 # updated: ""  # When the content was last entirely checked
 ---
 
-The _machine API_ allows you to connect to your machine from within a supported [Viam SDK](/dev/reference/apis/), retrieve status information, and send commands remotely.
+The _machine API_ allows you to connect to your machine from within a supported [Viam SDK](/reference/apis/), retrieve status information, and send commands remotely.
 
 The machine API is supported for use with the [Viam Python SDK](https://python.viam.dev/autoapi/viam/robot/client/index.html#viam.robot.client.RobotClient), the [Viam Go SDK](https://pkg.go.dev/go.viam.com/rdk/robot/client#RobotClient), and the [Viam C++ SDK](https://cpp.viam.dev/classviam_1_1sdk_1_1RobotClient.html).
 
diff --git a/docs/dev/reference/apis/services/_index.md b/docs/reference/apis/services/_index.md
similarity index 71%
rename from docs/dev/reference/apis/services/_index.md
rename to docs/reference/apis/services/_index.md
index c1f9c960ab..39474a44b3 100644
--- a/docs/dev/reference/apis/services/_index.md
+++ b/docs/reference/apis/services/_index.md
@@ -4,9 +4,10 @@ title: "Service APIs"
 weight: 5
 empty_node: true
 layout: "empty"
-canonical: "/dev/reference/apis/"
+canonical: "/reference/apis/"
 type: "docs"
 aliases:
+  - /dev/reference/apis/services/
   - appendix/apis/services/
   - /services/
 ---
diff --git a/docs/dev/reference/apis/services/base-rc.md b/docs/reference/apis/services/base-rc.md
similarity index 94%
rename from docs/dev/reference/apis/services/base-rc.md
rename to docs/reference/apis/services/base-rc.md
index 398a55e40a..1569076801 100644
--- a/docs/dev/reference/apis/services/base-rc.md
+++ b/docs/reference/apis/services/base-rc.md
@@ -1,7 +1,7 @@
 ---
 title: "Base remote control service API"
 linkTitle: "Base remote control"
-weight: 70
+weight: 10
 type: "docs"
 tags: ["base", "services", "rover", "input controller", "remote control"]
 description: "Give commands to get a list of inputs from the controller that are being monitored for that control mode."
@@ -9,6 +9,7 @@ icon: true
 images: ["/services/icons/base-rc.svg"]
 date: "2022-01-01"
 aliases:
+  - /dev/reference/apis/services/base-rc/
   - /appendix/apis/services/base-rc/
 # updated: ""  # When the content was last entirely checked
 ---
diff --git a/docs/dev/reference/apis/services/data.md b/docs/reference/apis/services/data.md
similarity index 76%
rename from docs/dev/reference/apis/services/data.md
rename to docs/reference/apis/services/data.md
index 1c6bc06f2a..86abf924c5 100644
--- a/docs/dev/reference/apis/services/data.md
+++ b/docs/reference/apis/services/data.md
@@ -1,25 +1,26 @@
 ---
 title: "Data management service API"
 linkTitle: "Data management"
-weight: 10
+weight: 20
 type: "docs"
 description: "Give commands to your data management service to sync data stored on the machine it is deployed on to the cloud."
 icon: true
 images: ["/icons/components/arm.svg"]
 date: "2022-01-01"
 aliases:
+  - /dev/reference/apis/services/data/
   - /appendix/apis/services/data/
 # updated: ""  # When the content was last entirely checked
 ---
 
 The data management service API allows you to sync data stored on the machine it is deployed on to the cloud.
 
-The [data management service](/data-ai/capture-data/capture-sync/) supports the following methods:
+The [data management service](/data/capture-sync/capture-and-sync-data/) supports the following methods:
 
 {{< readfile "/static/include/services/apis/generated/data_manager-table.md" >}}
 
 The data client API supports a separate set of methods that allow you to upload and export data to and from Viam.
-For information about that API, see [Data Client API](/dev/reference/apis/data-client/).
+For information about that API, see [Data Client API](/reference/apis/data-client/).
 
 ## API
 
diff --git a/docs/dev/reference/apis/services/discovery.md b/docs/reference/apis/services/discovery.md
similarity index 93%
rename from docs/dev/reference/apis/services/discovery.md
rename to docs/reference/apis/services/discovery.md
index 595b848e58..842e268429 100644
--- a/docs/dev/reference/apis/services/discovery.md
+++ b/docs/reference/apis/services/discovery.md
@@ -1,12 +1,14 @@
 ---
 title: "Discovery service API"
 linkTitle: "Discovery"
-weight: 80
+weight: 30
 type: "docs"
 tags: ["navigation", "services", "resources", "components"]
 description: "Reveal which resources are available to configure on a machine based on the hardware that is physically present."
 date: "2025-02-18"
 # updated: ""  # When the content was last entirely checked
+aliases:
+  - /dev/reference/apis/services/discovery/
 ---
 
 The discovery service API allows you to get a list of resources available to configure on a machine based on the hardware that is connected to or part of the machine.
diff --git a/docs/dev/reference/apis/services/generic.md b/docs/reference/apis/services/generic.md
similarity index 87%
rename from docs/dev/reference/apis/services/generic.md
rename to docs/reference/apis/services/generic.md
index 9ceb812855..37d1db9afe 100644
--- a/docs/dev/reference/apis/services/generic.md
+++ b/docs/reference/apis/services/generic.md
@@ -1,7 +1,7 @@
 ---
 title: "Generic service API"
 linkTitle: "Generic"
-weight: 60
+weight: 40
 type: "docs"
 tags: ["generic", "services"]
 description: "Give commands to your generic components for running model-specific commands using DoCommand."
@@ -14,7 +14,7 @@ aliases:
 # updated: ""  # When the content was last entirely checked
 ---
 
-The generic service API allows you to give commands to your [generic services](/operate/reference/services/generic/) for running model-specific commands using [`DoCommand`](/dev/reference/apis/services/generic/#docommand).
+The generic service API allows you to give commands to your [generic services](/operate/reference/services/generic/) for running model-specific commands using [`DoCommand`](/reference/apis/services/generic/#docommand).
 
 The generic service supports the following methods:
 
diff --git a/docs/dev/reference/apis/services/ml.md b/docs/reference/apis/services/ml.md
similarity index 83%
rename from docs/dev/reference/apis/services/ml.md
rename to docs/reference/apis/services/ml.md
index ce7e273a71..83f81e0c8e 100644
--- a/docs/dev/reference/apis/services/ml.md
+++ b/docs/reference/apis/services/ml.md
@@ -1,7 +1,7 @@
 ---
 title: "ML model service API"
 linkTitle: "ML model"
-weight: 30
+weight: 50
 type: "docs"
 tags: ["data management", "ml", "model training"]
 description: "Give commands to your ML model service to make inferences based on a provided ML model."
@@ -9,13 +9,14 @@ icon: true
 images: ["/services/icons/ml.svg"]
 date: "2022-01-01"
 aliases:
+  - /dev/reference/apis/services/ml/
   - /appendix/apis/services/ml/
 # updated: ""  # When the content was last entirely checked
 ---
 
 The ML model service API allows you to make inferences based on a provided ML model.
 
-The [ML Model service](/data-ai/ai/deploy/) supports the following methods:
+The [ML Model service](/vision/configure/) supports the following methods:
 
 {{< readfile "/static/include/services/apis/generated/mlmodel-table.md" >}}
 
diff --git a/docs/dev/reference/apis/services/motion.md b/docs/reference/apis/services/motion.md
similarity index 93%
rename from docs/dev/reference/apis/services/motion.md
rename to docs/reference/apis/services/motion.md
index 6fa8bcab64..fbbd8333ec 100644
--- a/docs/dev/reference/apis/services/motion.md
+++ b/docs/reference/apis/services/motion.md
@@ -1,13 +1,14 @@
 ---
 title: "Motion service API"
 linkTitle: "Motion"
-weight: 40
+weight: 60
 type: "docs"
 description: "Give commands to move a machine's components from one location or pose to another."
 icon: true
 images: ["/icons/components/arm.svg"]
 date: "2022-01-01"
 aliases:
+  - /dev/reference/apis/services/motion/
   - /appendix/apis/services/motion/
 # updated: ""  # When the content was last entirely checked
 ---
diff --git a/docs/dev/reference/apis/services/navigation.md b/docs/reference/apis/services/navigation.md
similarity index 93%
rename from docs/dev/reference/apis/services/navigation.md
rename to docs/reference/apis/services/navigation.md
index e65fa5b7f6..aba86e9603 100644
--- a/docs/dev/reference/apis/services/navigation.md
+++ b/docs/reference/apis/services/navigation.md
@@ -1,7 +1,7 @@
 ---
 title: "Navigation service API"
 linkTitle: "Navigation"
-weight: 50
+weight: 70
 type: "docs"
 tags: ["navigation", "services", "base", "rover"]
 description: "Give commands to define waypoints and move your machine along those waypoints while avoiding obstacles."
@@ -9,6 +9,7 @@ icon: true
 images: ["/services/icons/navigation.svg"]
 date: "2022-01-01"
 aliases:
+  - /dev/reference/apis/services/navigation/
   - /appendix/apis/services/navigation/
 # updated: ""  # When the content was last entirely checked
 ---
diff --git a/docs/dev/reference/apis/services/vision.md b/docs/reference/apis/services/vision.md
similarity index 86%
rename from docs/dev/reference/apis/services/vision.md
rename to docs/reference/apis/services/vision.md
index 8f9d044e35..6328afef03 100644
--- a/docs/dev/reference/apis/services/vision.md
+++ b/docs/reference/apis/services/vision.md
@@ -1,7 +1,7 @@
 ---
 title: "Vision service API"
 linkTitle: "Vision"
-weight: 20
+weight: 80
 type: "docs"
 description: "Give commands to get detections, classifications, or point cloud objects, depending on the ML model the vision service is using."
 aliases:
@@ -47,8 +47,8 @@ The returned detections consist of the bounding box around the identified object
 
 **Supported API methods:**
 
-- [GetDetections()](/dev/reference/apis/services/vision/#getdetections)
-- [GetDetectionsFromCamera()](/dev/reference/apis/services/vision/#getdetectionsfromcamera)
+- [GetDetections()](/reference/apis/services/vision/#getdetections)
+- [GetDetectionsFromCamera()](/reference/apis/services/vision/#getdetectionsfromcamera)
 
 ## Classifications
 
@@ -65,8 +65,8 @@ The returned classifications consist of the image's class label and confidence s
 
 **Supported API methods:**
 
-- [GetClassifications()](/dev/reference/apis/services/vision/#getclassifications)
-- [GetClassificationsFromCamera()](/dev/reference/apis/services/vision/#getclassificationsfromcamera)
+- [GetClassifications()](/reference/apis/services/vision/#getclassifications)
+- [GetClassificationsFromCamera()](/reference/apis/services/vision/#getclassificationsfromcamera)
 
 ## Segmentations
 
@@ -79,15 +79,15 @@ See our guide [Navigate with a Rover Base](/tutorials/services/navigate-with-rov
 Any camera that can return 3D pointclouds can use 3D object segmentation.
 
 {{% alert title="Tip" color="tip" %}}
-3D segmentation operations require [frame system](/operate/reference/services/frame-system/) configuration to properly relate camera coordinates to your machine's spatial reference frames.
+3D segmentation operations require [frame system](/operate/reference/) configuration to properly relate camera coordinates to your machine's spatial reference frames.
 This enables the vision service to provide meaningful 3D coordinates and spatial relationships.
 {{% /alert %}}
 
 **Supported API methods:**
 
-- [GetObjectPointClouds()](/dev/reference/apis/services/vision/#getobjectpointclouds)
+- [GetObjectPointClouds()](/reference/apis/services/vision/#getobjectpointclouds)
 
-The [vision service](/operate/reference/services/vision/) supports the following methods:
+The [vision service](/vision/configure/) supports the following methods:
 
 {{< readfile "/static/include/services/apis/generated/vision-table.md" >}}
 
diff --git a/docs/dev/reference/apis/services/world-state-store.md b/docs/reference/apis/services/world-state-store.md
similarity index 91%
rename from docs/dev/reference/apis/services/world-state-store.md
rename to docs/reference/apis/services/world-state-store.md
index 637a1d467d..8edcd13159 100644
--- a/docs/dev/reference/apis/services/world-state-store.md
+++ b/docs/reference/apis/services/world-state-store.md
@@ -1,7 +1,7 @@
 ---
 title: "World state store API"
 linkTitle: "World state store"
-weight: 70
+weight: 90
 type: "docs"
 tags: ["world_state_store", "services"]
 description: "Retrieve a list of world objects."
@@ -9,6 +9,8 @@ icon: true
 images: ["/icons/components/generic.svg"]
 date: "2025-09-12"
 # updated: ""  # When the content was last entirely checked
+aliases:
+  - /dev/reference/apis/services/world-state-store/
 ---
 
 The world state store service API allows you to retrieve a list of world objects.
diff --git a/docs/dev/reference/apis/sessions.md b/docs/reference/apis/sessions.md
similarity index 93%
rename from docs/dev/reference/apis/sessions.md
rename to docs/reference/apis/sessions.md
index 9aaefb7527..ec24ac8413 100644
--- a/docs/dev/reference/apis/sessions.md
+++ b/docs/reference/apis/sessions.md
@@ -1,7 +1,7 @@
 ---
 title: "Session management with Viam's client SDKs"
 linkTitle: "Session management"
-weight: 20
+weight: 50
 type: "docs"
 description: "Manage sessions between your machine and clients connected through Viam's SDKs."
 tags:
@@ -17,6 +17,7 @@ tags:
     "session management",
   ]
 aliases:
+  - /dev/reference/apis/sessions/
   - /program/apis/sessions/
   - /build/program/apis/sessions/
   - /appendix/apis/sessions/
@@ -30,10 +31,10 @@ The period of time during which a client is connected to a machine is called a _
 _Session management_ is a safety precaution that allows you to manage the clients that are authenticated and communicating with a machine's `viam-server` instance.
 The default session management configuration checks for presence to ensure that a machine only moves when a client is actively connected and stops any components that remain running when a client disconnects.
 This is especially important for machines that physically move.
-For example, imagine a wheeled rover gets a [`SetPower()`](/dev/reference/apis/components/base/#setpower) command as the last input from a client before the connection to the machine is interrupted.
+For example, imagine a wheeled rover gets a [`SetPower()`](/reference/apis/components/base/#setpower) command as the last input from a client before the connection to the machine is interrupted.
 Without session management, the API request from the client would cause the rover's motors to move, causing the machine to continue driving forever and potentially colliding with objects and people.
 
-For more information, see [Client Sessions and Machine Network Connectivity](/dev/reference/sdks/connectivity/).
+For more information, see [Client Sessions and Machine Network Connectivity](/reference/sdks/connectivity/).
 
 If you want to manage operations differently, you can manage your machine's client sessions yourself.
 The Session Management API provides functionality for:
@@ -41,7 +42,7 @@ The Session Management API provides functionality for:
 - clients to notify the machine that the client is actively authenticated and connected
 - the machine to stop moving components when a session ends
 
-### The `SessionsClient`
+## The `SessionsClient`
 
 A _client_ of a Viam machine can be a program using an SDK to control the machine, or all the different resources on the machine, including all {{< glossary_tooltip term_id="part" text="parts" >}} and sub-parts, like an input controller and a base, communicating.
 
@@ -60,7 +61,7 @@ If a resource was used by client A and then by client B, and client A disconnect
 
 A disconnected client will attempt to establish a new session immediately prior to the next operation it performs.
 
-#### Change the session timeout
+### Change the session timeout
 
 The default session timeout length is 20 seconds.
 To change this, pass the `timeout` parameter to the `DialOptions` object:
@@ -191,7 +192,7 @@ To manage your session with the session management API:
 ### Disable default session management
 
 The `SessionsClient` that serves the session management API is automatically enabled on your machine.
-It is instantiated as part of your [`RobotClient`](/dev/reference/apis/robot/) instance (client of the Machine API).
+It is instantiated as part of your [`RobotClient`](/reference/apis/robot/) instance (client of the Machine API).
 If you want to disable it, you can pass the option to your machine, as demonstrated in the following code snippets:
 
 {{< tabs >}}
@@ -241,6 +242,6 @@ You can do this with Viam's client SDKs.
 
 ### Use the session management API to manually manage sessions
 
-Use your [`RobotClient()`](/dev/reference/apis/robot/) instance to access the [`SessionsClient`](https://pkg.go.dev/go.viam.com/rdk/session) within your client SDK program.
+Use your [`RobotClient()`](/reference/apis/robot/) instance to access the [`SessionsClient`](https://pkg.go.dev/go.viam.com/rdk/session) within your client SDK program.
 This is a [gRPC](https://grpc.io/) client that `viam-server` instantiates at robot runtime.
 Then, define your own [`SessionsClient`](https://github.com/viamrobotics/rdk/blob/main/robot/client/client.go).
diff --git a/docs/reference/device-setup/_index.md b/docs/reference/device-setup/_index.md
new file mode 100644
index 0000000000..6f99a971e1
--- /dev/null
+++ b/docs/reference/device-setup/_index.md
@@ -0,0 +1,8 @@
+---
+title: "Device Setup"
+linkTitle: "Device Setup"
+weight: 55
+type: "docs"
+no_list: true
+description: "Setup guides for single-board computers and other devices supported by Viam."
+---
diff --git a/docs/reference/device-setup/beaglebone-setup.md b/docs/reference/device-setup/beaglebone-setup.md
new file mode 100644
index 0000000000..d2913ce91c
--- /dev/null
+++ b/docs/reference/device-setup/beaglebone-setup.md
@@ -0,0 +1,98 @@
+---
+title: "BeagleBone AI-64 Setup Guide"
+linkTitle: "BeagleBone Setup"
+weight: 20
+type: "docs"
+description: "Flash a BeagleBone AI-64 to prepare it for viam-server installation."
+images: ["/installation/thumbnails/beaglebone.png"]
+imageAlt: "BeagleBone A I-64"
+no_list: true
+aliases:
+  - /operate/reference/prepare/beaglebone-setup/
+  - "/installation/beaglebone-install/"
+  - "/installation/prepare/beaglebone-install/"
+  - "/installation/prepare/beaglebone-setup/"
+  - /get-started/installation/prepare/beaglebone-setup/
+  - /get-started/prepare/beaglebone-setup/
+date: "2022-01-01"
+# updated: ""  # When the content was last entirely checked
+# SMEs: Shawn and Rand
+---
+
+The [BeagleBone AI-64](https://docs.beagleboard.org/latest/boards/beaglebone/ai-64/) from [BeagleBoard.org](https://beagleboard.org/) is an open-source single-board computer with a Debian GNU/Linux operating system based on the Texas Instruments TDA4VM processor.
+Follow this guide to set up your BeagleBone AI-64 and prepare it for `viam-server` installation.
+
+<div class="td-max-width-on-larger-screens text-center">
+{{< imgproc alt="The front of a BeagleBone AI-64 single-board computer at a 45° angle." src="/installation/beaglebone-setup/image4.png" resize="400x" declaredimensions=true >}}
+</div>
+
+## Hardware requirements
+
+You need the following hardware, tools, and software to install `viam-server` on a BeagleBone AI-64:
+
+1. A [BeagleBone AI-64](https://www.beagleboard.org/boards/beaglebone-ai-64)
+2. A 5V barrel jack (recommended) and/or USB-C power supply, to power the BeagleBone
+3. Ethernet cable and/or WiFi dongle, to establish network connection on the BeagleBone
+4. (Optional) A microSD card and a way to connect the microSD card to the computer (like a microSD slot or microSD reader)
+   - This is required if you need to set up your BeagleBone for the first time or update your BeagleBone to the latest software image.
+
+The following instructions mirror the instructions given in the [BeagleBoard Quick Start Guide](https://docs.beagleboard.org/latest/boards/beaglebone/ai-64/02-quick-start.html).
+
+If you want additional help setting up your BeagleBone, you can follow the guides there and return to the Viam docs after SSH'ing into your BeagleBone.
+
+## Power your BeagleBone
+
+Power your board by plugging a 5VDC power source into the BeagleBone's barrel jack.
+You can also power the BeagleBone with a USB-C cable, but a 5VDC power source is recommended for more reliable performance.
+
+If the board has power, the LED on the board labeled _PWR_ or _ON_ is lit steadily.
+
+## Enable a network connection
+
+You need to enable a network connection on your BeagleBone to install `viam-server` on it.
+You can do this in multiple ways:
+
+- Connect an ethernet cable to your BeagleBone's ethernet port.
+- If you are working on a macOS machine, use [internet sharing over USB](https://support.apple.com/guide/mac-help/share-internet-connection-mac-network-users-mchlp1540/mac) to share your connection.
+  After enabling the option on your machine, SSH into your BeagleBone and run `sudo dhclient usb1`.
+- If you are working on a Linux machine, read [these tips on enabling a network connection](https://elinux.org/Beagleboard:Terminal_Shells).
+- If your personal computer supports mDNS (Multicast DNS), you can check to see if your BeagleBone board has established a network connection by visiting [beaglebone.local](https://beaglebone.local).
+
+## SSH into your BeagleBone from your PC
+
+You can SSH into your BeagleBone by running the following command in your terminal:
+
+`ssh <your-username>@<your-hostname>.local`
+
+By default, the hostname, username and password on a BeagleBone are:
+
+- Hostname: `beaglebone`
+- Username: `debian`
+- Password: `temppwd`
+
+Therefore, if you are using the default settings on your BeagleBone, the command is:
+
+`ssh debian@beaglebone.local`
+
+## Update your BeagleBone
+
+After SSH'ing into your BeagleBone, verify all packages are up to date:
+
+`sudo apt update && sudo apt dist-upgrade && sudo reboot`
+
+## Next steps
+
+You have now installed an operating system on your BeagleBone.
+To use your BeagleBone, follow the [setup guide](/operate/install/setup/):
+
+{{< cards >}}
+{{% card link="/operate/install/setup/" %}}
+{{< /cards >}}
+
+## Troubleshooting
+
+If you experience any issues getting Viam working on your BeagleBone, consult the [BeagleBone documentation](https://docs.beagleboard.org/latest/boards/beaglebone/ai-64/02-quick-start.html) for help updating your BeagleBone.
+
+{{< snippet "social.md" >}}
+
+You can find additional assistance in the [Troubleshooting section](/monitor/troubleshoot/).
diff --git a/docs/reference/device-setup/board1-setup.md b/docs/reference/device-setup/board1-setup.md
new file mode 100644
index 0000000000..43d7f52c12
--- /dev/null
+++ b/docs/reference/device-setup/board1-setup.md
@@ -0,0 +1,76 @@
+---
+title: "<board-series-model> Setup Guide"
+linkTitle: "<board-series-model> Setup"
+weight: 16
+type: "docs"
+description: "Flash an <storage-medium> for the <board-series-model> to prepare it for viam-server installation."
+images: ["/installation/thumbnails/prepare.png"]
+imageAlt: "<board-series-model>"
+no_list: true
+draft: true
+date: "2022-01-01"
+# updated: ""  # When the content was last entirely checked
+aliases:
+  - /operate/reference/prepare/board1-setup/
+---
+
+The [<board-series-model>](http://example.com) from <manufacturer/organization> is a <brief-board-description-including-features-and-specifications>.
+It supports <operating-systems-or-distributions> and is ideal for <use-cases-or-applications>.
+Follow this guide to set up your <board-series-model> and prepare it for `viam-server` installation.
+
+{{<imgproc src="installation/thumbnails/prepare.png" alt="The <board-series-model> single-board computer." resize="350x" declaredimensions=true >}}
+
+## Hardware requirements
+
+- Development machine: laptop or computer workstation
+- An [<board-series-model>](http://example.com) board
+- ...
+
+## Install OS
+
+The <board-series-model> boots from a <storage-medium>.
+You need to install an operating system on the <storage-medium> that you will use with your <board-series-model>.
+
+<Viam-specific-OS-installation-instructions OR link-to-board-OS-installation-guide-from-company>
+
+## Power your <board-series-model>
+
+To power your <board-series-model>, connect your power adapter to the board's <port-type> port.
+The LED should light up, which indicates that the board is powered.
+
+{{% alert title="Tip" color="tip" %}}
+
+If your board's LED does not light up when powered, try re-flashing your <storage-medium> or using a different <storage-medium>.
+
+{{% /alert %}}
+
+To connect to a display, connect the <HDMI/micro-HDMI> end of your HDMI cable to the <board> and the other end to your monitor.
+Then, to connect the keyboard and mouse, plug the two devices into your computer's USB hub and connect the USB hub to your <board-series-model>'s <USB-type> port.
+
+## Establish a network connection
+
+You can plug the Ethernet cable into your <board-series-model> for a wired internet connection.
+For a wireless connection, you can <alternative-wireless-network-connection-methods>.
+
+### Update your <board-series-model>
+
+Once you're connected to your board, you can verify all packages are up to date by running the following command:
+
+`sudo apt update && sudo apt dist-upgrade && sudo reboot`
+
+## Next steps
+
+You have now installed an operating system on your BOARD.
+To use your BOARD, follow the [setup guide](/operate/install/setup/):
+
+{{< cards >}}
+{{% card link="/operate/install/setup/" %}}
+{{< /cards >}}
+
+## Troubleshooting
+
+If you experience any issues getting Viam to work on your <board-series-model>, consult the [<board-series-model> documentation](http://example.com).
+
+{{< snippet "social.md" >}}
+
+You can find additional assistance in the [Troubleshooting section](/monitor/troubleshoot/).
diff --git a/docs/reference/device-setup/jetson-agx-orin-setup.md b/docs/reference/device-setup/jetson-agx-orin-setup.md
new file mode 100644
index 0000000000..6c63d0d677
--- /dev/null
+++ b/docs/reference/device-setup/jetson-agx-orin-setup.md
@@ -0,0 +1,159 @@
+---
+title: "NVIDIA Jetson AGX Orin Setup Guide"
+linkTitle: "Jetson AGX Orin Setup"
+weight: 20
+type: "docs"
+images: ["/installation/thumbnails/jetson-agx-orin-dev-kit.png"]
+imageAlt: "Jetson A G X Orin Developer Kit"
+description: "Set up the Jetson AGX Orin Developer Kit to prepare your NVIDIA Jetson AGX Orin for viam-server installation."
+no_list: true
+aliases:
+  - /operate/reference/prepare/jetson-agx-orin-setup/
+  - /installation/prepare/jetson-agx-orin-setup/
+  - /get-started/installation/prepare/jetson-agx-orin-setup/
+  - /get-started/prepare/jetson-agx-orin-setup/
+date: "2022-01-01"
+# updated: ""  # When the content was last entirely checked
+# SMEs: Pete Garafano
+---
+
+<div class="td-max-width-on-larger-screens text-center">
+{{<imgproc src="installation/thumbnails/jetson-agx-orin-dev-kit.png" alt="The grey and chunky front of the NVIDIA Jetson AGX Orin single-board computer development kit." resize="200x" declaredimensions=true >}}
+</div>
+
+The [Jetson AGX Orin](https://developer.nvidia.com/embedded/jetson-orin) from [NVIDIA](https://www.nvidia.com/) is a single-board computer that supports modern AI workloads and application development.
+Follow this guide to set up the [Jetson AGX Orin Developer Kit](https://developer.nvidia.com/embedded/learn/get-started-jetson-agx-orin-devkit) to prepare your NVIDIA Jetson AGX Orin for `viam-server` installation.
+
+<div style="clear:both;"><br /></div>
+
+{{< alert title="Important" color="note" >}}
+
+This guide assumes that you have a Jetson AGX Orin Developer Kit with a Jetson AGX Orin module and reference carrier board.
+If you want to use a different carrier board to incorporate your Orin into your machine, the type of carrier board you use will affect your hardware requirements.
+
+{{% /alert %}}
+
+{{% alert title="CAUTION: Use 3.3V inputs and outputs" color="caution" %}}
+
+The GPIO pins on Jetson boards are rated 3.3V signals. 5V signals from encoders and sensors can cause damage to a pin. We recommend selecting hardware that can operate 3.3V signals or lower.
+For details, see your board's specification.
+
+{{% /alert %}}
+
+## Hardware requirements
+
+You need the following hardware, tools, and software to install `viam-server` on a Jetson AGX Orin with the Jetson AGX Orin Developer Kit:
+
+**Initial setup with display attached:**
+
+1. A [Jetson AGX Orin Developer Kit](https://developer.nvidia.com/embedded/learn/get-started-jetson-agx-orin-devkit)
+2. A PC monitor (HDMI or DisplayPort)
+3. USB keyboard and mouse
+4. A DisplayPort to HDMI adapter/cable, to connect the Orin to the monitor
+5. USB Type-C power supply, to power the Orin (included with the AGX Orin Developer Kit)
+6. (Optional) Ethernet cable, to connect the Orin to the internet without Wifi access
+
+**Initial setup in headless mode:**
+
+1. A [Jetson AGX Orin Developer Kit](https://developer.nvidia.com/embedded/learn/get-started-jetson-agx-orin-devkit)
+2. An internet-connected Windows, Linux, or macOS computer
+3. A way to connect the computer to the Orin (for example, the USB Type-A to USB Type-C Cable included with the AGX Orin Developer Kit)
+
+   (Optional) If your computer doesn't have a USB Type-A port, you may need to attach a [USB-C hub](https://toomanyadapters.com/best-usb-hubs/) or similar device to your computer to connect to the Orin
+
+4. USB Type-C power supply, to power the Orin (included with the AGX Orin Developer Kit)
+5. (Optional) Ethernet cable, to connect the Orin to the internet without Wifi access
+
+## Jetson Orin setup guide
+
+Follow the instructions in [Getting Started with Jetson AGX Orin Developer Kit](https://developer.nvidia.com/embedded/learn/get-started-jetson-agx-orin-devkit) to boot up your Orin for the first time.
+
+If you have already booted up your Orin, start with "Step 2 - Install JetPack Components" to make sure you have installed the latest NVIDIA JetPack components.
+
+{{< alert title="Note" color="note" >}}
+Some vision services in the [registry](https://app.viam.com/registry) require you to install Jetpack 6 on your Jetson AGX Orin.
+If you intend to use GPIO, however, we recommend installing Jetpack 5 on your Jetson AGX Orin.
+{{< /alert >}}
+
+Look at the Troubleshooting section below for help navigating these instructions.
+Once you have reached _Next Steps_, return to the Viam docs.
+
+{{< alert title="Tip: <code>viam-server</code> installation with <code>curl</code>" color="tip" >}}
+
+If `curl` is not installed on your Orin, run `sudo apt install curl` before downloading the `viam-server` binary.
+
+If this command fails, try using `wget https://storage.googleapis.com/packages.viam.com/apps/viam-server/viam-server-latest-aarch64.AppImage` to download the `viam-server` binary.
+
+{{% /alert %}}
+
+## Camera setup
+
+1. Install E-Con Systems [e-CAM20_CUOAGX](https://www.e-consystems.com/nvidia-cameras/jetson-agx-orin-cameras/full-hd-ar0234-color-global-shutter-camera.asp) AR0234 driver.
+   Consult the instructions you received when purchasing your device for more information.
+2. Ensure the driver has successfully installed by running `sudo dmesg | grep ar0234`. The output should include `ar0234 Detected Ar0234 sensor`.
+3. Connect the AR0234 camera module and daughterboard to the J509 port located at the bottom of the Developer Kit.
+4. Configure the camera as a [webcam](/hardware/common-components/add-a-camera/).
+
+## Serial communication protocol tips
+
+To change the pins that are in use for modes of serial communication, launch <file>jetson-io.py</file> with the following commands:
+
+```sh { class="command-line" data-prompt="$"}
+cd ~
+sudo /opt/nvidia/jetson-io/jetson-io.py
+```
+
+In the interactive menu that opens, select **Configure Jetson 40 Pin Header** and **Configure header pins manually** to select and deselect pins to enable use.
+For a Jetson AGX Orin, reference the following:
+
+<!-- prettier-ignore -->
+| Data Sheet ID | GPIO Header Pin | Viam Bus ID | `jetson-io.py` ID | `/dev` Path ID | Notes |
+| ------------- | --------------- | ----------- | ----------------- | ----------- | ----- |
+| I2C_GP2_DAT, I2C_GP2_CLK | 3, 5 | `7` | `i2c2` | `/dev/i2c-2` | |
+| I2C_GP5_DAT, I2C_GP5_CLK | 27, 28 | `1` | `i2c8` | `/dev/i2c-8` | |
+| SPI1_DOUT, SPI1_DIN, SPI1_SCK, SPI1_CS0, SPI1_CS1 | 19, 21, 23, 24, 26 | `0` | `spi1` | `/dev/spidev0.0`, `/dev/spidev0.1` | Must be enabled to use SPI bus, must add `spidev` to `/etc/modules` |
+
+Note that I2C buses do not need to be configured through <file>jetson-io.py</file>.
+See NVIDIA's documentation on [Configuring the Jetson Expansion Headers](https://docs.nvidia.com/jetson/archives/r35.1/DeveloperGuide/text/HR/ConfiguringTheJetsonExpansionHeaders.html) for more information.
+
+## Next steps
+
+You have now installed an operating system on your Jetson board.
+To use your Jetson board, follow the [setup guide](/operate/install/setup/):
+
+{{< cards >}}
+{{% card link="/operate/install/setup/" %}}
+{{< /cards >}}
+
+## Troubleshooting
+
+### Setup tips
+
+- NVIDIA Step 1 - Run through Ubuntu Setup (oem config)
+
+  - Headless Mode Tips:
+    - Once you reach **step e** which instructs you to connect through the host serial port, the instructions to connect are immediately under **step e**.
+      Follow those steps according to the type of computer you're using.
+    - After running `sudo screen`, note that the `Password` input prompt immediately following refers to your computer's system password.
+  - "Jetson Initial configuration" (oem-config) Command Prompt Tips:
+    - App Partition: default is fine.
+    - Nvomodel mode: default is fine.
+    - Chromium install: not necessary, you can skip.
+    - Signing into online accounts: not necessary, you can skip.
+
+- NVIDIA Step 2 - Install JetPack Components
+  - After running `sudo apt dist-upgrade`, if you are prompted with "Package distributor has shipped an updated version" hit `y` to install the updated version.
+  - Do not run `sudo apt install nvidia-jetpack` in your terminal until after `sudo reboot` has completed.
+  - If your board is powered off after `sudo reboot` has completed and refuses to turn on, disconnect and reconnect the power cable.
+  - It is normal for JetPack installation to take a very long time, up to an hour or more.
+- If you do not see an interactive menu after launching <file>jetson-io.py</file>, try resizing your window to a large size.
+
+### Install `curl`
+
+If `curl` is not installed on your Orin, run `sudo apt install curl` before downloading the `viam-server` binary.
+
+If this command fails, try using `wget https://storage.googleapis.com/packages.viam.com/apps/viam-server/viam-server-stable-aarch64.AppImage` to download the `viam-server` binary.
+
+You can find additional assistance in the [Troubleshooting section](/monitor/troubleshoot/).
+
+{{< snippet "social.md" >}}
diff --git a/docs/reference/device-setup/jetson-nano-setup.md b/docs/reference/device-setup/jetson-nano-setup.md
new file mode 100644
index 0000000000..502b3b1922
--- /dev/null
+++ b/docs/reference/device-setup/jetson-nano-setup.md
@@ -0,0 +1,125 @@
+---
+title: "NVIDIA Jetson Nano and Orin Nano Setup Guide"
+linkTitle: "Jetson Nano and Orin Nano Setup"
+weight: 20
+type: "docs"
+images: ["/installation/thumbnails/jetson-nano-dev-kit.png"]
+imageAlt: "Jetson Nano"
+description: "Prepare your Jetson Nano or Jetson Orin Nano for viam-server installation."
+no_list: true
+aliases:
+  - /operate/reference/prepare/jetson-nano-setup/
+  - /installation/prepare/jetson-nano-setup/
+  - /get-started/installation/prepare/jetson-nano-setup/
+  - /get-started/prepare/jetson-nano-setup/
+date: "2022-01-01"
+# updated: ""  # When the content was last entirely checked
+# SMEs: Pete Garafano
+---
+
+The [Jetson Nano](https://developer.nvidia.com/embedded/jetson-nano) and [Jetson Orin Nano](https://www.nvidia.com/en-us/autonomous-machines/embedded-systems/jetson-orin) from [NVIDIA](https://www.nvidia.com/) are small computers built for embedded applications and capable of supporting modern AI workloads.
+Follow this guide to set up the [Jetson Nano Developer Kit](https://developer.nvidia.com/embedded/jetson-nano-developer-kit) or the [Jetson Orin Nano Developer Kit](https://developer.nvidia.com/embedded/jetson-agx-orin-developer-kit) to prepare your NVIDIA Jetson Nano for `viam-server` installation.
+
+<div class="td-max-width-on-larger-screens text-center">
+{{<imgproc src="installation/thumbnails/jetson-nano-dev-kit.png" resize="200x" alt="The front of the NVIDIA Jetson Nano single-board computer development kit.">}}
+{{<imgproc src="installation/thumbnails/jetson-orin-nano.jpeg" resize="200x" alt="The front of the NVIDIA Jetson Orin Nano single-board computer development kit.">}}
+</div>
+
+{{% alert title="Important" color="note" %}}
+
+This guide assumes that you have a Jetson Nano Developer Kit or a Jetson Orin Nano Developer Kit with a Jetson module and reference carrier board.
+If you want to use a different carrier board to incorporate your Nano into your machine, the type of carrier board you use will affect your hardware requirements.
+
+{{% /alert %}}
+
+{{% alert title="CAUTION: Use 3.3V inputs and outputs" color="caution" %}}
+
+The GPIO pins on Jetson boards are rated 3.3V signals. 5V signals from encoders and sensors can cause damage to a pin. We recommend selecting hardware that can operate 3.3V signals or lower. For details, see pages 1-3 of the [Jetson Nano Developer Kit 40-Pin Expansion Header GPIO Usage Considerations Applications Note](https://developer.nvidia.com/jetson-nano-developer-kit-40-pin-expansion-header-gpio-usage-considerations-applications-note).
+
+{{% /alert %}}
+
+## Hardware requirements
+
+You need the following hardware, tools, and software to install `viam-server` on a Jetson Nano or Jetson Orin Nano:
+
+**Initial setup with display attached:**
+
+1. A [Jetson Nano Developer Kit](https://developer.nvidia.com/embedded/jetson-nano-developer-kit) or [Jetson Orin Nano Developer Kit](https://developer.nvidia.com/embedded/jetson-agx-orin-developer-kit)
+2. A microSD card (32GB UHS-1 minimum recommended)
+3. A computer display (HDMI or DP) with a USB keyboard and mouse
+4. A way to connect the microSD card to the computer (like a microSD slot or microSD reader)
+5. Ethernet cable and/or Wifi dongle, to establish network connection on the Nano
+6. 5V-2A (Nano) or 9-19V (Orin Nano) DC power supply with barrel jack connector
+
+**Initial setup in headless mode:**
+
+1. A [Jetson Nano Developer Kit](https://developer.nvidia.com/embedded/jetson-nano-developer-kit) or [Jetson Orin Nano Developer Kit](https://developer.nvidia.com/embedded/jetson-agx-orin-developer-kit)
+2. A microSD card (32GB UHS-1 minimum recommended)
+3. An internet-connected computer
+4. A way to connect the computer to the Nano (like a USB 2.0 A-Male to Micro B Cable)
+5. A way to connect the microSD card to the computer (like a microSD slot or microSD reader)
+6. Ethernet cable and/or Wifi dongle, to establish network connection on the Nano
+7. 5V-2A (Nano) or 9-19V (Orin Nano) DC power supply with barrel jack connector
+
+## Nano setup guide
+
+Follow the instructions in [Getting Started with Jetson Nano Developer Kit](https://developer.nvidia.com/embedded/learn/get-started-jetson-nano-devkit) or [Getting Started with Jetson Orin Nano Developer Kit](https://developer.nvidia.com/embedded/learn/get-started-jetson-orin-nano-devkit).
+Once you have reached _Next Steps_, return to the Viam docs.
+
+{{< alert title="Note" color="note" >}}
+Some vision services in the [registry](https://app.viam.com/registry) require you to install Jetpack 6 on your Jetson AGX Orin.
+If you intend to use GPIO, however, we recommend installing Jetpack 5 on your Jetson AGX Orin.
+{{< /alert >}}
+
+## Serial communication protocol tips
+
+To change the pins that are in use for modes of serial communication, launch <file>jetson-io.py</file> with the following commands:
+
+```sh { class="command-line" data-prompt="$"}
+cd ~
+sudo /opt/nvidia/jetson-io/jetson-io.py
+```
+
+In the interactive menu that opens, select **Configure Jetson 40 Pin Header** and **Configure header pins manually** to select and deselect pins to enable use.
+For a Jetson Orin Nano, reference the following:
+
+<!-- prettier-ignore -->
+| GPIO Header Pin | Viam Bus ID | `jetson-io.py` ID |
+| --------------- | ----------- | ----------------- |
+| 3, 5 | `7` | `i2c2` |
+| 27, 28 | `1` | `i2c8` |
+| 19, 21, 23, 24, 26 | `0` | `spi1` |
+| 13, 16, 18, 22, 37 | `2` | `spi3` |
+| 15 | | `pwm1` |
+| 33 | | `pwm5` |
+
+Note that I2C buses do not need to be configured through <file>jetson-io.py</file>.
+See NVIDIA's documentation on [Configuring the Jetson Expansion Headers](https://docs.nvidia.com/jetson/archives/r35.1/DeveloperGuide/text/HR/ConfiguringTheJetsonExpansionHeaders.html) for more information.
+
+## Next steps
+
+You have now installed an operating system on your Jetson board.
+To use your Jetson board, follow the [setup guide](/operate/install/setup/):
+
+{{< cards >}}
+{{% card link="/operate/install/setup/" %}}
+{{< /cards >}}
+
+## Troubleshooting
+
+### Install `curl`
+
+If `curl` is not installed on your Orin, run `sudo apt install curl` before downloading the `viam-server` binary.
+
+If this command fails, try using `wget https://storage.googleapis.com/packages.viam.com/apps/viam-server/viam-server-stable-aarch64.AppImage` to download the `viam-server` binary.
+
+### Barrel jack power supply polarity
+
+Make sure the polarity on your barrel jack power supply is matched when powering your machine.
+See the last step of your appropriate [initial setup guide](#hardware-requirements) for instructions on choosing the correct power supply for your Nano board.
+
+If you do not see an interactive menu after launching <file>jetson-io.py</file>, try resizing your window to a large size.
+
+You can find additional assistance in the [Troubleshooting section](/monitor/troubleshoot/).
+
+{{< snippet "social.md" >}}
diff --git a/docs/reference/device-setup/odroid-c4-setup.md b/docs/reference/device-setup/odroid-c4-setup.md
new file mode 100644
index 0000000000..c9ec5bc0a5
--- /dev/null
+++ b/docs/reference/device-setup/odroid-c4-setup.md
@@ -0,0 +1,80 @@
+---
+title: "Odroid C4 Setup Guide"
+linkTitle: "Odroid-C4 Setup"
+weight: 16
+type: "docs"
+description: "Image a Odroid-C4 to prepare it for viam-server installation."
+images: ["/installation/thumbnails/odroid-c4.png"]
+imageAlt: "Odroid-C4"
+no_list: true
+aliases:
+  - /operate/reference/prepare/odroid-c4-setup/
+  - /get-started/installation/prepare/odroid-c4-setup/
+  - /get-started/prepare/odroid-c4-setup/
+  - /installation/prepare/odroid-c4-setup/
+date: "2022-01-01"
+# updated: ""  # When the content was last entirely checked
+# SME: Olivia Miller
+---
+
+The [Odroid-C4](https://wiki.odroid.com/odroid-c4/odroid-c4#odroid-c4) is a single-board computer that features an Amlogic S905x3 CPU and runs a variety of Linux or Android distributions.
+
+{{<imgproc src="installation/thumbnails/odroid-c4.png" alt="The Odroid-C4 single-board computer." resize="350x" declaredimensions=true >}}
+
+Follow this guide to set up your Odroid-C4.
+
+## Hardware requirements
+
+- An [Odroid-C4 board](https://www.hardkernel.com/shop/odroid-c4/)
+- A 12V/2A power supply
+- An ethernet cable and/or USB Wi-Fi dongle, for network connectivity
+- A computer, for development
+- A microSD card, if you plan to boot from SD instead of eMMC
+- (Optional) An HDMI cable, for display
+
+## Power your Odroid C4
+
+Before you power the board, you need to install an operating system.
+Visit [Odroid's OS Installation Guide](https://wiki.odroid.com/getting_started/os_installation_guide#os_installation_guide) to choose the right OS for your needs and follow the instructions to flash the OS to your microSD card or eMMC.
+
+To power your Odroid-C4, connect your power adapter to the Odroid-C4's power jack.
+The red LED should light up, which indicates that the board is powered.
+
+To connect to a display, connect one end of your HDMI cable to the Odroid and the other end to your monitor.
+
+## Establish a network connection
+
+Plug the Ethernet cable into your Odroid-C4for a wired internet connection.
+For a wireless connection, you can connect a USB Wi-Fi dongle and configure Wi-Fi settings through your operating system.
+
+## Access and update your Odroid-C4
+
+To access your Odroid remotely, use an SSH client like [TeraTerm](https://teratermproject.github.io/index-en.html).
+You'll also need the IP address of your Odroid-C4 board to connect remotely.
+Alternatively, connect a keyboard and mouse to interact with the board directly using a connected monitor.
+
+Once you're connected, open a terminal and run the following commands
+
+```sh {class="command-line" data-prompt="$"}
+sudo apt update && sudo apt upgrade
+```
+
+## Install `viam-server`
+
+{{< readfile "/static/include/install/install-linux.md" >}}
+
+## Try an example
+
+{{< readfile "/static/include/install/try-example.md" >}}
+
+## Next steps
+
+{{< cards >}}
+{{% card link="/operate/modules/configure-modules/" %}}
+{{% card link="/operate/hello-world/tutorial-desk-safari/" %}}
+{{% card link="/tutorials/" %}}
+{{< /cards >}}
+
+## Troubleshooting
+
+Visit the [Odroid Forum](https://forum.odroid.com/index.php) for troubleshooting tips and tricks specific to the Odroid-C4.
diff --git a/docs/reference/device-setup/orange-pi-3-lts.md b/docs/reference/device-setup/orange-pi-3-lts.md
new file mode 100644
index 0000000000..628c10a754
--- /dev/null
+++ b/docs/reference/device-setup/orange-pi-3-lts.md
@@ -0,0 +1,100 @@
+---
+title: "Orange Pi 3 LTS Setup Guide"
+linkTitle: "Orange Pi 3 LTS Setup"
+weight: 16
+type: "docs"
+description: "Image an Orange Pi 3 LTS to prepare it for viam-server installation."
+images: ["/installation/thumbnails/orange-pi-3-LTS.png"]
+imageAlt: "Orange Pi 3 LTS"
+no_list: true
+aliases:
+  - /operate/reference/prepare/orange-pi-3-lts/
+  - /get-started/installation/prepare/orange-pi-3-lts/
+  - /get-started/prepare/orange-pi-3-lts/
+  - /installation/prepare/orange-pi-3-lts/
+date: "2022-01-01"
+# updated: ""  # When the content was last entirely checked
+# SME: Olivia Miller
+---
+
+The [Orange Pi 3 LTS](http://www.orangepi.org/html/hardWare/computerAndMicrocontrollers/details/Orange-Pi-Zero-2.html) is a highly compact, open-source single-board computer equipped with dual-band WiFi and Bluetooth 5.0.
+It can run Ubuntu, Android10, or Debian distributions.
+
+{{<imgproc src="installation/thumbnails/orange-pi-3-LTS.png" alt="The Orange Pi 3 LTS single-board computer." resize="350x" declaredimensions=true >}}
+
+Follow this guide to set up your Orange Pi 3 LTS to run `viam-server`.
+
+## Hardware requirements
+
+- Development machine: laptop or computer workstation
+- An [Orange Pi 3 LTS](http://www.orangepi.org/html/hardWare/computerAndMicrocontrollers/details/orange-pi-3-LTS.html)
+- A 5V 3A power supply with a USB-C connector
+- A micro-SD card (TF card): Minimum of 8GB, 16GB recommended
+- [SD card reader](https://www.amazon.com/Reader-Beikell-Connector-Memory-Adapter/dp/B0BGNZGDTC/) (recommended with USB-C connector)
+- A monitor: for display
+- [HDMI cable](https://www.amazon.com/Highwings-Braided-Cord-Supports-ARC-Compatible-Ethernet/dp/B07TDH11BJ/): to connect Orange Pi to monitor display
+- USB keyboard and mouse
+- [USB-C to USB-A cables](https://www.amazon.com/Anker-2-Pack-Premium-Samsung-Galaxy/dp/B07DD5YHMH/): to connect keyboard and mouse to USB hub or Orange Pi ports (recommended, hardware dependent)
+- [USB hub](https://www.amazon.com/BYEASY-Extended-Portable-Splitter-MacBook/dp/B07TVH9NHP/) with USB-A connector (recommended)
+
+## Power your Orange Pi 3 LTS
+
+Before you power the board, you need to install an operating system.
+
+1. First, download an [Orange Pi 3 LTS Ubuntu image](https://drive.google.com/drive/folders/1KzyzyByev-fpZat7yvgYz1omOqFFqt1k) to your development machine.
+   We recommend `ubuntu_jammy_desktop`.
+1. Unzip the image.
+1. Insert the micro-SD card into the SD card reader and connect the reader to your development machine.
+1. Follow the [Orange Pi guide to prepare your microSD card](https://sbc-community.org/docs/general_guides/prepare_sd_card/) to flash the OS to your micro-SD card using [balenaEtcher](https://etcher.balena.io/).
+
+   {{< alert title="Tip: How to think about building a machine" color="tip" >}}
+   While flashing your microSD card, we recommend reading [How to think about building a machine](/operate/hello-world/building/).
+   {{< /alert >}}
+
+1. Insert the micro-SD into the Orange Pi.
+
+To power your Orange Pi 3 LTS, connect your power adapter to the LTS's USB-C port.
+The LED should light up, which indicates that the board is powered.
+
+{{% alert title="Tip" color="tip" %}}
+If your board's LED does not light up when powered, try re-flashing your micro-SD card with the `ubuntu_jammy_desktop` image or using a different micro-SD card.
+The Orange Pi will only power on with a compatible operating system installed.
+{{% /alert %}}
+
+To connect to a display, connect the HDMI cable to the Orange Pi's HDMI port and the other end to your monitor.
+Then, connect your keyboard and mouse to the two USB-A ports on your Orange Pi.
+Alternatively, you can connect your peripherals to a USB hub and connect the USB hub to your Orange Pi's USB-A port.
+
+{{% alert title="Tip" color="tip" %}}
+For board schematics, consult the [Orange Pi 3 LTS documentation](http://www.orangepi.org/html/hardWare/computerAndMicrocontrollers/details/orange-pi-3-LTS.html).
+{{% /alert %}}
+
+Once the Orange Pi successfully boots, you should be greeted with the Orange Pi desktop display.
+If you are prompted for a login password, note that the default password for Orange Pi devices is "orangepi".
+
+## Establish a network connection
+
+The Orange Pi 3 LTS comes equipped with a wireless network antenna.
+To connect to WiFi through the desktop, click on the WiFi icon in the top right of the monitor display, select your preferred network or hotspot, and enter the password.
+
+{{% alert title="Tip" color="tip" %}}
+You can also connect to WiFi while connected to the Orange Pi on the terminal with several different methods, including the `nmcli` tool.
+For more information, consult the [official user manual](https://drive.google.com/file/d/1jka7avWnzNeTIQFkk78LoJdygWaGH2iu/view) (page 80).
+{{% /alert %}}
+
+## Next steps
+
+You have now installed an operating system on your Orange Pi.
+To use your Orange Pi, follow the [setup guide](/operate/install/setup/):
+
+{{< cards >}}
+{{% card link="/operate/install/setup/" %}}
+{{< /cards >}}
+
+If you want to use the GPIO pins on the board, add a [`orangepi` board as a component](https://github.com/viam-modules/orange-pi/) after installing `viam-server`.
+
+## Troubleshooting
+
+If you are prompted for a password in the terminal, the default password for Orange Pis is "orangepi".
+
+Visit the [Orange Pi Forum](http://www.orangepi.org/orangepibbsen/) for troubleshooting tips and tricks specific to the Orange Pi.
diff --git a/docs/reference/device-setup/orange-pi-zero2.md b/docs/reference/device-setup/orange-pi-zero2.md
new file mode 100644
index 0000000000..22cc7ee48a
--- /dev/null
+++ b/docs/reference/device-setup/orange-pi-zero2.md
@@ -0,0 +1,93 @@
+---
+title: "Orange Pi Zero2 Setup Guide"
+linkTitle: "Orange Pi Zero2 Setup"
+weight: 16
+type: "docs"
+description: "Image an Orange Pi Zero2 to prepare it for viam-server installation."
+images: ["/installation/thumbnails/orange-pi-zero2.png"]
+imageAlt: "Orange Pi Zero2"
+no_list: true
+aliases:
+  - /operate/reference/prepare/orange-pi-zero2/
+  - /get-started/installation/prepare/orange-pi-zero2/
+  - /get-started/prepare/orange-pi-zero2/
+  - /installation/prepare/orange-pi-zero2/
+date: "2022-01-01"
+# updated: ""  # When the content was last entirely checked
+# SME: Olivia Miller
+---
+
+The [Orange Pi Zero2](http://www.orangepi.org/html/hardWare/computerAndMicrocontrollers/details/Orange-Pi-Zero-2.html) is a highly compact, open-source single-board computer equipped with dual-band WiFi and Bluetooth 5.0.
+It can run Ubuntu, Android10, or Debian distributions.
+
+{{<imgproc src="installation/thumbnails/orange-pi-zero2.png" alt="The Orange Pi Zero2 single-board computer." resize="350x" declaredimensions=true >}}
+
+Follow this guide to set up your Orange Pi Zero2 to run `viam-server`.
+
+## Hardware requirements
+
+- Development machine: laptop or computer workstation
+- An [Orange Pi Zero2](http://www.orangepi.org/html/hardWare/computerAndMicrocontrollers/service-and-support/Orange-Pi-Zero-2.html)
+- A 5V 3A power supply with a USB-C connector
+- A microSD card: Minimum of 8GB, 16GB recommended
+- [SD card reader](https://www.amazon.com/Reader-Beikell-Connector-Memory-Adapter/dp/B0BGNZGDTC/) (recommended with USB-C connector)
+- A monitor: for display
+- [Micro-HDMI to HDMI cable](https://www.amazon.com/Amazon-Basics-Flexible-Durable-18Gpbs/dp/B07KSDB25X/): to connect Orange Pi to monitor display
+- USB keyboard and mouse
+- [USB-C to USB-A cables](https://www.amazon.com/Anker-2-Pack-Premium-Samsung-Galaxy/dp/B07DD5YHMH/): to connect keyboard and mouse to USB hub
+- [USB hub](https://www.amazon.com/BYEASY-Extended-Portable-Splitter-MacBook/dp/B07TVH9NHP/) with USB-A connector (recommended)
+
+## Power your Orange Pi Zero2
+
+Before you power the board, you need to install an operating system.
+
+1. First, download an [Orange Pi Ubuntu image](https://drive.google.com/drive/folders/1ohxfoxWJ0sv8yEHbrXL1Bu2RkBhuCMup) to your development machine.
+   We recommend `ubuntu_jammy_desktop`.
+1. Unzip the image.
+1. Insert the micro-SD card into the SD card reader and connect the reader to your development machine.
+1. Follow [this guide](https://sbc-community.org/docs/general_guides/prepare_sd_card/) to flash the OS to your micro-SD card using [balenaEtcher](https://etcher.balena.io/).
+   {{< alert title="Tip: How to think about building a machine" color="tip" >}}
+   While flashing your microSD card, we recommend reading [How to think about building a machine](/operate/hello-world/building/).
+   {{< /alert >}}
+1. Insert the micro-SD into the Orange Pi.
+
+To power your Orange Pi Zero2, connect your power adapter to the Zero2's USB-C port.
+The LED should light up, which indicates that the board is powered.
+
+{{% alert title="Tip" color="tip" %}}
+If your board's LED does not light up when powered, try re-flashing your micro-SD card with the `ubuntu_jammy_desktop` image or using a different micro-SD card.
+The Orange Pi will only power on with a compatible operating system installed.
+{{% /alert %}}
+
+To connect to a display, connect the micro-HDMI end of your HDMI cable to the Orange Pi and the other end to your monitor.
+Then, to connect the keyboard and mouse, plug the two devices into your USB hub and connect the USB hub to your Orange Pi's USB-A port.
+
+After it boots, you should be greeted with the Orange Pi desktop display.
+If it prompts you for a password, note that the default password for Orange Pi devices is "orangepi".
+
+## Establish a network connection
+
+The Orange Pi Zero2 comes equipped with a wireless network antenna.
+To connect to WiFi, click on the WiFi icon in the top right of the monitor display, select your preferred network or hotspot, and enter the password.
+
+{{% alert title="Tip" color="tip" %}}
+You can also connect to WiFi while connected to the Orange Pi on the terminal with several different methods, including the `nmcli` tool.
+For more information, consult the [official user manual](https://drive.google.com/file/d/1jka7avWnzNeTIQFkk78LoJdygWaGH2iu/view) (page 80).
+{{% /alert %}}
+
+## Next steps
+
+You have now installed an operating system on your Orange Pi.
+To use your Orange Pi, follow the [setup guide](/operate/install/setup/):
+
+{{< cards >}}
+{{% card link="/operate/install/setup/" %}}
+{{< /cards >}}
+
+If you want to use the GPIO pins on the board, add a [`orangepi` board as a component](https://github.com/viam-modules/orange-pi/) after installing `viam-server`.
+
+## Troubleshooting
+
+If you are prompted for a password in the terminal, the default password for Orange Pis is "orangepi".
+
+Visit the [Orange Pi Forum](http://www.orangepi.org/orangepibbsen/) for troubleshooting tips and tricks specific to the Orange Pi.
diff --git a/docs/reference/device-setup/pumpkin.md b/docs/reference/device-setup/pumpkin.md
new file mode 100644
index 0000000000..97db6b8cba
--- /dev/null
+++ b/docs/reference/device-setup/pumpkin.md
@@ -0,0 +1,265 @@
+---
+title: "Pumpkin Board Setup Guide"
+linkTitle: "Pumpkin Board Setup"
+weight: 25
+type: "docs"
+images: ["/installation/thumbnails/pumpkin.png"]
+imageAlt: "Pumpkin board"
+description: "Configure the pin mappings to use a pumpkin board."
+no_list: true
+aliases:
+  - /operate/reference/prepare/pumpkin/
+  - /installation/prepare/pumpkin/
+  - /get-started/installation/prepare/pumpkin/
+  - /get-started/prepare/pumpkin/
+date: "2022-01-01"
+# updated: ""  # When the content was last entirely checked
+---
+
+To use a [Mediatek Genio 500 Pumpkin single-board computer](https://ologicinc.com/portfolio/mediateki500/) with Viam:
+
+1. [Install `viam-server`](/operate/install/setup/) on your machine.
+1. [Create a board definitions file](#create-a-board-definitions-file), specifying the mapping between your board's GPIO pins and connected hardware.
+1. [Configure a `customlinux` board](#configure-a-customlinux-board) on your machine, specifying the path to the definitions file in the board configuration.
+
+## Create a board definitions file
+
+The board definitions file describes the location of each GPIO pin on the board so that `viam-server` can access the pins correctly.
+
+On your Pumpkin board, create a JSON file in the <file>/home/root</file> directory named <file>board.json</file>, and provide the mappings between your GPIO pins and connected hardware.
+Use the template and example below to populate the JSON file with a single key, `"pins"`, whose value is a list of objects that each represent a pin on the board.
+
+```json
+{
+  "pins": [
+    {
+      "name": "3",
+      "device_name": "gpiochip0",
+      "line_number": 81,
+      "pwm_id": -1
+    },
+    {
+      "name": "5",
+      "device_name": "gpiochip0",
+      "line_number": 84,
+      "pwm_id": -1
+    },
+    {
+      "name": "7",
+      "device_name": "gpiochip0",
+      "line_number": 150,
+      "pwm_id": -1
+    },
+    {
+      "name": "11",
+      "device_name": "gpiochip0",
+      "line_number": 173,
+      "pwm_id": -1
+    },
+    {
+      "name": "13",
+      "device_name": "gpiochip0",
+      "line_number": 152,
+      "pwm_id": -1
+    },
+    {
+      "name": "15",
+      "device_name": "gpiochip0",
+      "line_number": 94,
+      "pwm_id": -1
+    },
+    {
+      "name": "19",
+      "device_name": "gpiochip0",
+      "line_number": 163,
+      "pwm_id": -1
+    },
+    {
+      "name": "21",
+      "device_name": "gpiochip0",
+      "line_number": 161,
+      "pwm_id": -1
+    },
+    {
+      "name": "23",
+      "device_name": "gpiochip0",
+      "line_number": 164,
+      "pwm_id": -1
+    },
+    {
+      "name": "27",
+      "device_name": "gpiochip0",
+      "line_number": 82,
+      "pwm_id": -1
+    },
+    {
+      "name": "29",
+      "device_name": "gpiochip0",
+      "line_number": 98,
+      "pwm_id": -1
+    },
+    {
+      "name": "31",
+      "device_name": "gpiochip0",
+      "line_number": 12,
+      "pwm_id": -1
+    },
+    {
+      "name": "33",
+      "device_name": "gpiochip0",
+      "line_number": 101,
+      "pwm_id": -1
+    },
+    {
+      "name": "35",
+      "device_name": "gpiochip0",
+      "line_number": 171,
+      "pwm_id": -1
+    },
+    {
+      "name": "37",
+      "device_name": "gpiochip0",
+      "line_number": 169,
+      "pwm_id": -1
+    },
+    {
+      "name": "8",
+      "device_name": "gpiochip0",
+      "line_number": 115,
+      "pwm_id": -1
+    },
+    {
+      "name": "10",
+      "device_name": "gpiochip0",
+      "line_number": 121,
+      "pwm_id": -1
+    },
+    {
+      "name": "12",
+      "device_name": "gpiochip0",
+      "line_number": 170,
+      "pwm_id": -1
+    },
+    {
+      "name": "16",
+      "device_name": "gpiochip0",
+      "line_number": 165,
+      "pwm_id": -1
+    },
+    {
+      "name": "18",
+      "device_name": "gpiochip0",
+      "line_number": 1,
+      "pwm_id": -1
+    },
+    {
+      "name": "22",
+      "device_name": "gpiochip0",
+      "line_number": 2,
+      "pwm_id": -1
+    },
+    {
+      "name": "24",
+      "device_name": "gpiochip0",
+      "line_number": 162,
+      "pwm_id": -1
+    },
+    {
+      "name": "26",
+      "device_name": "gpiochip0",
+      "line_number": 0,
+      "pwm_id": -1
+    },
+    {
+      "name": "28",
+      "device_name": "gpiochip0",
+      "line_number": 83,
+      "pwm_id": -1
+    },
+    {
+      "name": "32",
+      "device_name": "gpiochip0",
+      "line_number": 97,
+      "pwm_id": -1
+    },
+    {
+      "name": "36",
+      "device_name": "gpiochip0",
+      "line_number": 151,
+      "pwm_id": -1
+    },
+    {
+      "name": "38",
+      "device_name": "gpiochip0",
+      "line_number": 174,
+      "pwm_id": -1
+    },
+    {
+      "name": "40",
+      "device_name": "gpiochip0",
+      "line_number": 172,
+      "pwm_id": -1
+    }
+  ]
+}
+```
+
+## Configure a `customlinux` board
+
+Configure your board as a [`customlinux`](https://app.viam.com/module/viam/customlinux) board to use your board definitions file:
+
+{{< tabs name="Configure a customlinux board" >}}
+{{% tab name="Config Builder" %}}
+
+Navigate to the **CONFIGURE** tab of your machine's page.
+Click the **+** icon next to your machine part in the left-hand menu and select **Component or service**.
+Select the `board` type, then select the `customlinux` model.
+Enter a name or use the suggested name for your `customlinux` board and click **Create**.
+
+[Example configuration for a pumpkin board using customlinux](https://github.com/viam-modules/customlinux/blob/main/README.md#example-configuration-for-a-pumpkin-board)
+
+Copy and paste the following json object into your board's attributes field.
+
+```json {class="line-numbers linkable-line-numbers"}
+{
+  "board_defs_file_path": "/home/root/board.json"
+}
+```
+
+{{% /tab %}}
+{{% tab name="JSON Template" %}}
+
+```json {class="line-numbers linkable-line-numbers"}
+{
+  "components": [
+    {
+      "name": "myCustomBoard",
+      "model": "customlinux",
+      "api": "rdk:component:board",
+      "attributes": {
+        "board_defs_file_path": "/home/root/board.json"
+      },
+      "depends_on": []
+    }
+  ]
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Try an example
+
+{{< readfile "/static/include/install/try-example.md" >}}
+
+## Next steps
+
+{{< cards >}}
+{{% card link="/operate/modules/configure-modules/" %}}
+{{% card link="/operate/hello-world/tutorial-desk-safari/" %}}
+{{% card link="/tutorials/" %}}
+{{< /cards >}}
+
+## Need assistance?
+
+{{< snippet "social.md" >}}
diff --git a/docs/reference/device-setup/rpi-setup.md b/docs/reference/device-setup/rpi-setup.md
new file mode 100644
index 0000000000..f7dc019910
--- /dev/null
+++ b/docs/reference/device-setup/rpi-setup.md
@@ -0,0 +1,194 @@
+---
+title: "Raspberry Pi Setup Guide"
+linkTitle: "Raspberry Pi Setup"
+weight: 15
+type: "docs"
+description: "Image a Raspberry Pi to prepare it for viam-server installation."
+images: ["/installation/thumbnails/raspberry-pi-4-b-2gb.png"]
+imageAlt: "Raspberry Pi"
+no_list: true
+aliases:
+  - /operate/reference/prepare/rpi-setup/
+  - /getting-started/rpi-setup/
+  - /installation/rpi-setup/
+  - /installation/prepare/rpi-setup/
+  - /get-started/installation/prepare/rpi-setup/
+  - /get-started/prepare/rpi-setup/
+  - /operate/reference/prepare/rpi-enable-protocols/
+  - /operate/reference/prepare/wifi-credentials/
+# SME: James
+date: "2022-01-01"
+# updated: ""  # When the content was last entirely checked
+---
+
+{{<youtube embed_url="https://www.youtube-nocookie.com/embed/drl2p2of-qA">}}
+
+We recommend using Viam on a 64-bit Linux distribution.
+Support for older Raspberry Pis running on 32-bit ARM v7 is in beta.
+
+If you already have a Linux distribution installed on your {{< glossary_tooltip term_id="pi" text="Pi" >}}, you can skip ahead to [install `viam-server`](/operate/install/setup/).
+
+{{% expand "Click to check whether the Linux installation on your Raspberry Pi is 64-bit or 32-bit" %}}
+
+To check whether the Linux installation on your Raspberry Pi is 64-bit or 32-bit, `ssh` into your Pi and then run `lscpu`.
+
+Example output:
+
+{{< imgproc alt="Screenshot of a terminal running the 'lscpu' command. The output lists of this command on a Raspberry Pi. A red box highlights the command and the top of the output which reads 'Architecture: aarch64.'" src="/installation/rpi-setup/lscpu-output.png" resize="800x" declaredimensions=true class="shadow" >}}
+
+If the value of "Architecture: _'xxxxxx'_" ends in "64", you can skip ahead to [install `viam-server`](/operate/install/setup/).
+
+{{% /expand%}}
+
+## Hardware requirements
+
+- A [Raspberry Pi single-board computer](https://www.raspberrypi.com/products/raspberry-pi-4-model-b/)
+- A microSD card
+- An internet-connected computer
+- A way to connect the microSD card to the computer (microSD slot or microSD reader)
+
+## Install Raspberry Pi OS
+
+The Raspberry Pi boots from a microSD card.
+You need to install Raspberry Pi OS (formerly called Raspbian) on the microSD card you will use with your Pi:
+
+1. Connect the microSD card to your computer.
+
+1. Download the [Raspberry Pi Imager](https://www.raspberrypi.com/software/) and launch it.
+
+   {{< imgproc alt="Raspberry Pi Imager launcher window showing a 'Choose OS' and 'Choose Storage' buttons." src="/installation/rpi-setup/imager-launch-screen.png" resize="800x" declaredimensions=true class="shadow" >}}
+
+1. Click **CHOOSE DEVICE**.
+   Select your model of Pi.
+
+   {{< imgproc alt="Raspberry Pi Imager window showing available pi models." src="/installation/rpi-setup/select-pi-models.png" resize="800x" declaredimensions=true class="shadow" >}}
+
+1. Click **CHOOSE OS**.
+   Select **Raspberry Pi OS (other)**.
+
+   {{< imgproc alt="Raspberry Pi Imager window showing Raspberry Pi OS (Other) is selected." src="/installation/rpi-setup/select-other-custom-os.png" resize="800x" declaredimensions=true class="shadow" >}}
+
+   Select **Raspberry Pi OS Full (64-bit)** or **Raspberry Pi OS Full (32-bit)** from the menu.
+
+   {{< imgproc alt="Raspberry Pi Imager window showing Raspberry Pi OS (Legacy, 64-bit) Full is selected." src="/installation/rpi-setup/select-other-rpi.png" resize="800x" declaredimensions=true class="shadow"  >}}
+
+   You should be brought back to the initial launch screen.
+
+1. Click **CHOOSE STORAGE**.
+   From the list of devices, select the microSD card you intend to use in your Raspberry Pi.
+
+   If no devices are listed, make sure your microSD card is connected to your computer correctly.
+
+   {{< imgproc alt="The storage screen is shown with a generic SD card available as an option." src="/installation/rpi-setup/imager-select-storage.png" resize="800x" declaredimensions=true class="shadow"  >}}
+
+1. Configure your Raspberry Pi for remote access.
+   Click **Next**.
+   When prompted to apply OS customization settings, select **EDIT SETTINGS**.
+
+   {{< imgproc alt="Raspberry Pi Imager window showing gear-shaped settings icon is selected." src="/installation/rpi-setup/advanced-options.png" resize="800x" declaredimensions=true class="shadow"  >}}
+
+   {{% alert title="Important" color="note" %}}
+
+   If you are using a non-Raspberry Pi OS, altering the OS customization settings will cause the initial boot to fail.
+
+   {{% /alert %}}
+
+   Check **Set hostname** and enter the name you would like to access the Pi by in that field:
+
+   {{< imgproc alt="Raspberry Pi Imager window showing the advanced options menu with set hostname checked and set to my-machine.local." src="/installation/rpi-setup/imager-set-hostname.png" resize="600x" declaredimensions=true class="shadow"  >}}
+
+   There are two ways you can secure your Raspberry Pi: with an SSH key or with password authentication.
+
+   - For a learning project or a fun hobby project, we recommend using password authentication because it is easiest to set up for first-time users.
+   - For production use, we recommend using SSH keys for more secure authentication; only someone with the private SSH key will be able to authenticate to your system.
+
+   {{< tabs >}}
+
+{{% tab name="Password" %}}
+
+1. Select the checkbox next to **Set username and password** and set a username (for example, your first name) and a unique password that you will use to log into the Pi:
+
+   {{< imgproc alt="Raspberry Pi Imager window showing the 'Set username and password' option is selected. The user has entered username 'Robota' and some hidden password." src="/installation/rpi-setup/imager-set-passwordauthentication.png" resize="550x" declaredimensions=true class="shadow"  >}}
+
+2. Select the **SERVICES** tab.
+3. Check **Enable SSH**.
+
+{{% alert title="IMPORTANT" color="note" %}}
+
+Be sure that you remember the `hostname`, `username`, and `password` you set, as you will need them when you SSH into your Pi.
+
+Do not use the default username and password on a Raspberry Pi, as this poses a [security risk](https://www.zdnet.com/article/linux-malware-enslaves-raspberry-pi-to-mine-cryptocurrency/).
+
+{{% /alert  %}}
+
+{{% /tab %}}
+{{% tab name="SSH" %}}
+
+To set up SSH authentication:
+
+1. Select the checkbox for **Set username and password** and set a username (for example, your first name) that you will use to log into the Pi.
+   If you skip this step, the default username will be `pi` (not recommended for security reasons).
+   You do not need to specify a password.
+
+   {{< imgproc alt="Raspberry Pi Imager with username specified as 'Robota' and the password field left blank." src="/installation/rpi-setup/imager-set-username.png" resize="500x" declaredimensions=true class="shadow"  >}}
+
+1. Select the **SERVICES** tab.
+1. Check **Enable SSH**.
+1. Select **Allow public-key authentication only**.
+
+   If you select **Allow public-key authentication only**, and the section **Set authorized\_ keys for ''** is pre-populated, that means you have a public SSH key that is ready to use.
+   In that case, you can leave the pre-populated key as-is.
+   If this section is empty, you can either generate a new SSH key using [these instructions](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent), or you can use password authentication instead.
+
+   {{< imgproc alt="Raspberry Pi Imager window showing 'Set Hostname' and 'Enable SSH' both selected." src="/installation/rpi-setup/imager-set-ssh.png" resize="500x" declaredimensions=true class="shadow"  >}}
+
+{{% alert title="IMPORTANT" color="note" %}}
+
+Be sure that you remember the `hostname` and `username` you set, as you will need this when you SSH into your Pi.
+
+{{% /alert  %}}
+
+{{% /tab %}}
+{{< /tabs >}}
+
+    Lastly, connect your Pi to Wi-Fi so that you can run `viam-server` wirelessly.
+    Check **Configure wireless LAN** and enter your wireless network credentials.
+    SSID (short for Service Set Identifier) is your Wi-Fi network name, and password is the network password.
+    Change the section `Wireless LAN country` to where your router is currently being operated:
+
+    {{< imgproc alt="Raspberry Pi Imager window showing the 'Configure wireless LAN' option selected with SSID and password information for a wireless network." src="/installation/rpi-setup/imager-set-wifi.png" resize="550x" declaredimensions=true class="shadow"  >}}
+
+    Click **SAVE**.
+
+1.  Double check your OS and Storage settings and then click `YES`:
+
+    {{< imgproc alt="Edit image customization options window" src="/installation/rpi-setup/apply-settings-yes.png" resize="800x" declaredimensions=true class="shadow"  >}}
+
+    You will be prompted to confirm erasing your microSD card: select `YES`.
+
+    {{< imgproc alt="Edit image customization options window" src="/installation/rpi-setup/imager-write-confirm.png" resize="800x" declaredimensions=true class="shadow"  >}}
+
+    You may also be prompted by your operating system to enter an administrator password:
+
+    {{< imgproc alt="macOS admin password confirmation screen." src="/installation/rpi-setup/imager-permission.png" resize="300x" declaredimensions=true class="shadow"  >}}
+
+    After granting permissions to the Imager, it will begin writing and then verifying the Linux installation to the MicroSD card.
+
+    Remove the microSD card from your computer when the installation is complete.
+
+    {{< alert title="Tip: How to think about building a machine" color="tip" >}}
+
+While the Imager is flashing your microSD card, we recommend reading [How to think about building a machine](/operate/hello-world/building/).
+
+    {{< /alert >}}
+
+2.  Place the SD card into your Raspberry Pi and boot the Pi by plugging it in to an outlet.
+    A red LED will turn on to indicate that the Pi is connected to power.
+
+## Next steps
+
+Continue setting up `viam-server` on your Raspberry Pi in [the Viam app](https://app.viam.com/):
+
+{{< cards >}}
+{{% card link="/operate/install/setup/" %}}
+{{< /cards >}}
diff --git a/docs/reference/device-setup/setup-micro/_index.md b/docs/reference/device-setup/setup-micro/_index.md
new file mode 100644
index 0000000000..013e97502c
--- /dev/null
+++ b/docs/reference/device-setup/setup-micro/_index.md
@@ -0,0 +1,403 @@
+---
+linkTitle: "Set up an ESP32"
+title: "Set up an ESP32"
+weight: 25
+layout: "docs"
+type: "docs"
+images: ["/installation/thumbnails/install.png"]
+imageAlt: "Install Viam"
+no_list: false
+description: "Install the lightweight version of the software that drives hardware and connects your device to the cloud."
+aliases:
+  - /operate/install/setup-micro/
+  - /installation/microcontrollers/
+  - /installation/prepare/microcontrollers/
+  - /build/micro-rdk/
+  - /get-started/installation/microcontrollers/
+  - /installation/viam-micro-server-setup/
+  - /operate/reference/viam-micro-server/viam-micro-server-troubleshooting/
+  - /operate/get-started/setup-micro/
+---
+
+Viam maintains a lightweight version of `viam-server` for microcontrollers.
+
+## Supported microcontrollers
+
+To work with Viam's Micro-RDK, ESP32 microcontrollers must have at least:
+
+- 2 cores
+- 384kB SRAM
+- 2MB PSRAM
+- 8MB flash
+
+The following microcontrollers have been tested with Viam:
+
+- [ESP32-WROVER Series](https://www.espressif.com/en/products/modules/esp32)
+
+{{% hiddencontent %}}
+The Micro-RDK and `viam-micro-server` do not support 32-bit Linux.
+{{% /hiddencontent %}}
+
+## About ESP32 microcontroller setup
+
+Microcontrollers do not run operating systems and are instead flashed with dedicated firmware.
+Because of this, the microcontroller setup process is different than for SBCs, laptops, and desktops.
+
+To use an ESP32 controller with custom hardware, you build a firmware version from the Micro-RDK and modules to support your hardware.
+
+To quickly try out Viam for microcontrollers, you can use the pre-built binary `viam-micro-server` which supports the following components:
+
+- [`gpio`](/hardware/common-components/add-a-servo/): A servo controlled by GPIO pins.
+- [`two_wheeled_base`](/hardware/common-components/add-a-base/): A robotic base with differential steering.
+- [`free_heap_sensor`](https://github.com/viamrobotics/micro-rdk/tree/main/examples/modular-drivers/src): Reports the amount of free heap memory on the microcontroller.
+- [`wifi_rssi_sensor`](https://github.com/viamrobotics/micro-rdk/tree/main/examples/modular-drivers/src): Reports the signal strength of the ESP32's WiFi connection.
+
+## Quickstart with pre-built firmware
+
+{{% hiddencontent %}}
+Viam provides installers to flash an ESP32 from macOS or Linux running on the x86_64 or ARM64 (AArch64) processor architectures.
+{{% /hiddencontent %}}
+
+To get started quickly with the pre-built `viam-micro-server` binary, follow these steps:
+
+1. Create a Viam account on [app.viam.com](https://app.viam.com).
+   You can configure and manage devices and data collection in the web UI.
+
+1. Add a new _{{< glossary_tooltip term_id="machine" text="machine" >}}_ using the button in the top right corner of the **LOCATIONS** tab in the app.
+   A machine represents your device.
+
+1. On your machine's page, click **View setup instructions** and follow the steps for your operating system.
+   The app provides commands to install `viam-micro-server` and connect it to the cloud with your machine's unique credentials.
+
+1. A secure connection is automatically established between your machine and Viam.
+   When you update your machine's configuration, `viam-micro-server` automatically gets the updates.
+
+   You are ready to [configure](#configure-and-test-your-machine) any of the components listed above on your machine.
+
+## Build and flash custom firmware
+
+If you are using your ESP32 with resources that are not supported by the pre-built binary, you can build your own firmware with the Micro-RDK and your choice of {{< glossary_tooltip term_id="module" text="modules" >}}.
+
+### Set up your development environment
+
+The [Micro-RDK](https://github.com/viamrobotics/micro-rdk) (from which `viam-micro-server` is built) is written in Rust.
+To be able to develop for the Micro-RDK on macOS and Linux systems, you must install the following software on your development machine:
+
+1. Install dependencies:
+
+   {{< tabs >}}
+   {{% tab name="Linux" %}}
+
+   ```sh { class="command-line" data-prompt="$"}
+   sudo apt-get install bison ccache cmake curl dfu-util flex git gperf libffi-dev libssl-dev libudev-dev libusb-1.0-0 ninja-build python3 python3-pip python3-venv wget
+   ```
+
+   {{% /tab %}}
+   {{% tab name="macOS" %}}
+
+   If you haven't already, [install Homebrew](https://brew.sh/).
+
+   Then, install dependencies:
+
+   ```sh { class="command-line" data-prompt="$"}
+   brew install cmake dfu-util ninja
+   ```
+
+   {{% /tab %}}
+   {{< /tabs >}}
+
+1. If you do not yet have a Rust environment installed, install it with `rustup`.
+
+   ```sh { class="command-line" data-prompt="$"}
+   curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+   ```
+
+   Once completed, start a new shell instance, or run `. "$HOME/.cargo/env"` in the current one.
+
+   See the [Rust Installation guide](https://www.rust-lang.org/tools/install) for more information and other installation methods.
+
+1. Install `espup` and ESP development utilities with `cargo`:
+
+   ```sh { class="command-line" data-prompt="$"}
+   cargo install cargo-espflash cargo-generate espflash espup ldproxy
+   ```
+
+1. Use `espup` to download and install the ESP Rust toolchain:
+
+   ```sh { class="command-line" data-prompt="$"}
+   espup install -s -f /dev/null -v 1.85.0
+   ```
+
+{{% hiddencontent %}}
+Prior versions of the above `espup` instructions created a file called `export-rs.sh` which needed to be sourced before proceeding.
+That requirement [no longer applies](https://github.com/esp-rs/esp-idf-hal/issues/319#issuecomment-1785168921) for Micro-RDK development.
+The above command redirects `espup`'s production of the setup script to `/dev/null` to avoid cluttering the home directory.
+If you would like to instead retain the setup script, replace `/dev/null` in the above command with the location where you would like the script to be written, or remove the `-f /dev/null` entirely and the file will be written to `$HOME/export-esp.sh` by default.
+{{% /hiddencontent %}}
+
+### Build your firmware
+
+Create firmware that integrates an existing module with the Micro-RDK:
+
+1. Create a new machine and obtain its credentials:
+
+   Add a new machine on [Viam](https://app.viam.com).
+   Click on the name of the machine to go to the machine's page, then select the **CONFIGURE** tab.
+
+   Then select the part status dropdown to the right of your machine's name on the top of the page and copy the **Machine cloud credentials**:
+
+   {{<imgproc src="/get-started/micro-credentials.png" resize="450x" declaredimensions=true alt="Machine part info menu accessed by Live status indicator, with machine cloud credentials button highlighted." class="shadow" >}}
+
+   The Micro-RDK needs these credentials, which contain your machine part secret key and cloud app address, to connect to Viam.
+
+1. Generate a new project skeleton from [this template](https://github.com/viamrobotics/micro-rdk/tree/main/templates/project):
+
+   ```sh { class="command-line" data-prompt="$"}
+   cargo generate --git https://github.com/viamrobotics/micro-rdk.git
+   ```
+
+   Follow the prompts:
+
+   - Which sub-template should be expanded?: `templates/project`.
+   - Project name: Your choice.
+   - MCU: `esp32`.
+   - Include camera module?: If you will use an `esp32-camera` or a `fake` camera as a component of your machine, select `true`.
+   - Machine cloud credentials: Paste in the machine cloud credentials you obtained in step 1.
+   - Enter Wi-Fi name: The name of the Wi-Fi network for the ESP32 to connect to on boot. Note that you must provide a 2.4 GHz network.
+   - Enter the Wi-Fi password: The password for the 2.GHz WiFi network.
+
+   Hit **Enter** to generate the project.
+   The CLI automatically initializes a git repository in the generated directory for version control.
+
+1. Navigate into the generated project:
+
+   ```sh { class="command-line" data-prompt="$"}
+   cd <path-to/your-project-directory>
+   ```
+
+1. Add any desired modules to the project by including them in the `dependencies` section of the `Cargo.toml` for the generated project:
+
+   {{< tabs >}}
+   {{% tab name="Local path dependency" %}}
+
+   While developing a module, you'll typically use a local path dependency to reference your module directory, for example:
+
+   ```toml {class="line-numbers linkable-line-numbers" data-line="3"}
+   [dependencies]
+   ...
+   my-module = { path = "../my-module" }
+   ```
+
+   {{% /tab %}}
+   {{% tab name="Git repository dependency" %}}
+
+   For modules hosted in a Git repository, specify the repository URL and optionally a specific commit (`rev`), branch (`branch`), or tag (`tag`), for example:
+
+   ```toml {class="line-numbers linkable-line-numbers" data-line="3"}
+   [dependencies]
+   ...
+   my-module = { git = "https://github.com/username/my-module.git", tag = "v1.0.0" }
+   ```
+
+   To use any of the [example modules](https://github.com/viamrobotics/micro-rdk/blob/main/examples/modular-drivers/README.md#example-modules) provided by Viam, use this line, specifying the Micro-RDK version that matches your development environment:
+
+   ```toml {class="line-numbers linkable-line-numbers" data-line="3"}
+   [dependencies]
+   ...
+   micro-rdk-modular-driver-example = { git = "https://github.com/viamrobotics/micro-rdk.git", rev = "v0.5.0", package = "micro-rdk-modular-driver-example", features = ["esp32"] }
+   ```
+
+   {{% /tab %}}
+   {{< /tabs >}}
+
+1. Compile the project:
+
+   ```sh { class="command-line" data-prompt="$"}
+   make build-esp32-bin
+   ```
+
+   The first build can take a few minutes, as ESP-IDF must be cloned and built, and all dependent Rust crates must be fetched and built.
+   Subsequent builds will be faster.
+
+### Flash your ESP32
+
+Upload the generated firmware to your ESP32:
+
+1. Use a data cable to connect your ESP32 board to a USB port on your development machine.
+
+1. Run the following command to flash the firmware to your ESP32:
+
+   ```sh { class="command-line" data-prompt="$"}
+   make flash-esp32-bin
+   ```
+
+   When prompted, select the serial port that your ESP32 is connected to through a data cable.
+
+   If the flash is successful, you will retain a serial connection to the board until you press `Ctrl-C`.
+   While the serial connection is live, you can also restart the currently flashed image with `Ctrl-R`.
+
+1. Navigate to your new machine's page.
+   If successful, the status indicator should turn green and show the **Live** status.
+
+### Configure and test your machine
+
+You can now configure the models you included in your firmware and test them:
+
+1. Navigate to your machine's page.
+
+1. From the **CONFIGURE** tab, click **JSON** mode.
+   Micro-RDK components and services must be configured in JSON.
+
+1. Add your components and services to the machine configuration.
+   If you are using one of the example modules, find configuration details in the [example modules README](https://github.com/viamrobotics/micro-rdk/blob/main/examples/modular-drivers/README.md#example-modules).
+   For example, if you want to use a free heap sensor, your configuration could look like this:
+
+   ```json
+   {
+     "components": [
+       {
+         "name": "my-free-heap-sensor",
+         "api": "rdk:component:sensor",
+         "model": "free-heap",
+         "attributes": {}
+       }
+     ]
+   }
+   ```
+
+1. Click **Builder** mode and find the configuration card of the component you want to test.
+
+1. Click to open the **Test** section of the card and use the interface to test the component.
+
+1. If you make changes to your module code, rerun the build and flash steps to update the firmware and test the new version on your ESP32.
+
+## Configure over-the-air updates
+
+You can update the firmware on your microcontroller without a physical connection.
+
+{{% hiddencontent %}}
+Over-the-air updates are available for `viam-server` and the Micro-RDK. For information about `viam-server` see [Deploy software packages to machines](/fleet/deploy-software/).
+The following information covers the Micro-RDK.
+{{% /hiddencontent %}}
+
+The first time you flash your microcontroller, you must build a full firmware image, and use a data cable to flash it to your microcontroller.
+After the initial flash, you can update the firmware remotely by using the over-the-air (OTA) service to pull [cloud-hosted, OTA-ready firmware](#build-and-host-ota-firmware) from a URL.
+
+The firmware hosting endpoint must use HTTP/2.
+
+To configure OTA updates:
+
+1. On your machine's page, go to the **CONFIGURE** tab and select **JSON** mode.
+
+1. Paste in the template below, then configure the URL from which to fetch new firmware, and a version name of your choice.
+   The value of the `version` field is not directly used by the OTA service, so you can use any string.
+
+   {{< tabs >}}
+   {{% tab name="JSON Template" %}}
+
+```json {class="line-numbers linkable-line-numbers" data-line="3-11"}
+{
+  "services": [
+    {
+      "name": "OTA",
+      "api": "rdk:service:generic",
+      "model": "rdk:builtin:ota_service",
+      "attributes": {
+        "url": "<URL where firmware is stored in cloud storage>",
+        "version": "<version name>"
+      }
+    }
+  ]
+}
+```
+
+{{% /tab %}}
+{{% tab name="JSON Example" %}}
+
+```json {class="line-numbers linkable-line-numbers"}
+{
+  "services": [
+    {
+      "name": "OTA",
+      "api": "rdk:service:generic",
+      "model": "rdk:builtin:ota_service",
+      "attributes": {
+        "url": "https://github.com/Jessamy/modulefirmware/releases/download/v0.1.2/modulefirmware-ota.bin",
+        "version": "myVersion1"
+      }
+    }
+  ]
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Your device checks for configuration updates periodically.
+If the device receives a configuration with a modified `version` field, the device downloads the new firmware to an inactive partition and restarts.
+When the device boots it loads the new firmware.
+
+To trigger a remote update of the firmware on your microcontroller after the initial configuration, edit the `version` field and save the config.
+
+{{% alert title="Note" color="note" %}}
+There is no way to roll back to previous firmware after a bad upgrade without reflashing the device with a physical connection, so test your firmware thoroughly before deploying it to a fleet.
+{{% /alert %}}
+
+### Update multiple microcontrollers at the same time
+
+To update the firmware version for a group of microcontrollers at the same time, you can [create a fragment](/fleet/deploy-software/) with the OTA service configuration and apply it to multiple machines.
+Then, whenever you update the `version` field in the fragment, the version will be updated for each machine that has that fragment in its config, triggering a firmware update the next time the devices fetch their configs.
+
+### Build and host OTA firmware
+
+To use the OTA service, you must host your firmware in the cloud so that it can be accessed at a URL.
+
+GitHub workflows simplify the process of building and hosting your firmware by eliminating the need to build locally and then upload the firmware image to a cloud storage bucket.
+
+{{< tabs >}}
+{{% tab name="Use GitHub workflows (recommended)" %}}
+
+To build firmware on GitHub, follow these steps:
+
+1. [Create a firmware project](#build-and-flash-custom-firmware).
+   _Do not include Wi-Fi credentials or machine cloud credentials in the project_, since you will be publishing the project to a public GitHub repository.
+   The OTA service does not modify the partition containing the machine cloud credentials and WiFi credentials, so OTA updates do not require the credentials.
+
+1. Create a public GitHub repository for your firmware project, and upload the contents of the firmware project directory to the repository.
+   The `templates/project` template you used to create your project contains a GitHub workflow file that is used to build your firmware.
+
+1. In the firmware GitHub repository, navigate to **Settings** &rarr; **Actions** &rarr; **General** and enable **Read and write permissions**.
+
+1. Go to the firmware GitHub repository's **Releases** page and create a new release.
+   Create a tag starting with `v` followed by a version number, for example `v1.0.0`.
+   Click **Publish release** to trigger a build of the firmware.
+
+To deploy the firmware:
+
+1. Wait for the build to complete.
+
+1. In your firmware GitHub repository, navigate to the **Releases** page and find the assets for the release you just created.
+   The assets include the full and OTA firmware images.
+   Copy the URL of the OTA firmware image.
+
+1. Navigate to your machine's **CONFIGURE** tab and [configure the OTA service](#configure-over-the-air-updates) with the URL of the firmware image you just copied.
+
+{{% /tab %}}
+{{% tab name="Build locally and host manually" %}}
+
+If you want to use OTA updates, but don't want to use GitHub Actions, follow these steps:
+
+1. Build the OTA firmware locally with the following command:
+
+   ```sh { class="command-line" data-prompt="$"}
+   make build-esp32-ota
+   ```
+
+   Note that this is different from the `make build-esp32-bin` command, which builds a full firmware image that you must use the first time you flash your microcontroller.
+
+1. Upload the OTA firmware image to a cloud storage bucket.
+
+1. Configure the URL of the cloud storage bucket in your microcontroller's OTA service configuration.
+
+{{% /tab %}}
+{{< /tabs >}}
diff --git a/docs/reference/device-setup/setup-micro/micro-module.md b/docs/reference/device-setup/setup-micro/micro-module.md
new file mode 100644
index 0000000000..b99a60b78c
--- /dev/null
+++ b/docs/reference/device-setup/setup-micro/micro-module.md
@@ -0,0 +1,122 @@
+---
+title: "Create modules for ESP32 microcontrollers"
+linkTitle: "Modules for ESP32"
+type: "docs"
+weight: 50
+images: ["/installation/thumbnails/esp32-espressif.png"]
+imageAlt: "E S P 32 - espressif"
+tags: ["modular resources", "components", "services", "registry"]
+description: "Create your own modules for use with an Espressif ESP32 microcontroller."
+languages: ["rust"]
+date: "2024-12-11"
+# updated: ""  # When the content was last entirely checked
+aliases:
+  - /installation/prepare/microcontrollers/development-setup/
+  - /get-started/installation/prepare/microcontrollers/development-setup/
+  - /get-started/installation/microcontrollers/development-setup/
+  - /get-started/installation/viam-micro-server-dev/
+  - /installation/viam-micro-server-dev/
+  - /operate/modules/other-hardware/micro-module/
+---
+
+If no existing modules support your hardware or software, you can create your own.
+You'll write it in Rust and then embed it in the firmware you flash onto your device.
+
+## Create a new module for ESP32
+
+To create a new module compatible with the Micro-RDK, follow these steps:
+
+1. Set up your development environment following the [development setup instructions](/operate/install/setup-micro/#set-up-your-development-environment).
+
+1. Generate a new module skeleton from [this template](https://github.com/viamrobotics/micro-rdk/tree/main/templates/module):
+
+   ```sh { class="command-line" data-prompt="$"}
+   cargo generate --git https://github.com/viamrobotics/micro-rdk.git
+   ```
+
+   Select `templates/module` when prompted, give the module a name of your choice, and answer any additional prompts.
+
+   The CLI automatically initializes a git repository in the generated module directory.
+
+1. Navigate into the generated module directory:
+
+   ```sh { class="command-line" data-prompt="$"}
+   cd <path-to/your-module-directory>
+   ```
+
+1. Develop the module by defining structs which implement the necessary traits.
+   The required traits are determined by the API you chose to implement.
+
+   For example, to implement the sensor API, you need to implement `Readings`, `SensorT<f64>` and `Status` traits.
+
+   {{< expand "Example implementation" >}}
+   The following example <file>src/lib.rs</file> file implements the sensor API to return random numbers:
+
+   ```rust { class="line-numbers linkable-line-numbers" }
+    use std::sync::{Arc, Mutex};
+    use std::collections::HashMap;
+    use micro_rdk::DoCommand;
+    use micro_rdk::common::config::ConfigType;
+    use micro_rdk::common::registry::{ComponentRegistry, RegistryError, Dependency};
+    use micro_rdk::common::sensor::{
+        Sensor, SensorType, Readings, SensorError, SensorT, SensorResult,
+        GenericReadingsResult, TypedReadingsResult
+    };
+    use micro_rdk::common::status::{Status, StatusError};
+
+    pub fn register_models(registry: &mut ComponentRegistry) -> Result<(), RegistryError> {
+        registry.register_sensor("my_sensor", &MySensor::from_config)
+    }
+
+    #[derive(DoCommand)]
+    pub struct MySensor {}
+
+    impl MySensor {
+        pub fn from_config(_cfg: ConfigType, _deps: Vec<Dependency>) -> Result<SensorType, SensorError> {
+            Ok(Arc::new(Mutex::new(MySensor {})))
+        }
+    }
+
+    // Mark this type as a sensor
+    impl Sensor for MySensor {}
+
+    // Implementation for getting readings
+    impl SensorT<f64> for MySensor {
+        fn get_readings(&self) -> Result<TypedReadingsResult<f64>, SensorError> {
+            use rand::Rng;
+            let mut rng = rand::thread_rng();
+            let mut readings = HashMap::new();
+            readings.insert("random_value".to_string(), rng.gen());
+            Ok(readings)
+        }
+    }
+
+    // Required to convert typed readings to generic readings
+    impl Readings for MySensor {
+        fn get_generic_readings(&mut self) -> Result<GenericReadingsResult, SensorError> {
+            Ok(self
+                .get_readings()?
+                .into_iter()
+                .map(|v| (v.0, SensorResult::<f64> { value: v.1 }.into()))
+                .collect())
+        }
+    }
+
+    // Basic status implementation
+    impl Status for MySensor {
+        fn get_status(&self) -> Result<Option<micro_rdk::google::protobuf::Struct>, StatusError> {
+            Ok(Some(micro_rdk::google::protobuf::Struct {
+                fields: HashMap::new(),
+            }))
+        }
+    }
+
+   ```
+
+   {{< /expand >}}
+
+   For more examples, see the [example module implementation walkthrough](https://github.com/viamrobotics/micro-rdk/blob/main/examples/modular-drivers/README.md).
+
+## Test your module
+
+To use your module with your ESP32, follow the [Build and flash custom firmware](/operate/install/setup-micro/#build-and-flash-custom-firmware) workflow in a separate directory.
diff --git a/docs/reference/device-setup/setup-micro/micro-troubleshooting.md b/docs/reference/device-setup/setup-micro/micro-troubleshooting.md
new file mode 100644
index 0000000000..746dbae4fe
--- /dev/null
+++ b/docs/reference/device-setup/setup-micro/micro-troubleshooting.md
@@ -0,0 +1,220 @@
+---
+title: "Micro-RDK Troubleshooting"
+linkTitle: "Micro-RDK Troubleshooting"
+weight: 100
+type: docs
+images: ["/installation/thumbnails/install.png"]
+imageAlt: "Install viam-micro-server"
+description: "Troubleshooting tips and best practices for installing and using viam-micro-server or other Micro-RDK-based firmware on a microcontroller."
+aliases:
+  - /operate/reference/viam-micro-server/viam-micro-server-setup/
+  - /operate/reference/viam-micro-server/micro-troubleshooting/
+  - /operate/get-started/setup-micro/micro-troubleshooting/
+# date: "2024-10-07"
+# updated: ""  # When the content was last entirely checked
+---
+
+{{% alert title="Tip" color="tip" %}}
+The [Viam Micro-RDK installer](https://github.com/viamrobotics/micro-rdk/tree/main/micro-rdk-installer) is a command line tool that can be helpful for troubleshooting.
+{{% /alert %}}
+
+## Installation issues
+
+### Error: `xtensa-esp32-elf-gcc: error: unrecognized command line option '--target=xtensa-esp32-espidf'` when building on macOS
+
+This is caused by an [upstream bug](https://github.com/esp-rs/esp-idf-template/issues/174).
+To work around this issue, ensure that `CRATE_CC_NO_DEFAULTS=1` is set in the environment when building.
+
+### Error: `error: externally-managed-environment` when building ESP-IDF on macOS
+
+This is encountered when attempting to build ESP-IDF projects while using Python obtained from Homebrew.
+Homebrew's Python infrastructure is not intended for end-user consumption but is instead made available to support Homebrew packages which require a python interpreter.
+The preferred workaround for this issue is to obtain a user-facing python installation not from Homebrew, but there are other, less safe, workarounds.
+Please see the macOS specific notes in the [development technical notes on GitHub](https://github.com/viamrobotics/micro-rdk/blob/main/DEVELOPMENT.md#fixing-esp-builds-on-macos) for more details.
+
+### Error: Failed to open serial port
+
+If you run into the error `Failed to open serial port` when flashing your ESP32 with Linux, make sure the user is added to the group `dialout` with `sudo gpasswd -a $USER dialout`.
+
+### Error: `espflash::timeout`
+
+If you get the following error while connecting to your ESP32:
+
+```sh { class="command-line" data-prompt="$"}
+`Error: espflash::timeout
+
+  × Error while connecting to device
+  ╰─▶ Timeout while running command
+```
+
+Run the following command, replacing `<YOUR_PROJECT_NAME>` with the name of your project firmware (for example, `esp32-camera`):
+
+```sh { class="command-line" data-prompt="$"}
+espflash flash --erase-parts nvs --partition-table partitions.csv  target/xtensa-esp32-espidf/release/<YOUR_PROJECT_NAME> --baud 115200 && sleep 2 && espflash monitor
+```
+
+Try the connection command again.
+The baud rate on your device may not have been fast enough to connect.
+If successful, Viam will show that your machine part's status is **Live**.
+
+You can also try disconnecting and reconnecting the ESP32 to the USB port, then retrying the flash command.
+
+### Error: `viam.json` not found
+
+If you get the error `viam.json not found` try the following to manually add your machine cloud credentials as a file in your project:
+
+1. Navigate to your machine's page and select the **CONFIGURE** tab.
+1. Select the part status dropdown to the right of your machine's name on the top of the page:
+
+   {{<imgproc src="/get-started/micro-credentials.png" resize="450x" declaredimensions=true alt="Machine part info menu accessed by Live status indicator, with machine cloud credentials button highlighted." class="shadow" >}}
+
+1. Click the copy icon underneath **Machine cloud credentials**.
+   The Micro-RDK needs this JSON object, which contains your machine part secret key and cloud app address, to connect to Viam.
+1. Navigate to the directory of the project you just created.
+1. Create a new <file>viam.json</file> file and paste the machine cloud credentials in.
+1. Save the file.
+
+### Error: failed to run custom build command for `esp32-explorer (/host)`
+
+This may occur for various reasons such as your machine cloud credentials, Wi-Fi SSID, or password not being populated.
+Check that your project directory contains machine cloud credentials in a <file>viam.json</file>, and that you provided Wi-Fi credentials.
+
+### Error: invalid value `460800` for `--before <BEFORE>`
+
+Change `"-b"` to `"-B` in the <file>Makefile</file>, as `"-B"` is the Baudrate config.
+Run the following commands to flash <file>esp32-server.bin</file> to your ESP32 microcontroller at a high baud rate, wait for 2 seconds, and observe the device's output:
+
+```sh {class="command-line" data-prompt="$"}
+espflash write-bin 0x0 target/esp32-server.bin -B 460800  && sleep 2 && espflash monitor
+```
+
+## Other issues
+
+### Unstable connection
+
+Because microcontrollers are more resource-constrained than single-board computers or other computers, when you run [control code](/reference/sdks/) to control your Micro-RDK machine, you may experience instability.
+If your connection is unstable, we recommend changing the default settings by making the following changes to your connection code.
+This code will disable the SDK background task that monitors the connection to your machine, reducing processing demands and improving the reliability of connection establishment.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+# TODO: Replace this with the connect function on the CONNECT tab
+async def connect():
+    opts = RobotClient.Options(
+        # viam-micro-server configures once at boot,
+        # so we don't need to check if the components have changed
+        refresh_interval=0,
+        # Checking the connection can safely be disabled
+        check_connection_interval=0,
+        # Same for Attempting to reconnect
+        attempt_reconnect_interval=0,
+        # viam-micro-server doesn't support sessions
+        # so it is safe to disable them
+        disable_sessions=True,
+        dial_options=DialOptions.with_api_key(
+            # TODO: Replace "<API-KEY-ID>" (including brackets)
+            # with your machine's API key ID
+            api_key_id='<API-KEY-ID>',
+            # TODO: Replace "<API-KEY>" (including brackets)
+            # with your machine's API key
+            api_key='<API-KEY>')
+    )
+    # TODO: Replace "<MACHINE-ADDRESS>" (including brackets) with address from
+    # the CONNECT tab.
+    return await RobotClient.at_address('<MACHINE-ADDRESS>', opts)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+// TODO: Replace the call to client.New with the following block
+robot, err := client.New(
+    context.Background(),
+    "<MACHINE-ADDRESS>", // TODO: Replace "<MACHINE-ADDRESS>" (including brackets) with address from the CONNECT tab.
+    logger,
+    client.WithDisableSessions(), // viam-micro-server doesn't support sessions so it is safe to disable them
+    client.WithCheckConnectedEvery(0), // Checking the connection can safely be disabled
+    client.WithReconnectEvery(0), // Same for Attempting to reconnect
+    client.WithRefreshEvery(0), // viam-micro-server configures once at boot, so we don't need to check if the components have changed
+    client.WithDialOptions(rpc.WithEntityCredentials(
+        // TODO: Replace "<API-KEY-ID>" (including brackets) with your machine's
+        // API key ID
+        "<API-KEY-ID>",
+        rpc.Credentials{
+            Type: rpc.CredentialsTypeAPIKey,
+            // TODO: Replace "<API-KEY>" (including brackets) with your
+            // machine's API key
+            Payload: "<API-KEY>",
+        })),
+    )
+if err != nil {
+    logger.Fatal(err)
+}
+
+```
+
+{{% /tab %}}
+{{% /tabs %}}
+
+### Error: IceTransportClosed
+
+If you are trying to connect to an ESP32 and the connection is unstable with the repeating error `E (412486) micro_rdk::common::webrtc::ice: closing ice agent with error IceTransportClosed`, you have opened too many connections to the ESP32, which has a maximum of 3 connections by default.
+Make sure you only have one tab with your machine's page open to limit the number of connections to your ESP32.
+
+### Linux port permissions
+
+If a "Permission Denied" or similar port error occurs, first check the connection of the ESP32 to the machine's USB port.
+If connected and the error persists, run `sudo usermod -a -G dialout $USER` to add the current user to the `dialout` group, restart your terminal, and try again.
+
+### macOS executable permissions
+
+When using a machine running a version of macOS, the user is blocked from running the executable by default.
+To fix this, **Control+Click** the binary in Finder and then, in the following two prompts select **Open**.
+Close whatever terminal window this opens to be able to run the installer.
+
+### Error: FlashConnect
+
+This may occur because the serial port chosen if/when prompted is incorrect.
+However, if the correct port has been selected, try the following:
+
+1. Run the installer as explained above.
+2. When prompted to select a serial port:
+   1. Hold down the "EN" or enable button on your ESP32.
+   2. With the above button held down, select the correct serial port.
+   3. Press and hold down the "EN" and "Boot" buttons at the same time. Then release both.
+
+If this doesn't work, try wiggling or reattaching the connections on both ends of the data cable connecting your ESP32 to your computer.
+You can also try using a different cable entirely; make sure it is a data-compatible cable.
+
+### Ubuntu not recognizing the microcontroller
+
+If you're trying to connect a microcontroller using serial port to an Ubuntu system and the computer doesn't seem to be recognizing the microcontroller, check if the `brltty` service or its secondary service `brltty-udev` are active (`brltty` is a service installed by default that provides access to a braille display):
+
+```sh {class="command-line" data-prompt="$" data-output="2"}
+sudo systemctl status | grep brltty
+brltty-udev.service loaded active running Braille Device Support
+```
+
+It is a known issue that this service takes ownership of cp210x devices that are used in serial communication with microcontrollers.
+
+To disable the services, run the following:
+
+```sh {class="command-line" data-prompt="$"}
+sudo systemctl stop brltty-udev.service
+sudo systemctl mask brltty-udev.service
+sudo systemctl stop brltty.service
+sudo systemctl disable brltty.service
+```
+
+You may also need to reboot your system, and/or unplug the cable from the computer and re-plug it in.
+
+See this [blog post](https://koen.vervloesem.eu/blog/how-to-stop-brltty-from-claiming-your-usb-uart-interface-on-linux/) and [Ubuntu bug report](https://bugs.launchpad.net/ubuntu/+source/brltty/+bug/1958224) for more.
+
+### Additional assistance
+
+You can find general Viam troubleshooting information in the [Troubleshooting section](/monitor/troubleshoot/).
+
+{{< snippet "social.md" >}}
diff --git a/docs/reference/device-setup/sk-tda4vm.md b/docs/reference/device-setup/sk-tda4vm.md
new file mode 100644
index 0000000000..989cc464b0
--- /dev/null
+++ b/docs/reference/device-setup/sk-tda4vm.md
@@ -0,0 +1,122 @@
+---
+title: "SK-TDA4VM Setup Guide"
+linkTitle: "SK-TDA4VM Setup"
+weight: 25
+type: "docs"
+images: ["/installation/thumbnails/tda4vm.png"]
+imageAlt: "S K - T D A 4 V M"
+description: "Image a Texas Instruments TDA4VM starter kit board to prepare it for viam-server installation."
+no_list: true
+aliases:
+  - /operate/reference/prepare/sk-tda4vm/
+  - /installation/prepare/sk-tda4vm/
+  - /get-started/installation/prepare/sk-tda4vm/
+  - /get-started/prepare/sk-tda4vm/
+date: "2022-01-01"
+# updated: ""  # When the content was last entirely checked
+---
+
+## Hardware requirements
+
+- A [Texas Instruments TDA4VM single-board computer](https://www.ti.com/tool/SK-TDA4VM)
+- A USB-C power cable to power the TDA4VM board
+- A microSD card
+- A desktop or laptop computer for flashing the microSD card
+- A way to connect the microSD card to the computer (a microSD slot or microSD reader)
+- An Ethernet cable
+- An HDMI cable
+
+## Required downloads
+
+Download the following files to your computer:
+
+- Download the <a href="https://www.ti.com/tool/download/PROCESSOR-SDK-LINUX-SK-TDA4VM" target="_blank">PROCESSOR-SDK-LINUX-SK-TDA4VM — Linux SDK for edge AI applications on TDA4VM Jacinto™ processors</a> image.
+
+- Next, download and install the <a href="https://etcher.balena.io/#download-etcher" target="_blank">Balena Etcher</a> for your desktop/laptop OS.
+  You will use the Balena Etcher to flash the microSD card.
+
+## Flash the image
+
+{{% alert title="Important" color="note" %}}
+You must extract the image from the zip file before flashing the microSD card.
+{{% /alert %}}
+
+{{< imgproc alt="The Balena Etcher interface." src="/installation/sk-tda4vm/etcher.png" resize="600x" declaredimensions=true >}}
+
+<br>
+<br>
+
+1. Insert the microSD card into a reader connected to your computer.
+
+2. Launch Balena Etcher.
+
+3. Click **Flash from File** to open the file selector.
+
+4. Navigate to and select the image you downloaded.
+
+5. Click **Select Target** to choose the storage device corresponding to your microSD card from the selector window.
+
+6. Click on the desired device, then click **Select** to continue.
+
+7. Click **Flash!**.
+   If you receive a warning concerning the size of the microSD card, ensure that you have inserted the proper microSD and also selected the proper device, then click, **Yes, I'm sure** to flash the board.
+   The flashing and verification process may take 10-20 minutes, depending on your system.
+
+   {{< alert title="Tip: How to think about building a machine" color="tip" >}}
+   While the Etcher is flashing your microSD card, we recommend reading [How to think about building a machine](/operate/hello-world/building/).
+   {{< /alert >}}
+
+8. On completion of the flashing and validation process, remove the microSD card from your computer and insert it into the TDA4VM.
+
+{{< imgproc alt="Successful image flash completion screen." src="/installation/sk-tda4vm/completed.png" resize="600x" declaredimensions=true class="shadow"  >}}
+
+## Install Viam dependencies on the TDA4VM
+
+1. Connect the board to Ethernet.
+
+2. Connect the board to a monitor with the HDMI cable.
+
+3. Connect the board to power using the USB-C power cable.
+
+4. Use the credentials and IP address displayed in the upper right-hand corner of the monitor to SSH into the board.
+
+From the SSH session on the TDA4VM board:
+
+1. Clone the TDA4VM repo:
+
+   ```sh {class="command-line" data-prompt="$"}
+   git clone https://github.com/viam-labs/tda4vm-setup.git
+   ```
+
+2. Navigate to the setup directory:
+
+   ```sh {class="command-line" data-prompt="$"}
+   cd tda4vm-setup/
+   ```
+
+3. Make the server setup script executable:
+
+   ```sh {class="command-line" data-prompt="$"}
+   chmod +x tda4vm-viam-setup.sh
+   ```
+
+4. Launch the setup script to install `viam-server` dependencies:
+
+   ```sh {class="command-line" data-prompt="$"}
+   ./tda4vm-viam-setup.sh
+   ```
+
+   Once this process completes, the board will reboot.
+
+## Next steps
+
+You have now installed an operating system on your board.
+To use your board, follow the [setup guide](/operate/install/setup/):
+
+{{< cards >}}
+{{% card link="/operate/install/setup/" %}}
+{{< /cards >}}
+
+## Need assistance?
+
+{{< snippet "social.md" >}}
diff --git a/docs/dev/reference/glossary/api-namespace-triplet.md b/docs/reference/glossary/api-namespace-triplet.md
similarity index 63%
rename from docs/dev/reference/glossary/api-namespace-triplet.md
rename to docs/reference/glossary/api-namespace-triplet.md
index 3f74e156b4..ff88461686 100644
--- a/docs/dev/reference/glossary/api-namespace-triplet.md
+++ b/docs/reference/glossary/api-namespace-triplet.md
@@ -3,6 +3,8 @@ title: API Namespace Triplet
 id: api-namespace-triplet
 full_link:
 short_description: namespace:type:subtype, for example `rdk:component:sensor`
+aliases:
+  - /dev/reference/glossary/api-namespace-triplet/
 ---
 
 Every Viam {{< glossary_tooltip term_id="resource" text="resource" >}} implements an [application programming interface (API)](https://en.wikipedia.org/wiki/API) that describes how you can interact with that resource.
@@ -13,11 +15,11 @@ The `namespace` for built-in Viam resources is `rdk`, while the `type` is `compo
 `subtype` refers to a specific component or service, like a `camera` or `vision`.
 
 One API can have various {{< glossary_tooltip term_id="model" text="models" >}}, custom or built-in, but they all must conform to the same API definition.
-This requirement ensures that when a resource of that model is deployed, you can [interface with it](/dev/reference/sdks/) using the same [client API methods](/dev/reference/apis/) you would when programming resources of the same API with a different model.
+This requirement ensures that when a resource of that model is deployed, you can [interface with it](/reference/sdks/) using the same [client API methods](/reference/apis/) you would when programming resources of the same API with a different model.
 
 Each resource implements one and only one API.
 
 For example:
 
-- The API of the built-in component [camera](/operate/reference/components/camera/) is `rdk:component:camera`, which exposes methods such as `GetImages()`.
-- The API of the built-in service [vision](/operate/reference/services/vision/) is `rdk:service:vision`, which exposes methods such as `GetDetectionsFromCamera()`.
+- The API of the built-in component [camera](/hardware/common-components/add-a-camera/) is `rdk:component:camera`, which exposes methods such as `GetImages()`.
+- The API of the built-in service [vision](/vision/configure/) is `rdk:service:vision`, which exposes methods such as `GetDetectionsFromCamera()`.
diff --git a/docs/dev/reference/glossary/api.md b/docs/reference/glossary/api.md
similarity index 94%
rename from docs/dev/reference/glossary/api.md
rename to docs/reference/glossary/api.md
index bc66014abf..9c4aa0313a 100644
--- a/docs/dev/reference/glossary/api.md
+++ b/docs/reference/glossary/api.md
@@ -5,6 +5,8 @@ full_link:
 short_description: Application programming interface, a set of defined rules that enable different applications to communicate with each other.
 aka:
 type: "page"
+aliases:
+  - /dev/reference/glossary/api/
 ---
 
 API stands for application programming interface.
diff --git a/docs/dev/reference/glossary/attribute.md b/docs/reference/glossary/attribute.md
similarity index 77%
rename from docs/dev/reference/glossary/attribute.md
rename to docs/reference/glossary/attribute.md
index 45b793cf46..271f07f21e 100644
--- a/docs/dev/reference/glossary/attribute.md
+++ b/docs/reference/glossary/attribute.md
@@ -5,6 +5,8 @@ full_link:
 short_description: A configuration parameter of a resource.
 aka:
 type: "page"
+aliases:
+  - /dev/reference/glossary/attribute/
 ---
 
 A configuration parameter of a resource.
diff --git a/docs/dev/reference/glossary/base.md b/docs/reference/glossary/base.md
similarity index 69%
rename from docs/dev/reference/glossary/base.md
rename to docs/reference/glossary/base.md
index fd79b5b1fc..03e246ebf6 100644
--- a/docs/dev/reference/glossary/base.md
+++ b/docs/reference/glossary/base.md
@@ -3,9 +3,11 @@ title: Base
 id: base
 full_link: /components/base/
 short_description: A physical, mobile platform that the other parts of a mobile robot attach to.
+aliases:
+  - /dev/reference/glossary/base/
 ---
 
 A physical, mobile platform that the other parts of a mobile robot attach to.
 For example, a wheeled rover, boat, or flying drone.
 
-For more information see [Base Component](/operate/reference/components/base/).
+For more information see [Base Component](/hardware/common-components/add-a-base/).
diff --git a/docs/dev/reference/glossary/blob-storage.md b/docs/reference/glossary/blob-storage.md
similarity index 75%
rename from docs/dev/reference/glossary/blob-storage.md
rename to docs/reference/glossary/blob-storage.md
index da7aed906b..9613fdb8f6 100644
--- a/docs/dev/reference/glossary/blob-storage.md
+++ b/docs/reference/glossary/blob-storage.md
@@ -5,6 +5,8 @@ full_link:
 short_description: A cheap but slow storage medium.
 aka:
 type: "page"
+aliases:
+  - /dev/reference/glossary/blob-storage/
 ---
 
 A cheap but slow storage medium.
diff --git a/docs/dev/reference/glossary/board.md b/docs/reference/glossary/board.md
similarity index 69%
rename from docs/dev/reference/glossary/board.md
rename to docs/reference/glossary/board.md
index 059034631c..f3fd8b7cca 100644
--- a/docs/dev/reference/glossary/board.md
+++ b/docs/reference/glossary/board.md
@@ -3,10 +3,12 @@ title: Board
 id: board
 full_link: /components/board/
 short_description: A board is the signal wire hub of a machine that provides access to GPIO pins.
+aliases:
+  - /dev/reference/glossary/board/
 ---
 
 A board is the signal wire hub of a machine that provides access to GPIO pins.
 
 Examples of boards include Jetson, Raspberry Pi, or Numato.
 
-For more information see [Board Component](/operate/reference/components/board/).
+For more information see [Board Component](/hardware/common-components/add-a-board/).
diff --git a/docs/dev/reference/glossary/captive-web-portal.md b/docs/reference/glossary/captive-web-portal.md
similarity index 87%
rename from docs/dev/reference/glossary/captive-web-portal.md
rename to docs/reference/glossary/captive-web-portal.md
index affcebd391..d6205bd1d2 100644
--- a/docs/dev/reference/glossary/captive-web-portal.md
+++ b/docs/reference/glossary/captive-web-portal.md
@@ -2,6 +2,8 @@
 title: Captive web portal
 id: captive-web-portal
 short_description: A web page which is automatically displayed to users when connecting to a network.
+aliases:
+  - /dev/reference/glossary/captive-web-portal/
 ---
 
 A captive portal is a web page that is automatically displayed to users often as a landing or log-in page when connecting to a network.
diff --git a/docs/dev/reference/glossary/client-application.md b/docs/reference/glossary/client-application.md
similarity index 89%
rename from docs/dev/reference/glossary/client-application.md
rename to docs/reference/glossary/client-application.md
index f3acdfae5d..5985cec414 100644
--- a/docs/dev/reference/glossary/client-application.md
+++ b/docs/reference/glossary/client-application.md
@@ -3,6 +3,8 @@ title: Client Application
 id: client-application
 full_link:
 short_description: Client applications run business logic to operate your machine.
+aliases:
+  - /dev/reference/glossary/client-application/
 ---
 
 Client applications run business logic to operate your machine.
diff --git a/docs/dev/reference/glossary/component.md b/docs/reference/glossary/component.md
similarity index 92%
rename from docs/dev/reference/glossary/component.md
rename to docs/reference/glossary/component.md
index 63e029e5a3..16a1e9ce0e 100644
--- a/docs/dev/reference/glossary/component.md
+++ b/docs/reference/glossary/component.md
@@ -2,6 +2,8 @@
 title: Component
 id: component
 short_description: A resource that often represents a physical piece of hardware which a computer controls; for example, a servo, a camera, or an arm.
+aliases:
+  - /dev/reference/glossary/component/
 ---
 
 A resource that often represents a physical piece of hardware in a machine which a computer controls; for example, a servo, a camera, or an arm.
diff --git a/docs/dev/reference/glossary/flashed.md b/docs/reference/glossary/flashed.md
similarity index 89%
rename from docs/dev/reference/glossary/flashed.md
rename to docs/reference/glossary/flashed.md
index 39839f9b44..fcb88b88ec 100644
--- a/docs/dev/reference/glossary/flashed.md
+++ b/docs/reference/glossary/flashed.md
@@ -7,6 +7,8 @@ aka:
   - flashed
   - flashing
 type: "page"
+aliases:
+  - /dev/reference/glossary/flashed/
 ---
 
 Flashed or flashing refers to the process of writing an operating system, firmware, or other software directly to a device's non-volatile storage medium, such as an SD card, eMMC storage, or flash memory.
@@ -23,6 +25,6 @@ The flashing process typically involves:
 3. Verifying the write was successful
 4. Booting or resetting the device to load the new software
 
-For example, when setting up a Raspberry Pi for use with Viam, you would "flash" Raspberry Pi OS to an SD card using the [Raspberry Pi Imager](/operate/reference/prepare/rpi-setup/#install-raspberry-pi-os) or similar software.
+For example, when setting up a Raspberry Pi for use with Viam, you would "flash" Raspberry Pi OS to an SD card using the [Raspberry Pi Imager](/reference/device-setup/rpi-setup/#install-raspberry-pi-os) or similar software.
 
 Flashing is different from regular software installation because it involves writing directly to storage at a low level, often replacing everything on the target storage medium.
diff --git a/docs/dev/reference/glossary/fragment.md b/docs/reference/glossary/fragment.md
similarity index 69%
rename from docs/dev/reference/glossary/fragment.md
rename to docs/reference/glossary/fragment.md
index d2fd570668..b63b0f9c84 100644
--- a/docs/dev/reference/glossary/fragment.md
+++ b/docs/reference/glossary/fragment.md
@@ -3,8 +3,10 @@ title: Fragment
 id: fragment
 full_link: /manage/fleet/reuse-configuration/
 short_description: A reusable configuration block that you can share across multiple machines.
+aliases:
+  - /dev/reference/glossary/fragment/
 ---
 
 A reusable configuration block that you can share across multiple machines.
 
-For more information, see [Fragments](/manage/fleet/reuse-configuration/).
+For more information, see [Fragments](/fleet/reuse-configuration/).
diff --git a/docs/dev/reference/glossary/frame-system.md b/docs/reference/glossary/frame-system.md
similarity index 86%
rename from docs/dev/reference/glossary/frame-system.md
rename to docs/reference/glossary/frame-system.md
index 383a000019..008c81b965 100644
--- a/docs/dev/reference/glossary/frame-system.md
+++ b/docs/reference/glossary/frame-system.md
@@ -3,6 +3,8 @@ title: Frame System
 id: frame-system
 full_link: /operate/reference/services/frame-system/
 short_description: The frame system holds reference frame information for the relative position of components in space.
+aliases:
+  - /dev/reference/glossary/frame-system/
 ---
 
 The frame system holds reference frame information for the relative position of components in space.
diff --git a/docs/dev/reference/glossary/frame.md b/docs/reference/glossary/frame.md
similarity index 91%
rename from docs/dev/reference/glossary/frame.md
rename to docs/reference/glossary/frame.md
index 09b70044fe..724629e0fb 100644
--- a/docs/dev/reference/glossary/frame.md
+++ b/docs/reference/glossary/frame.md
@@ -3,6 +3,8 @@ title: Frame
 id: frame
 full_link:
 short_description: A frame represents a coordinate system that describes the position and orientation of an object.
+aliases:
+  - /dev/reference/glossary/frame/
 ---
 
 A frame represents a coordinate system that describes the position and orientation of an object.
diff --git a/docs/dev/reference/glossary/gantry.md b/docs/reference/glossary/gantry.md
similarity index 88%
rename from docs/dev/reference/glossary/gantry.md
rename to docs/reference/glossary/gantry.md
index 3964d87a09..0094b645d9 100644
--- a/docs/dev/reference/glossary/gantry.md
+++ b/docs/reference/glossary/gantry.md
@@ -3,6 +3,8 @@ title: Gantry
 id: attribute
 full_link: /components/gantry/
 short_description: A mechanical system that only uses linear motion to carry out a task.
+aliases:
+  - /dev/reference/glossary/gantry/
 ---
 
 A mechanical system that only uses linear motion to carry out a task; for example, the scaffolding of a 3D printer, which moves the print head around on motorized linear rails.
diff --git a/docs/dev/reference/glossary/grpc.md b/docs/reference/glossary/grpc.md
similarity index 93%
rename from docs/dev/reference/glossary/grpc.md
rename to docs/reference/glossary/grpc.md
index c2e317ae87..0969b8e18e 100644
--- a/docs/dev/reference/glossary/grpc.md
+++ b/docs/reference/glossary/grpc.md
@@ -3,6 +3,8 @@ title: gRPC
 id: grpc
 full_link:
 short_description: An open source, cross-platform, high performance Remote Procedure Call (RPC) framework initially developed at Google in 2015.
+aliases:
+  - /dev/reference/glossary/grpc/
 ---
 
 An open source, cross-platform, high performance Remote Procedure Call (RPC) framework initially developed at Google in 2015.
diff --git a/docs/dev/reference/glossary/index.md b/docs/reference/glossary/index.md
similarity index 89%
rename from docs/dev/reference/glossary/index.md
rename to docs/reference/glossary/index.md
index 8ac8feb3c4..5d7219d8de 100644
--- a/docs/dev/reference/glossary/index.md
+++ b/docs/reference/glossary/index.md
@@ -10,5 +10,6 @@ card:
   weight: 10
   title: Glossary
 aliases:
+  - /dev/reference/glossary/
   - "/appendix/glossary/"
 ---
diff --git a/docs/dev/reference/glossary/job.md b/docs/reference/glossary/job.md
similarity index 83%
rename from docs/dev/reference/glossary/job.md
rename to docs/reference/glossary/job.md
index 5c59fd0790..a7e6b55dba 100644
--- a/docs/dev/reference/glossary/job.md
+++ b/docs/reference/glossary/job.md
@@ -3,6 +3,8 @@ title: Jobs
 id: job
 full_link: /manage/software/scheduled-jobs/
 short_description: Automated tasks that run on machines at specified intervals to perform routine operations.
+aliases:
+  - /dev/reference/glossary/job/
 ---
 
 Jobs are automated tasks that run on machines at specified intervals to perform routine operations such as a task based on sensor readings, maintenance operations, and system checks.
@@ -10,4 +12,4 @@ Jobs are automated tasks that run on machines at specified intervals to perform
 The job scheduler is built into `viam-server` and executes configured jobs according to their specified schedules.
 Each job targets a specific resource on your machine and calls a designated method at the scheduled intervals.
 
-For more information, see [Schedule automated jobs](/manage/software/scheduled-jobs/).
+For more information, see [Schedule automated jobs](/fleet/schedule-jobs/).
diff --git a/docs/dev/reference/glossary/location.md b/docs/reference/glossary/location.md
similarity index 86%
rename from docs/dev/reference/glossary/location.md
rename to docs/reference/glossary/location.md
index 36d4b81d86..3ca60ec61a 100644
--- a/docs/dev/reference/glossary/location.md
+++ b/docs/reference/glossary/location.md
@@ -3,8 +3,10 @@ title: Location
 id: location
 full_link: /manage/reference/organize/
 short_description: A location is a virtual grouping of machines that allows you to organize machines and manage access to your fleet.
+aliases:
+  - /dev/reference/glossary/location/
 ---
 
 A location is a virtual grouping of machines that allows you to organize machines and manage access to your fleet.
 
-For more information, see [Manage Locations and Sub-Locations](/manage/reference/organize/).
+For more information, see [Manage Locations and Sub-Locations](/reference/).
diff --git a/docs/dev/reference/glossary/machine-config.md b/docs/reference/glossary/machine-config.md
similarity index 87%
rename from docs/dev/reference/glossary/machine-config.md
rename to docs/reference/glossary/machine-config.md
index 9bb5a930e0..cc49a12c10 100644
--- a/docs/dev/reference/glossary/machine-config.md
+++ b/docs/reference/glossary/machine-config.md
@@ -3,6 +3,8 @@ title: Machine Config
 id: machine-config
 full_link: /configure/
 short_description: The complete configuration of a single machine part.
+aliases:
+  - /dev/reference/glossary/machine-config/
 ---
 
 The complete configuration of a single machine {{< glossary_tooltip term_id="part" text="part" >}}, including components, services, and scheduled jobs.
diff --git a/docs/dev/reference/glossary/machine-fqdn.md b/docs/reference/glossary/machine-fqdn.md
similarity index 89%
rename from docs/dev/reference/glossary/machine-fqdn.md
rename to docs/reference/glossary/machine-fqdn.md
index ba609fe334..4a7287ff74 100644
--- a/docs/dev/reference/glossary/machine-fqdn.md
+++ b/docs/reference/glossary/machine-fqdn.md
@@ -5,6 +5,8 @@ full_link:
 short_description: The fully qualified domain name (FQDN) of a machine in the Viam platform.
 aka:
 type: "page"
+aliases:
+  - /dev/reference/glossary/machine-fqdn/
 ---
 
 The fully qualified domain name (FQDN) of a {{< glossary_tooltip term_id="machine" text="machine" >}} in the Viam platform, typically in the format `<machine-name>.<location-id>.viam.cloud`.
diff --git a/docs/dev/reference/glossary/machine-id.md b/docs/reference/glossary/machine-id.md
similarity index 87%
rename from docs/dev/reference/glossary/machine-id.md
rename to docs/reference/glossary/machine-id.md
index b89b0694a8..bf31047b69 100644
--- a/docs/dev/reference/glossary/machine-id.md
+++ b/docs/reference/glossary/machine-id.md
@@ -5,10 +5,12 @@ full_link:
 short_description: A unique identifier assigned to each machine in the Viam platform.
 aka:
 type: "page"
+aliases:
+  - /dev/reference/glossary/machine-id/
 ---
 
 A **Machine ID** is a unique identifier assigned to each {{< glossary_tooltip term_id="machine" text="machine" >}} in the Viam platform.
 This ID is used to identify and reference a specific machine within the Viam ecosystem.
 
 Machine IDs are automatically generated when a new machine is created on Viam.
-You can get it using the web UI and the [Fleet management API](/dev/reference/apis/fleet/).
+You can get it using the web UI and the [Fleet management API](/reference/apis/fleet/).
diff --git a/docs/dev/reference/glossary/machine.md b/docs/reference/glossary/machine.md
similarity index 90%
rename from docs/dev/reference/glossary/machine.md
rename to docs/reference/glossary/machine.md
index 3f1c97815b..da0f9298b2 100644
--- a/docs/dev/reference/glossary/machine.md
+++ b/docs/reference/glossary/machine.md
@@ -3,6 +3,8 @@ title: Machine
 id: machine
 full_link: /fleet/machines/
 short_description: An organizational concept, consisting of a computer and the components and services it controls, or sometimes multiple computers working closely together.
+aliases:
+  - /dev/reference/glossary/machine/
 ---
 
 A smart machine is an organizational concept, consisting of either one _{{< glossary_tooltip term_id="part" text="part" >}}_, or multiple _parts_ working closely together to complete tasks.
diff --git a/docs/dev/reference/glossary/ml.md b/docs/reference/glossary/ml.md
similarity index 50%
rename from docs/dev/reference/glossary/ml.md
rename to docs/reference/glossary/ml.md
index c1b6f16563..7fde5c117c 100644
--- a/docs/dev/reference/glossary/ml.md
+++ b/docs/reference/glossary/ml.md
@@ -5,8 +5,10 @@ full_link:
 short_description: Machine learning, a field of artificial intelligence focused on building systems that learn from data.
 aka:
 type: "page"
+aliases:
+  - /dev/reference/glossary/ml/
 ---
 
 ML stands for machine learning, a field of artificial intelligence that focuses on building systems that can learn from and make decisions based on data.
 
-Viam provides tools for [training ML models](/data-ai/train/train/), [deploying them to machines](/data-ai/ai/deploy/), [running inference](/data-ai/ai/run-inference/), and [interpret visual data from cameras](/data-ai/ai/alert/) to enable intelligent behavior in robotic systems.
+Viam provides tools for [training ML models](/train/custom-training-scripts/), [deploying them to machines](/vision/configure/), [running inference](/vision/detect/), and [interpret visual data from cameras](/vision/alert-on-detections/) to enable intelligent behavior in robotic systems.
diff --git a/docs/dev/reference/glossary/model-namespace-triplet.md b/docs/reference/glossary/model-namespace-triplet.md
similarity index 90%
rename from docs/dev/reference/glossary/model-namespace-triplet.md
rename to docs/reference/glossary/model-namespace-triplet.md
index 4a21fb142b..dfae183a12 100644
--- a/docs/dev/reference/glossary/model-namespace-triplet.md
+++ b/docs/reference/glossary/model-namespace-triplet.md
@@ -2,6 +2,8 @@
 title: Model Namespace Triplet
 id: model-namespace-triplet
 short_description: namespace:module-name:name or rdk:builtin:name
+aliases:
+  - /dev/reference/glossary/model-namespace-triplet/
 ---
 
 {{< glossary_tooltip term_id="model" text="Models" >}} are uniquely namespaced as colon-delimited-triplets.
diff --git a/docs/dev/reference/glossary/model.md b/docs/reference/glossary/model.md
similarity index 73%
rename from docs/dev/reference/glossary/model.md
rename to docs/reference/glossary/model.md
index 70becc0578..100b86f8ec 100644
--- a/docs/dev/reference/glossary/model.md
+++ b/docs/reference/glossary/model.md
@@ -3,16 +3,18 @@ title: Model
 id: model
 full_link:
 short_description: A particular implementation of a resource. For example, UR5e is a model of the arm component API.
+aliases:
+  - /dev/reference/glossary/model/
 ---
 
-A particular implementation of a {{< glossary_tooltip term_id="resource" text="resource" >}} [API](/dev/reference/apis/).
+A particular implementation of a {{< glossary_tooltip term_id="resource" text="resource" >}} [API](/reference/apis/).
 
 Models allow you to control hardware or software of a similar category, such as motors, with a consistent set of methods as an interface, even if the underlying implementation differs.
 
-For example, some _models_ of DC motors communicate using [GPIO](/operate/reference/components/board/), while other DC motors use serial protocols like the SPI bus.
+For example, some _models_ of DC motors communicate using [GPIO](/hardware/common-components/add-a-board/), while other DC motors use serial protocols like the SPI bus.
 Regardless, you can power any motor model that implements the `rdk:component:motor` API with the `SetPower()` method.
 
-Models are either included with [`viam-server`](/operate/reference/viam-server/) or provided through {{< glossary_tooltip term_id="module" text="modules" >}}.
+Models are either included with `viam-server` or provided through {{< glossary_tooltip term_id="module" text="modules" >}}.
 All models are uniquely namespaced as colon-delimited-triplets.
 Built-in model names have the form `rdk:builtin:name`.
 Modular resource model names have the form `namespace:module-name:model-name`.
diff --git a/docs/dev/reference/glossary/modular-resource.md b/docs/reference/glossary/modular-resource.md
similarity index 92%
rename from docs/dev/reference/glossary/modular-resource.md
rename to docs/reference/glossary/modular-resource.md
index 522f3bf4f4..d4554ec489 100644
--- a/docs/dev/reference/glossary/modular-resource.md
+++ b/docs/reference/glossary/modular-resource.md
@@ -2,6 +2,8 @@
 title: Modular Resource
 id: modular-resource
 short_description: A modular resource is a model of a component or service provided by a module.
+aliases:
+  - /dev/reference/glossary/modular-resource/
 ---
 
 A modular resource is a {{< glossary_tooltip term_id="model" text="model" >}} of a {{< glossary_tooltip term_id="component" text="component" >}} or {{< glossary_tooltip term_id="service" text="service" >}} provided by a {{< glossary_tooltip term_id="module" text="module" >}}.
diff --git a/docs/dev/reference/glossary/module.md b/docs/reference/glossary/module.md
similarity index 94%
rename from docs/dev/reference/glossary/module.md
rename to docs/reference/glossary/module.md
index 2ae51f3a45..fbfc646ef2 100644
--- a/docs/dev/reference/glossary/module.md
+++ b/docs/reference/glossary/module.md
@@ -3,6 +3,8 @@ title: Module
 id: module
 full_link:
 short_description: Modules are the code packages that provide functionality like drivers, integrations, and control logic to your machines.
+aliases:
+  - /dev/reference/glossary/module/
 ---
 
 A _module_ is a code package which provides one or more {{< glossary_tooltip term_id="modular-resource" text="modular resources" >}}, which add {{< glossary_tooltip term_id="resource" text="resource" >}} {{< glossary_tooltip term_id="type" text="types" >}} or {{< glossary_tooltip term_id="model" text="models" >}}, integrations, or control logic for your machines.
diff --git a/docs/dev/reference/glossary/mql.md b/docs/reference/glossary/mql.md
similarity index 78%
rename from docs/dev/reference/glossary/mql.md
rename to docs/reference/glossary/mql.md
index fff92f987b..0718686ffa 100644
--- a/docs/dev/reference/glossary/mql.md
+++ b/docs/reference/glossary/mql.md
@@ -3,8 +3,10 @@ title: MQL
 id: mql
 full_link:
 short_description: MQL is the MongoDB query language, similar to SQL but specific to the MongoDB document model.
+aliases:
+  - /dev/reference/glossary/mql/
 ---
 
 MQL is the [MongoDB query language](https://www.mongodb.com/docs/manual/tutorial/query-documents/), similar to {{< glossary_tooltip term_id="sql" text="SQL" >}} but specific to the MongoDB document model.
 
-You can use MQL to query data that you have synced to Viam using the [data management service](/data-ai/capture-data/capture-sync/).
+You can use MQL to query data that you have synced to Viam using the [data management service](/data/capture-sync/capture-and-sync-data/).
diff --git a/docs/dev/reference/glossary/organization.md b/docs/reference/glossary/organization.md
similarity index 82%
rename from docs/dev/reference/glossary/organization.md
rename to docs/reference/glossary/organization.md
index fb3e8a0699..1e69826a14 100644
--- a/docs/dev/reference/glossary/organization.md
+++ b/docs/reference/glossary/organization.md
@@ -3,10 +3,12 @@ title: Organization
 id: organization
 full_link: /manage/reference/organize/
 short_description: An organization is a group of one or more locations that helps you organize your fleet and manage who has access to your fleet.
+aliases:
+  - /dev/reference/glossary/organization/
 ---
 
 An organization or org is the highest level grouping in the Viam platform, which generally represents a company, or other institution.
 Every {{< glossary_tooltip term_id="location" text="location" >}} is grouped into an organization.
 You can also have organizations for departments or other entities, or for personal use.
 
-For more information, see [Organize your machines](/manage/reference/organize/).
+For more information, see [Organize your machines](/reference/).
diff --git a/docs/dev/reference/glossary/origin-frame.md b/docs/reference/glossary/origin-frame.md
similarity index 86%
rename from docs/dev/reference/glossary/origin-frame.md
rename to docs/reference/glossary/origin-frame.md
index 3c93d3ae97..44f590b8c5 100644
--- a/docs/dev/reference/glossary/origin-frame.md
+++ b/docs/reference/glossary/origin-frame.md
@@ -3,6 +3,8 @@ title: Origin frame
 id: origin-frame
 full_link:
 short_description: The origin frame is the frame at the base of an arm or other component that has a complex kinematics chain.
+aliases:
+  - /dev/reference/glossary/origin-frame/
 ---
 
 The origin frame is the frame at the base of an arm, gantry, or other component.
@@ -13,4 +15,4 @@ Every component that has a kinematics chain has an origin frame and an end effec
 If you parent a gripper to the arm's `my_arm` frame, the frame system will know the gripper is at the end of the arm.
 If you mistakenly parent the gripper to the arm's `my_arm_origin` frame, the frame system will think the gripper is at the base of the arm, and the gripper will not move when you move the arm.
 
-For more information, see [How the frame system works](/operate/reference/services/frame-system/#how-the-frame-system-works).
+For more information, see [How the frame system works](/reference/).
diff --git a/docs/dev/reference/glossary/package.md b/docs/reference/glossary/package.md
similarity index 85%
rename from docs/dev/reference/glossary/package.md
rename to docs/reference/glossary/package.md
index df94fe7a04..e01263584d 100644
--- a/docs/dev/reference/glossary/package.md
+++ b/docs/reference/glossary/package.md
@@ -3,6 +3,8 @@ title: Package
 id: package
 full_link:
 short_description: An archive, module, ML model, SLAM Map, or other bundle of binary code.
+aliases:
+  - /dev/reference/glossary/package/
 ---
 
 A _package_ is an archive, module, ML model, SLAM map, or other bundle of binary code.
diff --git a/docs/dev/reference/glossary/part.md b/docs/reference/glossary/part.md
similarity index 79%
rename from docs/dev/reference/glossary/part.md
rename to docs/reference/glossary/part.md
index 489facb829..5f1232d7f0 100644
--- a/docs/dev/reference/glossary/part.md
+++ b/docs/reference/glossary/part.md
@@ -1,10 +1,10 @@
 ---
 title: Part
 id: part
-full_link: /operate/reference/architecture/parts/
+full_link: /reference/glossary/part/
 short_description: A single-board computer, desktop, laptop, or other computer running viam-server, the hardware components attached to it, and any services or other resources running on it.
+aliases:
+  - /dev/reference/glossary/part/
 ---
 
 Smart machines are organized into _parts_, where each part represents a computer (a single-board computer, desktop, laptop, or other computer) running `viam-server`, the hardware {{< glossary_tooltip term_id="component" text="components" >}} attached to it, and any {{< glossary_tooltip term_id="service" text="services" >}} or other resources running on it.
-
-For more information, see [Machine Architecture: Parts](/operate/reference/architecture/parts/).
diff --git a/docs/dev/reference/glossary/pi.md b/docs/reference/glossary/pi.md
similarity index 87%
rename from docs/dev/reference/glossary/pi.md
rename to docs/reference/glossary/pi.md
index ce2484f438..d5528b780d 100644
--- a/docs/dev/reference/glossary/pi.md
+++ b/docs/reference/glossary/pi.md
@@ -5,6 +5,8 @@ full_link:
 short_description: Short for Raspberry Pi, a series of small single-board computers developed by the Raspberry Pi Foundation.
 aka:
 type: "page"
+aliases:
+  - /dev/reference/glossary/pi/
 ---
 
 Pi is short for Raspberry Pi, a series of small, affordable single-board computers developed by the Raspberry Pi Foundation.
@@ -12,4 +14,4 @@ These credit card-sized computers are widely used in robotics, IoT projects, edu
 
 Viam supports many different devices including Raspberry Pis as host computers for running `viam-server`.
 
-To set up a Raspberry Pi, see [the Raspberry Pi setup instructions](/operate/reference/prepare/rpi-setup/).
+To set up a Raspberry Pi, see [the Raspberry Pi setup instructions](/reference/device-setup/rpi-setup/).
diff --git a/docs/dev/reference/glossary/pin-number.md b/docs/reference/glossary/pin-number.md
similarity index 93%
rename from docs/dev/reference/glossary/pin-number.md
rename to docs/reference/glossary/pin-number.md
index 3831146ac3..b460c0c254 100644
--- a/docs/dev/reference/glossary/pin-number.md
+++ b/docs/reference/glossary/pin-number.md
@@ -3,6 +3,8 @@ title: Pin Number
 id: pin-number
 full_link:
 short_description: A pin number is the index of the pin on the board. Not the same as a pin's GPIO number.
+aliases:
+  - /dev/reference/glossary/pin-number/
 ---
 
 A pin number is the physical index of a pin on a {{< glossary_tooltip term_id="board" text="board" >}}.
diff --git a/docs/dev/reference/glossary/protobuf.md b/docs/reference/glossary/protobuf.md
similarity index 89%
rename from docs/dev/reference/glossary/protobuf.md
rename to docs/reference/glossary/protobuf.md
index c53576b9b1..fde40a0e05 100644
--- a/docs/dev/reference/glossary/protobuf.md
+++ b/docs/reference/glossary/protobuf.md
@@ -3,6 +3,8 @@ title: Protocol Buffers (Protobuf)
 id: protobuf
 full_link:
 short_description: A free and open-source, language-neutral, cross-platform data format for serializing structured data.
+aliases:
+  - /dev/reference/glossary/protobuf/
 ---
 
 A free and open-source, language-neutral, cross-platform data format for serializing structured data.
diff --git a/docs/dev/reference/glossary/rdk.md b/docs/reference/glossary/rdk.md
similarity index 68%
rename from docs/dev/reference/glossary/rdk.md
rename to docs/reference/glossary/rdk.md
index 8b5ae926fd..f871397b93 100644
--- a/docs/dev/reference/glossary/rdk.md
+++ b/docs/reference/glossary/rdk.md
@@ -1,8 +1,10 @@
 ---
 title: RDK (Robot Development Kit)
 id: rdk
-full_link: /operate/reference/viam-server/
+full_link: /reference/glossary/rdk/
 short_description: The official Viam-developed codebase that provides all functionality of an SDK and more.
+aliases:
+  - /dev/reference/glossary/rdk/
 ---
 
-Viam’s Robot Development Kit (RDK) is the [open-source](https://github.com/viamrobotics/rdk), on-machine portion of the Viam platform, that provides [`viam-server`](/operate/reference/viam-server/) and the Go SDK.
+Viam’s Robot Development Kit (RDK) is the [open-source](https://github.com/viamrobotics/rdk), on-machine portion of the Viam platform, that provides `viam-server` and the Go SDK.
diff --git a/docs/dev/reference/glossary/remote-part.md b/docs/reference/glossary/remote-part.md
similarity index 69%
rename from docs/dev/reference/glossary/remote-part.md
rename to docs/reference/glossary/remote-part.md
index 950c9b1c3e..9a82760e50 100644
--- a/docs/dev/reference/glossary/remote-part.md
+++ b/docs/reference/glossary/remote-part.md
@@ -4,8 +4,8 @@ id: remote-part
 full_link: /architecture/parts/
 short_description: A machine part which is controlled by another machine part.
 aka:
+aliases:
+  - /dev/reference/glossary/remote-part/
 ---
 
 A machine part which is controlled by another machine part.
-
-For more information, see [Machine Architecture: Parts](/operate/reference/architecture/parts/).
diff --git a/docs/dev/reference/glossary/resource.md b/docs/reference/glossary/resource.md
similarity index 88%
rename from docs/dev/reference/glossary/resource.md
rename to docs/reference/glossary/resource.md
index 7b09c2db0e..9d89de3a84 100644
--- a/docs/dev/reference/glossary/resource.md
+++ b/docs/reference/glossary/resource.md
@@ -3,6 +3,8 @@ title: Resource
 id: resource
 full_link:
 short_description: Resources are individual, addressable elements of a machine such as components or services.
+aliases:
+  - /dev/reference/glossary/resource/
 ---
 
 Resources are individual, addressable elements of a machine.
@@ -16,4 +18,4 @@ Resources are individual, addressable elements of a machine.
 Each part has local resources and can also have resources from another {{< glossary_tooltip term_id="remote-part" text="remote">}} machine part.
 The capabilities of each resource are exposed through the part’s API.
 
-Each resource on your machine implements either one of the [existing Viam APIs](/dev/reference/apis/), or a [custom interface](/operate/reference/advanced-modules/#new-apis).
+Each resource on your machine implements either one of the [existing Viam APIs](/reference/apis/), or a [custom interface](/reference/).
diff --git a/docs/dev/reference/glossary/sdk.md b/docs/reference/glossary/sdk.md
similarity index 86%
rename from docs/dev/reference/glossary/sdk.md
rename to docs/reference/glossary/sdk.md
index d4854df97e..69ee59fb3a 100644
--- a/docs/dev/reference/glossary/sdk.md
+++ b/docs/reference/glossary/sdk.md
@@ -1,12 +1,14 @@
 ---
 title: SDK (Software Development Kit)
 id: sdk
-full_link: /dev/reference/apis/
+full_link: /reference/apis/
 short_description: Viam provides software development kits (SDKs) to help you write client applications and create support for custom component types.
+aliases:
+  - /dev/reference/glossary/sdk/
 ---
 
 Viam provides software development kits (SDKs) to help you write client applications and create support for custom {{< glossary_tooltip term_id="component" text="component" >}} types.
 
 The SDKs wrap the `viam-server` {{< glossary_tooltip term_id="grpc" text="gRPC" >}} {{< glossary_tooltip term_id="viam-robot-api" text="Viam Robot API" >}} and streamline connection, authentication, and encryption.
 
-For more information, see [Interact with Resources with Viam's Client SDKs](/dev/reference/apis/).
+For more information, see [Interact with Resources with Viam's Client SDKs](/reference/apis/).
diff --git a/docs/dev/reference/glossary/service.md b/docs/reference/glossary/service.md
similarity index 80%
rename from docs/dev/reference/glossary/service.md
rename to docs/reference/glossary/service.md
index dba4d3dc98..debac35852 100644
--- a/docs/dev/reference/glossary/service.md
+++ b/docs/reference/glossary/service.md
@@ -2,10 +2,12 @@
 title: Service
 id: service
 short_description: Built-in software packages for complex capabilities such as SLAM, Computer Vision, Motion Planning, and Data Collection.
+aliases:
+  - /dev/reference/glossary/service/
 ---
 
 Services are built-in software packages for complex capabilities such as simultaneous localization and mapping (SLAM), computer vision, motion planning, and data collection.
 
 Each service is typed by a proto API, such as the [service proto definitions](https://github.com/viamrobotics/api/tree/main/proto/viam/service).
 
-For more information, see [Service APIs](/dev/reference/apis/#service-apis).
+For more information, see [Service APIs](/reference/apis/#service-apis).
diff --git a/docs/dev/reference/glossary/setup.md b/docs/reference/glossary/setup.md
similarity index 93%
rename from docs/dev/reference/glossary/setup.md
rename to docs/reference/glossary/setup.md
index 835b2a67c9..823ae6bdb3 100644
--- a/docs/dev/reference/glossary/setup.md
+++ b/docs/reference/glossary/setup.md
@@ -3,6 +3,8 @@ title: View setup instructions
 id: setup
 full_link:
 short_description: To view setup instructions for a machine part, navigate to the CONFIGURE tab, find the part's card, click the "..." menu in the upper right corner of the card, and select "View setup instructions".
+aliases:
+  - /dev/reference/glossary/setup/
 ---
 
 Before configuring a machine {{< glossary_tooltip term_id="part" text="part" >}}, you must follow the correct setup instructions for your machine's architecture.
diff --git a/docs/dev/reference/glossary/slam.md b/docs/reference/glossary/slam.md
similarity index 82%
rename from docs/dev/reference/glossary/slam.md
rename to docs/reference/glossary/slam.md
index dd39f4fc4c..2196bc9b2d 100644
--- a/docs/dev/reference/glossary/slam.md
+++ b/docs/reference/glossary/slam.md
@@ -3,8 +3,10 @@ title: SLAM
 id: slam
 full_link: /operate/reference/services/slam/
 short_description: Simultaneous Localization And Mapping (SLAM) algorithms use data from a machine's sensors to generate a map of the environment and determine the machine's position within it.
+aliases:
+  - /dev/reference/glossary/slam/
 ---
 
 SLAM (Simultaneous Localization and Mapping) algorithms use data from a machine's sensors, like LiDARs, cameras, and movement sensors, to generate a map of the environment and determine the machine's position within it.
 
-For more information, see [SLAM](/operate/reference/services/slam/).
+For more information, see [SLAM](/reference/services/slam/).
diff --git a/docs/dev/reference/glossary/smart-machine.md b/docs/reference/glossary/smart-machine.md
similarity index 90%
rename from docs/dev/reference/glossary/smart-machine.md
rename to docs/reference/glossary/smart-machine.md
index cb040651a4..f13ff7b46a 100644
--- a/docs/dev/reference/glossary/smart-machine.md
+++ b/docs/reference/glossary/smart-machine.md
@@ -3,6 +3,8 @@ title: Smart Machine
 id: smart-machine
 full_link:
 short_description: A machine or device that lives in the real world and has some ability to perceive the world (with a sensor, for example) and perform actions like operating a motor.
+aliases:
+  - /dev/reference/glossary/smart-machine/
 ---
 
 A machine or device that lives in the real world and has some ability to perceive the world (with a sensor, for example) and perform actions like operating a motor.
diff --git a/docs/dev/reference/glossary/sql.md b/docs/reference/glossary/sql.md
similarity index 79%
rename from docs/dev/reference/glossary/sql.md
rename to docs/reference/glossary/sql.md
index a7b83bb71d..8bf6fffa8e 100644
--- a/docs/dev/reference/glossary/sql.md
+++ b/docs/reference/glossary/sql.md
@@ -3,8 +3,10 @@ title: SQL
 id: sql
 full_link:
 short_description: SQL (structured query language) is the widely-used, industry-standard query language popular with relational databases.
+aliases:
+  - /dev/reference/glossary/sql/
 ---
 
 [SQL (structured query language)](https://en.wikipedia.org/wiki/SQL) is the widely-used, industry-standard query language popular with [relational databases](https://en.wikipedia.org/wiki/Relational_database).
 
-You can use SQL to query data that you have synced to Viam using the [data management service](/data-ai/capture-data/capture-sync/).
+You can use SQL to query data that you have synced to Viam using the [data management service](/data/capture-sync/capture-and-sync-data/).
diff --git a/docs/dev/reference/glossary/subtype.md b/docs/reference/glossary/subtype.md
similarity index 82%
rename from docs/dev/reference/glossary/subtype.md
rename to docs/reference/glossary/subtype.md
index 8b0fcd29f9..294d400798 100644
--- a/docs/dev/reference/glossary/subtype.md
+++ b/docs/reference/glossary/subtype.md
@@ -3,6 +3,8 @@ title: Subtype
 id: subtype
 full_link:
 short_description: A group of component or service models that share the same API. For example, arm is a subtype of component.
+aliases:
+  - /dev/reference/glossary/subtype/
 ---
 
 A category within a {{< glossary_tooltip term_id="type" text="type" >}} of {{< glossary_tooltip term_id="resource" text="resource" >}}.
@@ -11,6 +13,6 @@ Resource models belonging to a subtype share the same API.
 
 For example, an arm is a subtype of the {{< glossary_tooltip term_id="component" text="component" >}} resource type, while the `ur5e` is a {{< glossary_tooltip term_id="model" text="model" >}} of the arm subtype's API.
 
-The [Vision Service](/operate/reference/services/vision/) is a subtype of the {{< glossary_tooltip term_id="service" text="service" >}} resource type.
+The [Vision Service](/vision/configure/) is a subtype of the {{< glossary_tooltip term_id="service" text="service" >}} resource type.
 
 The `subtype` string is the third part of the {{< glossary_tooltip term_id="api-namespace-triplet" text="API namespace triplet" >}}.
diff --git a/docs/dev/reference/glossary/trigger.md b/docs/reference/glossary/trigger.md
similarity index 82%
rename from docs/dev/reference/glossary/trigger.md
rename to docs/reference/glossary/trigger.md
index ef3d34edfc..181d1158bd 100644
--- a/docs/dev/reference/glossary/trigger.md
+++ b/docs/reference/glossary/trigger.md
@@ -3,6 +3,8 @@ title: Trigger
 id: trigger
 full_link: /data-ai/reference/triggers-configuration/
 short_description: A mechanism that sends alerts by email or webhook when specific events occur in your machine or data.
+aliases:
+  - /dev/reference/glossary/trigger/
 ---
 
 A trigger is a mechanism that sends alerts by email or webhook when specific events occur in your machine or data.
@@ -13,4 +15,4 @@ Triggers can alert you when the following events occur:
 - Data syncs from a machine
 - A service detects a specified object or classifies a specified label
 
-For more information, see [Trigger configuration](/data-ai/reference/triggers-configuration/).
+For more information, see [Trigger configuration](/reference/triggers/).
diff --git a/docs/dev/reference/glossary/type.md b/docs/reference/glossary/type.md
similarity index 91%
rename from docs/dev/reference/glossary/type.md
rename to docs/reference/glossary/type.md
index 25d1324e0d..602363496e 100644
--- a/docs/dev/reference/glossary/type.md
+++ b/docs/reference/glossary/type.md
@@ -3,6 +3,8 @@ title: Type
 id: type
 full_link:
 short_description: Component and service are the built-in types of resource API the RDK provides.
+aliases:
+  - /dev/reference/glossary/type/
 ---
 
 In the {{< glossary_tooltip term_id="rdk" text="RDK" >}} architecture's {{< glossary_tooltip term_id="api-namespace-triplet" text="namespace triplet" >}} for resource APIs, _type_ refers to the distinction between {{< glossary_tooltip term_id="component" text="component" >}} or {{< glossary_tooltip term_id="service" text="service" >}}.
diff --git a/docs/dev/reference/glossary/viam-agent.md b/docs/reference/glossary/viam-agent.md
similarity index 77%
rename from docs/dev/reference/glossary/viam-agent.md
rename to docs/reference/glossary/viam-agent.md
index b101495707..a7c1c9c024 100644
--- a/docs/dev/reference/glossary/viam-agent.md
+++ b/docs/reference/glossary/viam-agent.md
@@ -3,9 +3,11 @@ title: Viam Agent
 id: viam-agent
 full_link:
 short_description: The Viam provisioning application for deploying viam-server.
+aliases:
+  - /dev/reference/glossary/viam-agent/
 ---
 
 The Viam Agent is a provisioning application for deploying and managing `viam-server` across a fleet of machines.
 You can use the Viam Agent to provision a machine as it first comes online with a pre-defined configuration, including WiFi networks or additional build or provision steps.
 
-See [Provision Machines](/manage/fleet/provision/setup/) for more information.
+See [Provision Machines](/fleet/provision-devices/) for more information.
diff --git a/docs/dev/reference/glossary/viam-micro-server.md b/docs/reference/glossary/viam-micro-server.md
similarity index 77%
rename from docs/dev/reference/glossary/viam-micro-server.md
rename to docs/reference/glossary/viam-micro-server.md
index 0e37cf4073..94bffd2643 100644
--- a/docs/dev/reference/glossary/viam-micro-server.md
+++ b/docs/reference/glossary/viam-micro-server.md
@@ -3,10 +3,12 @@ title: viam-micro-server
 id: viam-micro-server
 full_link: /operate/reference/viam-micro-server/
 short_description: The lightweight version of viam-server that can run on ESP32 devices.
+aliases:
+  - /dev/reference/glossary/viam-micro-server/
 ---
 
 The lightweight version of `viam-server`, built for microcontrollers.
 `viam-micro-server` is a set of open-source utilities which run on your microcontroller and provides Viam functionality to your machine.
 `viam-micro-server` is built from the Micro-RDK.
 
-For more information see [Architecture](/operate/reference/viam-micro-server/).
+For more information see [Architecture](/reference/viam-micro-server/).
diff --git a/docs/dev/reference/glossary/viam-robot-api.md b/docs/reference/glossary/viam-robot-api.md
similarity index 91%
rename from docs/dev/reference/glossary/viam-robot-api.md
rename to docs/reference/glossary/viam-robot-api.md
index 130ce54f19..70d940c12d 100644
--- a/docs/dev/reference/glossary/viam-robot-api.md
+++ b/docs/reference/glossary/viam-robot-api.md
@@ -3,6 +3,8 @@ title: Viam Robot API
 id: viam-robot-api
 full_link:
 short_description: The specification for communication with resources.
+aliases:
+  - /dev/reference/glossary/viam-robot-api/
 ---
 
 The specification for communication with resources.
diff --git a/docs/dev/reference/glossary/viam-server.md b/docs/reference/glossary/viam-server.md
similarity index 73%
rename from docs/dev/reference/glossary/viam-server.md
rename to docs/reference/glossary/viam-server.md
index 088b7c941a..fb9acd996d 100644
--- a/docs/dev/reference/glossary/viam-server.md
+++ b/docs/reference/glossary/viam-server.md
@@ -1,11 +1,11 @@
 ---
 title: viam-server
 id: viam-server
-full_link: /operate/reference/viam-server/
+full_link: /reference/glossary/viam-server/
 short_description: The executable binary which runs on and provides functionality to machines.
+aliases:
+  - /dev/reference/glossary/viam-server/
 ---
 
 The open-source executable binary that runs on your machine's computer (such as a single-board computer or a server) and provides most Viam functionality.
 `viam-server` is built from the RDK.
-
-For more information see [Architecture](/operate/reference/viam-server/).
diff --git a/docs/dev/reference/glossary/vision-service.md b/docs/reference/glossary/vision-service.md
similarity index 77%
rename from docs/dev/reference/glossary/vision-service.md
rename to docs/reference/glossary/vision-service.md
index 576c2d91c2..47dfa238db 100644
--- a/docs/dev/reference/glossary/vision-service.md
+++ b/docs/reference/glossary/vision-service.md
@@ -5,9 +5,11 @@ full_link: /operate/reference/services/vision/
 short_description: A service that enables machines to interpret visual data from cameras using computer vision and machine learning.
 aka:
 type: "page"
+aliases:
+  - /dev/reference/glossary/vision-service/
 ---
 
 The vision service is a {{< glossary_tooltip term_id="service" text="service" >}} in the Viam platform that enables machines to interpret visual data captured by camera using computer vision and {{< glossary_tooltip term_id="ml" text="machine learning" >}} techniques.
 Vision services can use various models, including pre-trained models or custom models trained on your own data using the Viam platform.
 
-For more information, see the [Vision service documentation](/operate/reference/services/vision/) or [Alert on inferences](/data-ai/ai/alert/).
+For more information, see the [Vision service documentation](/vision/configure/) or [Alert on inferences](/vision/alert-on-detections/).
diff --git a/docs/dev/reference/glossary/web-sockets.md b/docs/reference/glossary/web-sockets.md
similarity index 87%
rename from docs/dev/reference/glossary/web-sockets.md
rename to docs/reference/glossary/web-sockets.md
index 373babdd47..be2ad2c4db 100644
--- a/docs/dev/reference/glossary/web-sockets.md
+++ b/docs/reference/glossary/web-sockets.md
@@ -3,6 +3,8 @@ title: Websockets
 id: web-sockets
 full_link:
 short_description: A computer communications protocol that provides full-duplex communication channels over a single Transmission Control Protocol (TCP) connection.
+aliases:
+  - /dev/reference/glossary/web-sockets/
 ---
 
 A computer communications protocol that provides full-duplex communication channels over a single Transmission Control Protocol (TCP) connection.
diff --git a/docs/dev/reference/glossary/webrtc.md b/docs/reference/glossary/webrtc.md
similarity index 91%
rename from docs/dev/reference/glossary/webrtc.md
rename to docs/reference/glossary/webrtc.md
index cef6315d2b..523ee9788c 100644
--- a/docs/dev/reference/glossary/webrtc.md
+++ b/docs/reference/glossary/webrtc.md
@@ -3,6 +3,8 @@ title: WebRTC
 id: webrtc
 full_link:
 short_description: An open source project which provides applications with real-time communication (RTC) using application programming interfaces (API) allowing powerful voice and video integration.
+aliases:
+  - /dev/reference/glossary/webrtc/
 ---
 
 An open source project which provides applications with real-time communication (RTC) using application programming interfaces (API) allowing powerful voice and video integration.
diff --git a/docs/dev/reference/glossary/world-frame.md b/docs/reference/glossary/world-frame.md
similarity index 79%
rename from docs/dev/reference/glossary/world-frame.md
rename to docs/reference/glossary/world-frame.md
index bfe228d710..3d3b460c94 100644
--- a/docs/dev/reference/glossary/world-frame.md
+++ b/docs/reference/glossary/world-frame.md
@@ -4,9 +4,11 @@ id: world-frame
 full_link: /operate/mobility/move-arm/frame-how-to/
 short_description: The fixed, user-defined global coordinate system that is the reference point for all other coordinate frames in a robotic system.
 aka: world frame, world
+aliases:
+  - /dev/reference/glossary/world-frame/
 ---
 
-The world reference [frame](/operate/reference/services/frame-system/) is the fixed, global coordinate system that serves as the reference point for all other coordinate frames in a robotic system.
+The world reference [frame](/reference/) is the fixed, global coordinate system that serves as the reference point for all other coordinate frames in a robotic system.
 It provides a consistent basis for describing the position and orientation of robots, components, and objects in the physical space.
 All other coordinate frames (such as machine frames and component frames) are defined relative to this world frame, either directly or through a chain of transformations.
 
diff --git a/docs/reference/sdks/_index.md b/docs/reference/sdks/_index.md
new file mode 100644
index 0000000000..8fea1453f9
--- /dev/null
+++ b/docs/reference/sdks/_index.md
@@ -0,0 +1,39 @@
+---
+title: "Write control code with Viam SDKs"
+linkTitle: "SDKs"
+weight: 10
+type: "docs"
+description: "Write code to control your machine with Viam's Python, Go, TypeScript, Flutter, and C++ SDKs."
+aliases:
+  - /sdks/
+---
+
+## Backend SDKs
+
+The backend SDKs allow you to build business logic to control [components](/reference/apis/#component-apis) and [services](/reference/apis/#service-apis), as well as manage your [fleet](/reference/apis/fleet/) and [data](/reference/apis/data-client/), and [billing information](/reference/apis/billing-client/), or [provision](/fleet/provision-devices/) machines.
+With the backend SDKs you can also create custom {{< glossary_tooltip term_id="modular-resource" text="modular resources" >}}.
+
+{{< sectionlist-custom class="horizontal" >}}
+{{% sectionlist-custom-item link="/reference/sdks/python/" %}}
+{{% sectionlist-custom-item link="/reference/sdks/go/" %}}
+{{% sectionlist-custom-item link="/reference/sdks/cpp/" %}}
+{{< /sectionlist-custom >}}
+<br>
+
+## Frontend SDKs
+
+The frontend TypeScript SDK allows you to control your machine's [components](/reference/apis/#component-apis), as well as manage your [data](/reference/apis/data-client/) or [provision](/fleet/provision-devices/) machines.
+
+{{< sectionlist-custom class="horizontal" >}}
+{{% sectionlist-custom-item link="/reference/sdks/typescript/" %}}
+{{< /sectionlist-custom >}}
+<br>
+
+## Mobile SDK
+
+The mobile SDK allows you to build iOS and Android apps to control your machine's [components](/reference/apis/#component-apis), as well as manage your [fleet](/reference/apis/fleet/) and [data](/reference/apis/data-client/), or [provision](/fleet/provision-devices/) machines.
+
+{{< sectionlist-custom class="horizontal">}}
+{{% sectionlist-custom-item link="/reference/sdks/flutter/" %}}
+{{< /sectionlist-custom >}}
+<br>
diff --git a/docs/dev/reference/sdks/connectivity.md b/docs/reference/sdks/connectivity.md
similarity index 66%
rename from docs/dev/reference/sdks/connectivity.md
rename to docs/reference/sdks/connectivity.md
index 337ed05baf..ab09cd965f 100644
--- a/docs/dev/reference/sdks/connectivity.md
+++ b/docs/reference/sdks/connectivity.md
@@ -7,13 +7,14 @@ description: "When you connect to a machine, the machine automatically chooses t
 tags:
   ["client", "sdk", "viam-server", "networking", "apis", "robot api", "session"]
 aliases:
+  - /dev/reference/sdks/connectivity/
   - /program/connectivity/
   - /sdks/connectivity/
 date: "2022-01-01"
 # updated: ""  # When the content was last entirely checked
 ---
 
-When connecting to a machine using the connection code from the [**CONNECT** tab](/dev/reference/sdks/), a [client session](/dev/reference/apis/sessions/) automatically uses the most efficient route to connect to your machine either through local LAN or WAN or the internet.
+When connecting to a machine using the connection code from the [**CONNECT** tab](/reference/sdks/), a [client session](/reference/apis/sessions/) automatically uses the most efficient route to connect to your machine either through local LAN or WAN or the internet.
 
 ## Connect over local network or offline
 
@@ -68,25 +69,25 @@ When a machine loses its connection to the internet but is still connected to a
 - Client sessions connected through the same LAN or WAN will function normally.
 - Client sessions connected through the internet will timeout and end.
   If the client is on the same LAN or WAN but the route it chose to connect is through the internet, the client will automatically disconnect and then reconnect over LAN.
-- Cloud sync for the [data management service](/data-ai/capture-data/capture-sync/) will pause until the internet connection is re-established since the machine will be unable to connect to Viam.
+- Cloud sync for the [data management service](/data/capture-sync/capture-and-sync-data/) will pause until the internet connection is re-established since the machine will be unable to connect to Viam.
 
 When a machine loses its connection to LAN or WAN, all client sessions will timeout and end by default.
 
 ### Client session timeout and end
 
-When your client cannot connect to your machine's `viam-server` instance, `viam-server` will end any current client [_sessions_](/dev/reference/apis/sessions/) on this machine and all client operations will [time out automatically](/dev/reference/apis/sessions/) and halt: any active commands will be cancelled, stopping any moving parts, and no new commands will be able to reach the machine until the connection is restored.
+When your client cannot connect to your machine's `viam-server` instance, `viam-server` will end any current client [_sessions_](/reference/apis/sessions/) on this machine and all client operations will [time out automatically](/reference/apis/sessions/) and halt: any active commands will be cancelled, stopping any moving parts, and no new commands will be able to reach the machine until the connection is restored.
 
-To disable the default behavior and manage resource timeout and reconfiguration over a networking session yourself, you can [disable the default behavior](/dev/reference/apis/sessions/#disable-default-session-management) of session management, then use [Viam's SDKs](/dev/reference/sdks/) in your code to make calls to [the session management API](https://pkg.go.dev/go.viam.com/rdk/session#hdr-API).
+To disable the default behavior and manage resource timeout and reconfiguration over a networking session yourself, you can [disable the default behavior](/reference/apis/sessions/#disable-default-session-management) of session management, then use [Viam's SDKs](/reference/sdks/) in your code to make calls to [the session management API](https://pkg.go.dev/go.viam.com/rdk/session#hdr-API).
 
 {{% alert title="Note" color="note" %}}
 
 There are a couple of exceptions to the general timeout behavior:
 
-- If a [`MoveOnMap`](/dev/reference/apis/services/motion/#moveonmap) or [`MoveOnGlobe`](/dev/reference/apis/services/motion/#moveonglobe) command has completed a motion plan and returned an execution ID before the connection is lost, the resource that receives the motion plan will complete the motion without a connection.
+- If a [`MoveOnMap`](/reference/apis/services/motion/#moveonmap) or [`MoveOnGlobe`](/reference/apis/services/motion/#moveonglobe) command has completed a motion plan and returned an execution ID before the connection is lost, the resource that receives the motion plan will complete the motion without a connection.
 - If a navigation service and motion service are running on the same machine, the navigation service will continue sending requests to the motion service even after losing internet connectivity.
 
 {{% /alert %}}
 
 ### Configure a connection timeout
 
-When connecting to a machine using the [robot API](/dev/reference/apis/robot/) from a supported [Viam SDK](/dev/reference/apis/), you can configure an [optional timeout](/dev/reference/apis/sessions/#change-the-session-timeout) to account for intermittent or delayed network connectivity.
+When connecting to a machine using the [robot API](/reference/apis/robot/) from a supported [Viam SDK](/reference/apis/), you can configure an [optional timeout](/reference/apis/sessions/#change-the-session-timeout) to account for intermittent or delayed network connectivity.
diff --git a/docs/dev/reference/sdks/cpp.md b/docs/reference/sdks/cpp.md
similarity index 85%
rename from docs/dev/reference/sdks/cpp.md
rename to docs/reference/sdks/cpp.md
index d3c4f824ea..0ec950207c 100644
--- a/docs/dev/reference/sdks/cpp.md
+++ b/docs/reference/sdks/cpp.md
@@ -8,5 +8,6 @@ icon: true
 images: ["/logos/cpp.svg"]
 canonical: "https://cpp.viam.dev/"
 aliases:
+  - /dev/reference/sdks/cpp/
   - /sdks/cpp/
 ---
diff --git a/docs/dev/reference/sdks/docommand.md b/docs/reference/sdks/docommand.md
similarity index 95%
rename from docs/dev/reference/sdks/docommand.md
rename to docs/reference/sdks/docommand.md
index 1a9bafbf6a..3442eafaa7 100644
--- a/docs/dev/reference/sdks/docommand.md
+++ b/docs/reference/sdks/docommand.md
@@ -7,10 +7,12 @@ description: "Implement DoCommand in your module or use it from Viam's SDKs."
 tags: ["sdk", "extend"]
 date: "2025-04-29"
 # updated: ""  # When the content was last entirely checked
+aliases:
+  - /dev/reference/sdks/docommand/
 ---
 
 The `DoCommand` method is a flexible wrapper that you can use to send commands that have no corresponding built-in API method.
-`DoCommand` is part of every [component](/dev/reference/apis/#component-apis) and [service API](/dev/reference/apis/#service-apis), though most models do not implement it.
+`DoCommand` is part of every [component](/reference/apis/#component-apis) and [service API](/reference/apis/#service-apis), though most models do not implement it.
 
 In the majority of cases, you should use a more specific method for your component or service.
 As the developer of a resource, you can implement `DoCommand` in your module if you need to add custom commands to your resource.
@@ -32,7 +34,7 @@ See [More examples](#more-examples) for more.
 
 Imagine you have a robotic vacuum cleaner that has a docking sequence and can clean specific areas such as the kitchen and the living room.
 
-You could [write a module](/operate/modules/write-a-driver-module/) that implements the [base API](/dev/reference/apis/components/base/).
+You could [write a module](/operate/modules/write-a-driver-module/) that implements the [base API](/reference/apis/components/base/).
 The base API includes methods like `MoveStraight` to drive the vacuum cleaner around, and like all resource APIs, it includes a `DoCommand` method.
 In addition to the standard base methods, you could implement `DoCommand` to trigger the docking and cleaning sequences:
 
diff --git a/docs/dev/reference/sdks/flutter.md b/docs/reference/sdks/flutter.md
similarity index 85%
rename from docs/dev/reference/sdks/flutter.md
rename to docs/reference/sdks/flutter.md
index 9a4ad7013c..e6e95df2d0 100644
--- a/docs/dev/reference/sdks/flutter.md
+++ b/docs/reference/sdks/flutter.md
@@ -8,5 +8,6 @@ icon: true
 images: ["/logos/flutter.svg"]
 canonical: "https://flutter.viam.dev/"
 aliases:
+  - /dev/reference/sdks/flutter/
   - /sdks/flutter/
 ---
diff --git a/docs/dev/reference/sdks/go.md b/docs/reference/sdks/go.md
similarity index 87%
rename from docs/dev/reference/sdks/go.md
rename to docs/reference/sdks/go.md
index eb5f703807..64f92d0766 100644
--- a/docs/dev/reference/sdks/go.md
+++ b/docs/reference/sdks/go.md
@@ -8,5 +8,6 @@ icon: true
 images: ["/logos/golang.svg"]
 canonical: "https://pkg.go.dev/go.viam.com/rdk"
 aliases:
+  - /dev/reference/sdks/go/
   - /sdks/go/
 ---
diff --git a/docs/dev/reference/sdks/python/_index.md b/docs/reference/sdks/python/_index.md
similarity index 85%
rename from docs/dev/reference/sdks/python/_index.md
rename to docs/reference/sdks/python/_index.md
index f3444d0051..73fbb05404 100644
--- a/docs/dev/reference/sdks/python/_index.md
+++ b/docs/reference/sdks/python/_index.md
@@ -8,5 +8,6 @@ icon: true
 images: ["/logos/python.svg"]
 canonical: "https://python.viam.dev/"
 aliases:
+  - /dev/reference/sdks/python/
   - /sdks/python/
 ---
diff --git a/docs/dev/reference/sdks/python/python-venv.md b/docs/reference/sdks/python/python-venv.md
similarity index 95%
rename from docs/dev/reference/sdks/python/python-venv.md
rename to docs/reference/sdks/python/python-venv.md
index f317ce7675..557ba43529 100644
--- a/docs/dev/reference/sdks/python/python-venv.md
+++ b/docs/reference/sdks/python/python-venv.md
@@ -8,6 +8,7 @@ images: ["/services/icons/sdk.svg"]
 tags:
   ["client", "sdk", "application", "sdk", "fleet", "program", "python", "venv"]
 aliases:
+  - /dev/reference/sdks/python/python-venv/
   - /program/python-venv/
   - /sdks/python/python-venv/
 date: "2022-01-01"
@@ -68,7 +69,7 @@ pip3 install viam-sdk
 
 This installs the Viam Python SDK and all required general dependencies.
 
-If you intend to use the [ML (machine learning) model service](/data-ai/ai/deploy/), install the Python SDK using the `mlmodel` extra:
+If you intend to use the [ML (machine learning) model service](/vision/configure/), install the Python SDK using the `mlmodel` extra:
 
 ```sh {class="command-line" data-prompt="$"}
 pip3 install 'viam-sdk[mlmodel]'
@@ -101,4 +102,4 @@ Your IDE will now recognize all packages installed in this environment.
 
 ## Start building
 
-You are now ready to [start using Viam's Python SDK](/dev/reference/sdks/)!
+You are now ready to [start using Viam's Python SDK](/reference/sdks/)!
diff --git a/docs/dev/reference/sdks/typescript.md b/docs/reference/sdks/typescript.md
similarity index 84%
rename from docs/dev/reference/sdks/typescript.md
rename to docs/reference/sdks/typescript.md
index fc7941350d..ad4e0bb1ed 100644
--- a/docs/dev/reference/sdks/typescript.md
+++ b/docs/reference/sdks/typescript.md
@@ -8,5 +8,6 @@ icon: true
 images: ["/logos/typescript.svg"]
 canonical: "https://ts.viam.dev/"
 aliases:
+  - /dev/reference/sdks/typescript/
   - /sdks/typescript/
 ---
diff --git a/docs/dev/reference/sdks/use-extra-params.md b/docs/reference/sdks/use-extra-params.md
similarity index 87%
rename from docs/dev/reference/sdks/use-extra-params.md
rename to docs/reference/sdks/use-extra-params.md
index a077a30b79..b5d3333cae 100644
--- a/docs/dev/reference/sdks/use-extra-params.md
+++ b/docs/reference/sdks/use-extra-params.md
@@ -7,6 +7,7 @@ description: "Using the extra parameter on resource API methods with Viam's SDKs
 images: ["/services/icons/sdk.svg"]
 tags: ["sdk", "extra", "extend"]
 aliases:
+  - /dev/reference/sdks/use-extra-params/
   - /program/sdks/use-extra-params
   - /program/use-extra-params/
   - /sdks/use-extra-params/
@@ -14,16 +15,16 @@ date: "2022-01-01"
 # updated: ""  # When the content was last entirely checked
 ---
 
-How to [use](#use) and [define](#define) the `extra` parameters that many {{< glossary_tooltip term_id="resource" text="resource" >}} [API methods](/dev/reference/apis/) offer in the Go and Python SDKs.
+How to [use](#use) and [define](#define) the `extra` parameters that many {{< glossary_tooltip term_id="resource" text="resource" >}} [API methods](/reference/apis/) offer in the Go and Python SDKs.
 
 ## Use
 
 You can use `extra` parameters with modular {{< glossary_tooltip term_id="resource" text="resource" >}} implementations that are _models_ of built-in resource types.
 
-For example, a new model of [sensor](/operate/reference/components/sensor/), or a new model of {{< glossary_tooltip term_id="slam" text="SLAM" >}} service.
+For example, a new model of [sensor](/hardware/common-components/add-a-sensor/), or a new model of {{< glossary_tooltip term_id="slam" text="SLAM" >}} service.
 
-The `extra` parameters in that built-in resource type's [API](/dev/reference/apis/) allow users to pass information to a resource's driver that isn't specified as a parameter for all models of the resource type.
-This is necessary to keep the API of resource types consistent across, for example, all models of [motor](/operate/reference/components/motor/) or all models of [camera](/operate/reference/components/camera/).
+The `extra` parameters in that built-in resource type's [API](/reference/apis/) allow users to pass information to a resource's driver that isn't specified as a parameter for all models of the resource type.
+This is necessary to keep the API of resource types consistent across, for example, all models of [motor](/hardware/common-components/add-a-motor/) or all models of [camera](/hardware/common-components/add-a-camera/).
 
 Send extra information in an API call in `extra` parameters as follows:
 
@@ -97,7 +98,7 @@ If `extra` information must be passed to a resource, it is handled within a new,
 To do this, define a custom implementation of the resource's API as a new _model_, and modify the resource's API methods to handle the `extra` information you send.
 Follow the steps in the [Modular Resources documentation](/operate/modules/write-a-driver-module/) to do so.
 
-For an example of how to check the values of keys in an `extra` parameter of a built-in resource [API method](/dev/reference/apis/), reference this modification to the built-in [sensor](/operate/reference/components/sensor/) resource type's [Readings](/dev/reference/apis/components/sensor/#getreadings) method in the code of a new sensor model:
+For an example of how to check the values of keys in an `extra` parameter of a built-in resource [API method](/reference/apis/), reference this modification to the built-in [sensor](/hardware/common-components/add-a-sensor/) resource type's [Readings](/reference/apis/components/sensor/#getreadings) method in the code of a new sensor model:
 
 {{< tabs >}}
 {{% tab name="Python" %}}
diff --git a/docs/data-ai/reference/triggers-configuration.md b/docs/reference/triggers.md
similarity index 84%
rename from docs/data-ai/reference/triggers-configuration.md
rename to docs/reference/triggers.md
index b0bd2867f7..55bc964c5d 100644
--- a/docs/data-ai/reference/triggers-configuration.md
+++ b/docs/reference/triggers.md
@@ -7,14 +7,17 @@ tags: ["data management", "trigger", "webhook"]
 description: "Detailed information about how to configure triggers and webhooks."
 date: "2025-05-05"
 updated: "2025-09-18"
+aliases:
+  - /data-ai/reference/triggers-configuration/
+  - /reference/configuration/triggers/
 ---
 
 Triggers can alert you by email or webhook when any of the following events occur:
 
-- [machine telemetry data syncs from your local device to the Viam cloud](/manage/troubleshoot/alert/)
-- [data syncs from a machine](/data-ai/data/alert-data/)
-- [service detects a specified object or classifies a specified label](/data-ai/ai/alert/)
-- [machine logs contain errors, warnings, or info logs](/manage/troubleshoot/alert/)
+- [Machine telemetry data syncs from your local device to the Viam cloud](/monitor/alert/)
+- [Data syncs from a machine](/data/trigger-on-data/)
+- [A vision service detects a specified object or classifies a specified label](/vision/alert-on-detections/)
+- [Machine logs contain errors, warnings, or info logs](/monitor/alert/)
 
 This page provides a reference for the Trigger attributes.
 For step-by-step configuration information, see the preceding links instead.
@@ -133,8 +136,8 @@ Triggers support the following attributes:
 | Name | Type | Required? | Description |
 | ---- | ---- | --------- | ----------- |
 | `name` | string | **Required** | The name of the trigger |
-| `event` |  object | **Required** | The trigger event object, which contains the following fields: <ul><li>`type`: The type of the event to trigger on. Options: <ul><li>`part_data_ingested`: fire when data syncs</li> <li>`conditional_data_ingested`: fire when data that meets a certain condition syncs</li> <li>`part_online`: fire when the part is online</li> <li>`part_offline`: fire when the part is offline</li> <li>`conditional_logs_ingested`: check every hour and fire if logs of the specified log level are present</li></ul></li><li>`data_types`: Required with `type` `part_data_ingested`. An array of data types that trigger the event. Options: `binary`, `tabular`, `file`, `unspecified`. </li><li> `conditional`: Required when `type` is `conditional_data_ingested`. For more information about this field, see [Conditional attributes](/data-ai/reference/triggers-configuration/#conditional-attributes). </li><li> `log_levels`: Required when `type` is `conditional_logs_ingested`. An array of log levels. Options: `error`, `warn`, `info`. </li></ul> |
-| `notifications` |  object | **Required** | The notifications object, which contains the following fields: <ul><li>`type`: The type of the notification. Options: `webhook`, `email`</li><li>`value`: The URL to send the request to, the email address to notify, or `all_machine_ownders` to notify all machine owners.</li><li>`seconds_between_notifications`: The interval between notifications in seconds. This field is ignored for event type `conditional_logs_ingested` where the interval is always one hour.</li></ul> For more information on webhooks, see [Webhook attributes](#webhook-attributes). |
+| `event` | object | **Required** | The trigger event object, which contains the following fields: <ul><li>`type`: The type of the event to trigger on. Options: <ul><li>`part_data_ingested`: fire when data syncs</li> <li>`conditional_data_ingested`: fire when data that meets a certain condition syncs</li> <li>`part_online`: fire when the part is online</li> <li>`part_offline`: fire when the part is offline</li> <li>`conditional_logs_ingested`: check every hour and fire if logs of the specified log level are present</li></ul></li><li>`data_types`: Required with `type` `part_data_ingested`. An array of data types that trigger the event. Options: `binary`, `tabular`, `file`, `unspecified`. </li><li> `conditional`: Required when `type` is `conditional_data_ingested`. For more information about this field, see [Conditional attributes](/reference/triggers/#conditional-attributes). </li><li> `log_levels`: Required when `type` is `conditional_logs_ingested`. An array of log levels. Options: `error`, `warn`, `info`. </li></ul> |
+| `notifications` | object | **Required** | The notifications object, which contains the following fields: <ul><li>`type`: The type of the notification. Options: `webhook`, `email`</li><li>`value`: The URL to send the request to, the email address to notify, or `all_machine_owners` to notify all machine owners.</li><li>`seconds_between_notifications`: The interval between notifications in seconds. This field is ignored for event type `conditional_logs_ingested` where the interval is always one hour.</li></ul> For more information on webhooks, see [Webhook attributes](#webhook-attributes). |
 | `notes` | string | Optional | Descriptive text to document the purpose, configuration details, or other important information about this trigger. |
 
 ## Conditional attributes
@@ -377,5 +380,5 @@ If the HTTP request Viam sends results in an error, you can see this error logge
 For example:
 
 ```txt
-9/18/2025, 12:52:59 PM error app.trigger.trigger-1     Trigger failed to notify https://testurl.com for robotPartId abc1234d-1a23-1a23-123a-1abc23d45e67. Component: N/A, Method: N/A, TriggerType: part_online, NotificationType: webhook, Error: received unretryable status code: 404 in webhook response, ResponseCode: 404
+9/18/2025, 12:52:59 PM error app.trigger.trigger-1     Trigger failed to notify https://testurl.com for robotPartId abc1234d-1a23-1a23-123a-1abc23d45e67. Component: N/A, Method: N/A, TriggerType: part_online, NotificationType: webhook, Error: received unretryable status code: 404 in webhook response, ResponseCode: 404
 ```
diff --git a/docs/train/_index.md b/docs/train/_index.md
new file mode 100644
index 0000000000..ad979b6a73
--- /dev/null
+++ b/docs/train/_index.md
@@ -0,0 +1,12 @@
+---
+linkTitle: "Train ML models"
+title: "Train ML models"
+weight: 50
+layout: "docs"
+type: "docs"
+no_list: true
+manualLink: "/train/overview/"
+description: "Create datasets and train ML models from captured data."
+aliases:
+  - /build/train/
+---
diff --git a/docs/train/annotate-images.md b/docs/train/annotate-images.md
new file mode 100644
index 0000000000..8b92a57eec
--- /dev/null
+++ b/docs/train/annotate-images.md
@@ -0,0 +1,175 @@
+---
+linkTitle: "Annotate images"
+title: "Annotate images"
+weight: 15
+layout: "docs"
+type: "docs"
+description: "Label images with tags or bounding boxes for training an ML model."
+date: "2025-01-30"
+---
+
+Label your dataset images with tags for classification or bounding boxes for
+object detection. You need a [dataset with images](/train/create-a-dataset/)
+before you can annotate.
+
+## Tag images for classification
+
+Tags are labels that apply to an entire image. Use them when you are building
+a classification model -- for example, labeling images as "good-part" or
+"defective-part".
+
+**Web UI:**
+
+1. In the **DATA** tab, click an image to open it in the detail view.
+2. On the right side panel, find the **Tags** section.
+3. Click the **+** button next to **Tags**.
+4. Type a tag name (for example, `good-part`) and press Enter.
+5. The tag is saved immediately. Repeat for each image.
+
+To tag multiple images at once, use the SDK to add tags programmatically (see
+the code example below).
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+async def main():
+    viam_client = await connect()
+    data_client = viam_client.data_client
+
+    binary_data_ids = ["binary-data-id-1", "binary-data-id-2"]
+
+    await data_client.add_tags_to_binary_data_by_ids(
+        tags=["good-part"],
+        binary_ids=binary_data_ids,
+    )
+    print("Tags added.")
+
+    viam_client.close()
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+binaryIDs := []string{"binary-data-id-1", "binary-data-id-2"}
+
+err = dataClient.AddTagsToBinaryDataByIDs(
+    ctx,
+    []string{"good-part"},
+    binaryIDs,
+)
+if err != nil {
+    logger.Fatal(err)
+}
+fmt.Println("Tags added.")
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+You can get binary data IDs by querying for images using the data client's
+`binary_data_by_filter` method, which returns objects that include the binary
+data ID.
+
+Choose tag names that are clear, consistent, and descriptive. Use lowercase with
+hyphens (for example, `good-part`, `defective-part`, `no-part`). Avoid vague names like
+`type1` or `other`.
+
+## Draw bounding boxes for object detection
+
+Bounding boxes mark the location of specific objects within an image. Use them
+when you are building an object detection model -- for example, detecting
+packages on a conveyor belt.
+
+**Web UI:**
+
+1. Open your dataset and click an image to open the detail view.
+2. In the side panel, click the **Actions** tab.
+3. Click **Annotate** to enter annotation mode.
+4. Select or create a label (for example, `package`).
+5. Hold **Cmd** (macOS) or **Ctrl** (Windows/Linux) and click-and-drag on the
+   image to draw a rectangle around the object.
+6. The bounding box appears with your selected label. Adjust the box edges by
+   dragging them if needed.
+7. Repeat for every object in the image that should be detected.
+8. Move to the next image and repeat.
+
+Draw tight bounding boxes that closely fit the object. Do not include excessive
+background. If an image contains multiple objects, draw a separate bounding box
+for each one.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+async def main():
+    viam_client = await connect()
+    data_client = viam_client.data_client
+
+    bbox_id = await data_client.add_bounding_box_to_image_by_id(
+        binary_id="binary-data-id-1",
+        label="package",
+        x_min_normalized=0.15,
+        y_min_normalized=0.20,
+        x_max_normalized=0.85,
+        y_max_normalized=0.90,
+    )
+    print(f"Added bounding box: {bbox_id}")
+
+    viam_client.close()
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+bboxID, err := dataClient.AddBoundingBoxToImageByID(
+    ctx,
+    "binary-data-id-1",
+    "package",
+    0.15, // x_min_normalized
+    0.20, // y_min_normalized
+    0.85, // x_max_normalized
+    0.90, // y_max_normalized
+)
+if err != nil {
+    logger.Fatal(err)
+}
+fmt.Printf("Added bounding box: %s\n", bboxID)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Coordinates are normalized 0.0-1.0, where (0.0, 0.0) is the top-left corner
+and (1.0, 1.0) is the bottom-right corner.
+
+## Troubleshooting
+
+{{< expand "Bounding boxes not saving" >}}
+
+- **Annotation mode not active.** You must click the **Annotate** button before
+  drawing boxes. Without annotation mode, click-and-drag does nothing.
+- **No label selected.** You must select or create a label before drawing a
+  bounding box. If no label is selected, the box will not persist.
+- **Box too small.** Very small bounding boxes (a few pixels) may not register.
+  Draw boxes that clearly encompass the object.
+
+{{< /expand >}}
+
+{{< expand "Tags applied to wrong images" >}}
+
+- **Remove incorrect tags.** In the web UI, click the image, find the tag in
+  the Tags section, and click the **x** next to it to remove it.
+- **Programmatically remove tags.** Use `remove_tags_from_binary_data_by_ids`
+  in the SDK to remove tags from specific images.
+
+{{< /expand >}}
+
+## What's next
+
+- [Automate annotation](/train/automate-annotation/) -- speed up labeling by
+  using an existing ML model to generate predictions automatically.
+- [Train a model](/train/train-a-model/) -- use your labeled dataset to
+  train a classification or object detection model.
diff --git a/docs/train/automate-annotation.md b/docs/train/automate-annotation.md
new file mode 100644
index 0000000000..444be5b6a2
--- /dev/null
+++ b/docs/train/automate-annotation.md
@@ -0,0 +1,109 @@
+---
+linkTitle: "Automate annotation"
+title: "Automate annotation"
+weight: 17
+layout: "docs"
+type: "docs"
+description: "Use ML models to auto-label images and programmatically build annotated datasets."
+date: "2025-01-30"
+---
+
+Manually labeling hundreds of images is slow. If you already have a trained ML
+model -- even a rough first version -- you can use it to generate label
+predictions automatically. You review and correct the predictions instead of
+labeling from scratch.
+
+You can also use the SDKs to annotate images programmatically, or combine
+capture, annotation, and dataset management into a single script for continuous
+dataset improvement.
+
+## Auto-predict labels
+
+Use an existing ML model to generate predictions for images in a dataset,
+then review each prediction. This works with both classification models
+(which generate tags) and object detection models (which generate bounding boxes).
+
+1. Navigate to your [dataset's page](https://app.viam.com/datasets/).
+1. Click **Get auto-predictions**.
+1. **Select** a model to generate predictions with.
+1. Set the **confidence threshold** above which to create a label prediction.
+1. Click **Get predictions**.
+1. Once predictions have finished generating, click **Review predictions**.
+1. For each image, **Accept (A)** or **Reject (R)** each prediction.
+
+## Programmatic tagging with SDKs
+
+Use an ML model to generate tags for images, then pass the tags and image IDs
+to the data client API.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+{{< read-code-snippet file="/static/include/examples-generated/tag-images.snippet.tag-images.py" lang="python" class="line-numbers linkable-line-numbers" data-line="" >}}
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+{{< read-code-snippet file="/static/include/examples-generated/tag-images.snippet.tag-images.go" lang="go" class="line-numbers linkable-line-numbers" data-line="" >}}
+
+{{% /tab %}}
+{{% tab name="TypeScript" %}}
+
+{{< read-code-snippet file="/static/include/examples-generated/tag-images.snippet.tag-images.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="" >}}
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Programmatic bounding boxes with SDKs
+
+Use an ML model to generate bounding boxes for images, then pass each bounding
+box and image ID to the data client API.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+{{< read-code-snippet file="/static/include/examples-generated/label-images.snippet.label-images.py" lang="python" class="line-numbers linkable-line-numbers" data-line="" >}}
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+{{< read-code-snippet file="/static/include/examples-generated/label-images.snippet.label-images.go" lang="go" class="line-numbers linkable-line-numbers" data-line="" >}}
+
+{{% /tab %}}
+{{% tab name="TypeScript" %}}
+
+{{< read-code-snippet file="/static/include/examples-generated/label-images.snippet.label-images.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="" >}}
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Capture, annotate, and add to dataset in one script
+
+The following example captures an image, uses an ML model to generate
+annotations, and adds the image to a dataset -- all in a single script. Use
+this pattern to expand and improve your datasets continuously over time.
+Check annotation accuracy in the **DATA** tab, then retrain your ML model on
+the improved dataset.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+{{< read-code-snippet file="/static/include/examples-generated/capture-annotate-dataset.snippet.capture-annotate-dataset.py" lang="python" class="line-numbers linkable-line-numbers" data-line="" >}}
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+{{< read-code-snippet file="/static/include/examples-generated/capture-annotate-dataset.snippet.capture-annotate-dataset.go" lang="go" class="line-numbers linkable-line-numbers" data-line="" >}}
+
+{{% /tab %}}
+{{% tab name="TypeScript" %}}
+
+{{< read-code-snippet file="/static/include/examples-generated/capture-annotate-dataset.snippet.capture-annotate-dataset.ts" lang="ts" class="line-numbers linkable-line-numbers" data-line="" >}}
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## What's next
+
+- [Train a model](/train/train-a-model/) -- use your labeled dataset to
+  train a classification or object detection model.
diff --git a/docs/train/create-a-dataset.md b/docs/train/create-a-dataset.md
new file mode 100644
index 0000000000..f17ea06989
--- /dev/null
+++ b/docs/train/create-a-dataset.md
@@ -0,0 +1,328 @@
+---
+linkTitle: "Create a dataset"
+title: "Create a dataset"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Create a dataset of images for training an ML model."
+date: "2025-01-30"
+aliases:
+  - /build/train/create-a-dataset/
+---
+
+A dataset is a named collection of images at the organization level that you
+label and use for training. Before training, your dataset must meet these
+minimums:
+
+| Requirement        | Minimum                |
+| ------------------ | ---------------------- |
+| Total images       | 15                     |
+| Labeled images     | 80% of total           |
+| Examples per label | 10                     |
+| Label distribution | Roughly equal          |
+| Image source       | Production environment |
+
+For production use, aim for hundreds of images per label under varied
+conditions.
+
+## 1. Create a dataset
+
+You can create a dataset from the web UI, the CLI, or programmatically.
+
+**Web UI:**
+
+1. Go to [app.viam.com](https://app.viam.com).
+2. Click the **DATA** tab in the top navigation.
+3. Click the **DATASETS** subtab.
+4. Click **+ Create dataset**.
+5. Enter a descriptive name for your dataset. Use a name that reflects the task,
+   such as `inspection-parts-v1` or `package-detection`. Dataset names must be
+   unique within your organization.
+6. Click **Create**.
+
+Your empty dataset now appears in the list.
+
+**CLI:**
+
+If you have the Viam CLI installed, create a dataset from the command line:
+
+```bash
+viam dataset create --org-id=YOUR-ORG-ID --name=my-inspection-dataset
+```
+
+The command returns the dataset ID, which you will need for subsequent CLI and
+SDK operations.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+import asyncio
+from viam.rpc.dial import DialOptions
+from viam.app.viam_client import ViamClient
+
+
+API_KEY = "YOUR-API-KEY"
+API_KEY_ID = "YOUR-API-KEY-ID"
+ORG_ID = "YOUR-ORGANIZATION-ID"
+
+
+async def connect() -> ViamClient:
+    dial_options = DialOptions.with_api_key(API_KEY, API_KEY_ID)
+    return await ViamClient.create_from_dial_options(dial_options)
+
+
+async def main():
+    viam_client = await connect()
+    data_client = viam_client.data_client
+
+    dataset_id = await data_client.create_dataset(
+        name="my-inspection-dataset",
+        organization_id=ORG_ID,
+    )
+    print(f"Created dataset: {dataset_id}")
+
+    viam_client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/app"
+    "go.viam.com/rdk/logging"
+)
+
+func main() {
+    apiKey := "YOUR-API-KEY"
+    apiKeyID := "YOUR-API-KEY-ID"
+    orgID := "YOUR-ORGANIZATION-ID"
+
+    ctx := context.Background()
+    logger := logging.NewDebugLogger("create-dataset")
+
+    viamClient, err := app.CreateViamClientWithAPIKey(
+        ctx, app.Options{}, apiKey, apiKeyID, logger)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer viamClient.Close()
+
+    dataClient := viamClient.DataClient()
+
+    datasetID, err := dataClient.CreateDataset(
+        ctx, "my-inspection-dataset", orgID)
+    if err != nil {
+        logger.Fatal(err)
+    }
+    fmt.Printf("Created dataset: %s\n", datasetID)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Replace all placeholder values (`YOUR-API-KEY`, `YOUR-API-KEY-ID`,
+`YOUR-ORGANIZATION-ID`) with your actual values. To find your organization ID,
+click your organization name in the top navigation bar, then click **Settings**.
+Your organization ID is displayed on the settings page with a copy button.
+
+## 2. Add images to the dataset
+
+With a dataset created, you need to populate it with images.
+
+**Web UI:**
+
+1. Click the **DATA** tab in the top navigation.
+2. Use the filters to find the images you want. Filter by machine, component,
+   time range, or tags.
+3. Select individual images by clicking their checkboxes, or use **Select all**
+   to select all visible images.
+4. Click **Add to dataset** in the action bar that appears.
+5. Select your dataset from the dropdown.
+6. Click **Add**.
+
+The selected images are now part of your dataset.
+
+**CLI:**
+
+Add images to a dataset using filter criteria:
+
+```bash
+viam dataset data add filter \
+  --dataset-id=YOUR-DATASET-ID \
+  --location-id=YOUR-LOCATION-ID \
+  --tags=label1,label2
+```
+
+This adds all images matching the filter to the dataset. You can filter by
+location, machine, component, tags, or time range.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+async def main():
+    viam_client = await connect()
+    data_client = viam_client.data_client
+
+    await data_client.add_binary_data_to_dataset_by_ids(
+        binary_ids=["binary-data-id-1", "binary-data-id-2"],
+        dataset_id="YOUR-DATASET-ID",
+    )
+    print("Images added to dataset.")
+
+    viam_client.close()
+```
+
+You can get binary data IDs by querying for images first using the data client's
+`binary_data_by_filter` method, which returns objects that include the binary ID.
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+err = dataClient.AddBinaryDataToDatasetByIDs(
+    ctx,
+    []string{"binary-data-id-1", "binary-data-id-2"},
+    "YOUR-DATASET-ID",
+)
+if err != nil {
+    logger.Fatal(err)
+}
+fmt.Println("Images added to dataset.")
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## 3. Annotate your images
+
+Before training, you need to label every image in your dataset with tags
+(for classification) or bounding boxes (for object detection).
+
+See [Annotate images](/train/annotate-images/) for step-by-step instructions
+on manual labeling, or [Automate annotation](/train/automate-annotation/) to
+use an existing ML model to speed up the process.
+
+## 4. Verify dataset quality
+
+Before you train a model, check that your dataset meets the requirements.
+
+**In the web UI:**
+
+1. Go to the **DATA** tab and click the **DATASETS** subtab.
+2. Click your dataset to open it.
+3. Review the dataset summary, which shows:
+   - Total number of images
+   - Number of labeled images
+   - Labels used and their counts
+4. Check each requirement:
+
+| Check                 | What to look for                                                              |
+| --------------------- | ----------------------------------------------------------------------------- |
+| Enough images         | At least 15 total. More is better.                                            |
+| Labeling coverage     | At least 80% of images have tags or bounding boxes                            |
+| Examples per label    | At least 10 images per label                                                  |
+| Label balance         | No label should have more than 3x the images of any other label               |
+| Production conditions | Images should represent real operating conditions, not staged or ideal setups |
+
+**Common issues to fix before training:**
+
+- **Too few images in one class:** Capture more images of the underrepresented
+  class, or remove the class and merge it with a related one.
+- **Unlabeled images:** Either label them or remove them from the dataset.
+  Unlabeled images do not help training and can confuse the summary statistics.
+- **Non-representative images:** If your model will run on a factory floor but
+  your training images were taken on a clean desk, the model will not generalize.
+  Capture images under production conditions -- with the actual lighting,
+  background, camera angle, and distance your machine uses.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+async def main():
+    viam_client = await connect()
+    data_client = viam_client.data_client
+
+    datasets = await data_client.list_datasets_by_organization_id(
+        organization_id=ORG_ID,
+    )
+    for ds in datasets:
+        print(f"Dataset: {ds.name}, ID: {ds.id}")
+
+    viam_client.close()
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+datasets, err := dataClient.ListDatasetsByOrganizationID(ctx, orgID)
+if err != nil {
+    logger.Fatal(err)
+}
+for _, ds := range datasets {
+    fmt.Printf("Dataset: %s, ID: %s\n", ds.Name, ds.ID)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "Dataset creation fails" >}}
+
+- **Name already exists.** Dataset names must be unique within your organization.
+  Choose a different name or delete the existing dataset if it is no longer
+  needed.
+- **Permission denied.** Verify that your API key has organization-level access.
+  API keys scoped to a single machine or location cannot create datasets.
+
+{{< /expand >}}
+
+{{< expand "Images not appearing in the dataset" >}}
+
+- **Sync delay.** Images must sync from the machine to the cloud before they
+  are available to add to a dataset. Wait a minute and check the **DATA** tab
+  to confirm images have arrived.
+- **Wrong filter.** If using the CLI `add filter` command, double-check your
+  filter criteria. A typo in a tag name or location ID will match zero images
+  without an error.
+- **Binary ID mismatch.** If adding images programmatically by ID, verify that
+  the binary IDs are correct. You can retrieve valid IDs using the
+  `binary_data_by_filter` method.
+
+{{< /expand >}}
+
+{{< expand "Label imbalance warnings" >}}
+
+- **Collect more data for underrepresented labels.** The most effective fix is
+  to capture more images of the minority class under varied conditions.
+- **Do not duplicate images.** Adding copies of the same image inflates the
+  count without adding information. The model needs diverse examples.
+- **Consider merging labels.** If two labels are very similar and one has few
+  examples, merge them into a single label.
+
+{{< /expand >}}
+
+## What's next
+
+- [Annotate images](/train/annotate-images/) -- label your images with tags
+  or bounding boxes for training.
+- [Automate annotation](/train/automate-annotation/) -- use an existing ML
+  model to auto-label images instead of doing it by hand.
+- [Train a model](/train/train-a-model/) -- use your labeled dataset to
+  train a classification or object detection model.
diff --git a/docs/train/custom-training-scripts.md b/docs/train/custom-training-scripts.md
new file mode 100644
index 0000000000..667b562d0f
--- /dev/null
+++ b/docs/train/custom-training-scripts.md
@@ -0,0 +1,317 @@
+---
+linkTitle: "Custom training scripts"
+title: "Custom training scripts"
+tags: ["data management", "ml", "model training"]
+weight: 30
+layout: "docs"
+type: "docs"
+languages: ["python"]
+viamresources: ["mlmodel", "data_manager"]
+platformarea: ["ml"]
+description: "Use or write custom training scripts to train ML models on the Viam platform with any framework or logic."
+date: "2024-12-04"
+updated: "2025-10-13"
+---
+
+Viam's [managed training](/train/train-a-model/) handles TensorFlow and TFLite classification and detection out of the box.
+For anything else, you can use a custom training script: a different framework, custom preprocessing, non-image data, or a training pipeline you want to share with your organization.
+
+Before writing your own, check the [registry](https://app.viam.com/registry?type=Training+Script) for existing training scripts and [pre-trained models](https://app.viam.com/registry?type=ML+Model) you can deploy directly.
+If a training script there fits your needs, skip ahead to [Submit a training job](#submit-a-training-job).
+
+## Write a training script
+
+A training script is a Python project that the Viam platform runs in the cloud.
+The platform provides your script with a dataset and an output directory; your script produces a trained model.
+
+### File structure
+
+```treeview
+my-training/
+├── model/
+│   ├── training.py
+│   └── __init__.py
+└── setup.py
+```
+
+`setup.py` declares your dependencies:
+
+```python {class="line-numbers linkable-line-numbers"}
+from setuptools import find_packages, setup
+
+setup(
+    name="my-training",
+    version="0.1",
+    packages=find_packages(),
+    include_package_data=True,
+    install_requires=[
+        # Add your dependencies here, for example:
+        # "tensorflow>=2.11",
+        # "numpy",
+    ],
+)
+```
+
+### training.py
+
+Your script receives two required command-line arguments from the platform:
+
+| Argument                   | Description                                                                                           |
+| -------------------------- | ----------------------------------------------------------------------------------------------------- |
+| `--dataset_file`           | Path to a JSONLines file containing dataset metadata: file paths and annotations for each data point. |
+| `--model_output_directory` | Directory where your script must save its model artifacts.                                            |
+
+You can add custom arguments (like `--num_epochs` or `--labels`) and pass them when you submit the training job.
+
+Here is the overall shape of a training script:
+
+```python {class="line-numbers linkable-line-numbers"}
+import argparse
+import json
+import os
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--dataset_file", dest="data_json",
+                        type=str, required=True)
+    parser.add_argument("--model_output_directory", dest="model_dir",
+                        type=str, required=True)
+    # Add custom arguments as needed:
+    parser.add_argument("--num_epochs", dest="num_epochs",
+                        type=int, default=200)
+    return parser.parse_args()
+
+
+def load_dataset(data_json):
+    """Parse the JSONLines dataset file."""
+    entries = []
+    with open(data_json, "r") as f:
+        for line in f:
+            entries.append(json.loads(line))
+    return entries
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    dataset = load_dataset(args.data_json)
+
+    # --- Your training logic goes here ---
+    # Use the dataset entries to train a model with
+    # whatever framework fits your use case.
+    model = ...
+    labels = ...
+
+    # Save model artifacts to the output directory.
+    # The format must match what your ML model service expects.
+    # For example, tflite_cpu expects a .tflite file and labels.txt.
+    with open(os.path.join(args.model_dir, "model.tflite"), "wb") as f:
+        f.write(model)
+    with open(os.path.join(args.model_dir, "labels.txt"), "w") as f:
+        f.write("\n".join(labels))
+```
+
+The critical parts:
+
+- **Parse arguments**: Accept `--dataset_file` and `--model_output_directory` at minimum.
+- **Read the dataset**: Each line in the JSONLines file is a JSON object. For image datasets, each object has an `image_path` and either `classification_annotations`, `bounding_box_annotations`, or both. Non-image datasets will have a different structure depending on how the data was captured.
+- **Save to the output directory**: When the job completes, Viam packages everything in this directory and publishes it to the registry as a new model version. Files in a `tmp/` subdirectory are excluded: use it for intermediate work.
+
+If the script exits with a non-zero status or produces no files in the output directory, the training job is marked as failed.
+
+### Dataset file format
+
+Each line of the dataset file is a JSON object like this:
+
+```json
+{
+  "image_path": "/path/to/data/img1.jpeg",
+  "classification_annotations": [{ "annotation_label": "blue_star" }],
+  "bounding_box_annotations": [
+    {
+      "annotation_label": "blue_star",
+      "x_min_normalized": 0.382,
+      "x_max_normalized": 0.51,
+      "y_min_normalized": 0.356,
+      "y_max_normalized": 0.527
+    }
+  ]
+}
+```
+
+Bounding box coordinates are normalized to the range 0.0-1.0 relative to image dimensions.
+For classification, read `classification_annotations`.
+For object detection, read `bounding_box_annotations`.
+See the [example training script](https://github.com/viam-modules/classification-tflite) for complete parsing functions that handle both annotation types.
+
+### Accessing Viam APIs
+
+The platform provides `API_KEY` and `API_KEY_ID` environment variables if your script needs to call [Viam APIs](/reference/apis/) during training, for example, to query additional data:
+
+```python
+import os
+from viam.rpc.dial import DialOptions
+from viam.app.viam_client import ViamClient
+
+
+async def connect() -> ViamClient:
+    dial_options = DialOptions.with_api_key(
+        os.environ.get("API_KEY"), os.environ.get("API_KEY_ID")
+    )
+    return await ViamClient.create_from_dial_options(dial_options)
+```
+
+### Complete example
+
+For a full working training script, see the [classification-tflite example](https://github.com/viam-modules/classification-tflite) on GitHub.
+It trains a TFLite single-label classification model using TensorFlow and Keras.
+
+## Test and upload
+
+Before submitting a cloud training job, test your script locally against an exported dataset.
+
+### Export a dataset
+
+```sh {class="command-line" data-prompt="$"}
+viam dataset export --destination=<destination> --dataset-id=<dataset-id>
+```
+
+This downloads the binary data files and a `dataset.jsonl` metadata file.
+To download only the JSONL file without binary data, add `--only-jsonl`.
+
+You can get the dataset ID from the [**DATASETS** tab](https://app.viam.com/data/datasets) or by running [`viam dataset list`](/cli/).
+
+### Test locally with Docker
+
+The `test-local` command runs your training script inside the same Docker container that cloud training uses.
+This catches problems that plain Python testing misses: missing system dependencies, Python version differences, and package conflicts.
+
+```sh {class="command-line" data-prompt="$"}
+viam training-script test-local \
+  --training-script-directory=my-training/ \
+  --dataset-file=dataset.jsonl \
+  --dataset-root=<destination> \
+  --model-output-directory=<output-dir>
+```
+
+The `--dataset-file` path is relative to `--dataset-root`.
+The command mounts your script, dataset, and output directories into the container.
+
+To match a specific cloud container version, use `--container-version`.
+Run `viam train containers list` to list available container versions with their framework versions and end-of-life dates.
+
+You can pass custom arguments with `--custom-args`:
+
+```sh {class="command-line" data-prompt="$"}
+viam training-script test-local \
+  --training-script-directory=my-training/ \
+  --dataset-file=dataset.jsonl \
+  --dataset-root=<destination> \
+  --model-output-directory=<output-dir> \
+  --custom-args=num_epochs=5,labels="label1 label2"
+```
+
+{{% alert title="Note" color="note" %}}
+The training containers are built for linux/x86_64 (amd64).
+On ARM systems like Apple Silicon Macs, Docker uses Rosetta 2 emulation automatically, which may be slower but ensures your script runs in the same environment as cloud training.
+{{% /alert %}}
+
+If you prefer a quick check without Docker, you can run your script directly:
+
+```sh {class="command-line" data-prompt="$"}
+python3 -m model.training --dataset_file=<path/to/dataset.jsonl> \
+    --model_output_directory=<output-dir>
+```
+
+### Package and upload
+
+```sh {class="command-line" data-prompt="$"}
+tar -czvf my-training.tar.gz my-training/
+viam training-script upload --path=my-training.tar.gz \
+  --org-id=<org-id> --script-name=my-training-script
+```
+
+You can also specify `--framework`, `--type`, `--visibility`, and `--description` when uploading.
+See the [CLI reference](/cli/) for the full list of flags.
+
+To find your organization ID, run `viam organization list`.
+
+After uploading, your script appears in the [registry](https://app.viam.com/registry?type=Training+Script).
+
+## Submit a training job
+
+Once a training script is in the registry, whether you uploaded it or are using someone else's, submit a training job to run it against a dataset.
+
+Every custom training job runs inside a container.
+You must select a container version that matches the framework your script requires (for example, a PyTorch container for a PyTorch script).
+To see the available containers with their framework versions and end-of-life dates, run:
+
+```sh {class="command-line" data-prompt="$"}
+viam train containers list
+```
+
+{{< tabs >}}
+{{% tab name="Web UI" %}}
+
+1. Go to your [**DATASETS**](https://app.viam.com/data/datasets) and select the dataset you want to train on.
+2. Click **Train model**.
+3. Select **Train on a custom training script** and follow the prompts.
+4. Select a **Container version** that matches the framework your training script uses.
+   The UI shows a warning if the selected container is approaching its end-of-life date.
+5. Optionally, add custom arguments as key-value pairs in the **Arguments** section.
+
+{{% /tab %}}
+{{% tab name="CLI" %}}
+
+Use [`viam train submit custom from-registry`](/cli/):
+
+```sh {class="command-line" data-prompt="$"}
+viam train submit custom from-registry --dataset-id=<dataset-id> \
+  --org-id=<org-id> --model-name=my-model \
+  --model-version=1 --version=1 \
+  --script-name=<namespace>:<script-name> \
+  --container-version=<container-version> \
+  --args=num_epochs=100,labels="'label1 label2'"
+```
+
+You can get the dataset ID from the [**DATASETS** tab](https://app.viam.com/data/datasets) or by running [`viam dataset list`](/cli/).
+
+{{% /tab %}}
+{{% tab name="API" %}}
+
+Use the [ML Training Client API](/reference/apis/ml-training-client/#submittrainingjob) to submit training jobs programmatically.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Monitor and debug
+
+{{< tabs >}}
+{{% tab name="Web UI" %}}
+
+In the Viam app, go to the **DATA** page, click the [**MODELS** tab](https://app.viam.com/models), and expand **Active Training**.
+Click a job ID to view its logs.
+
+{{% /tab %}}
+{{% tab name="CLI" %}}
+
+List training jobs:
+
+```sh {class="command-line" data-prompt="$"}
+viam train list --org-id=<org-id> --job-status=unspecified
+```
+
+View logs for a specific job:
+
+```sh {class="command-line" data-prompt="$"}
+viam train logs --job-id=<job-id>
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Training logs expire after 7 days.
+You will receive an email when your training job completes.
+
+If a job fails, check the logs first: the error message usually indicates the problem.
+Note that training scripts may emit log lines at the error level and still succeed; check the final job status rather than individual log lines.
diff --git a/docs/train/deploy-a-model.md b/docs/train/deploy-a-model.md
new file mode 100644
index 0000000000..4d6643a1cf
--- /dev/null
+++ b/docs/train/deploy-a-model.md
@@ -0,0 +1,154 @@
+---
+linkTitle: "Deploy a model"
+title: "Deploy a model to a machine"
+weight: 25
+layout: "docs"
+type: "docs"
+description: "Add an ML model service and vision service to run a trained model on your machine."
+---
+
+Configure your machine to load a trained model from the registry and apply it
+to live camera frames. You need an ML model service to load the model and a
+vision service to run it against camera input.
+
+{{< alert title="Tip" color="tip" >}}
+For the full guide to configuring vision services and cloud inference, see [Configure computer vision](/vision/configure/).
+{{< /alert >}}
+
+## 1. Add the ML model service
+
+1. Navigate to your machine's **CONFIGURE** tab.
+2. Click **+** and select **Configuration block**.
+3. Search for `tflite` and find the **tflite_cpu** block (by **viam**,
+   badge: **MLMODEL**).
+4. Click the block, then click **Add component**.
+5. Enter a name for the service (for example, `my-ml-model`) and click
+   **Add component**. The supporting `viam:tflite_cpu` module is installed
+   automatically.
+6. In the service configuration card, under **Deployment**, leave
+   **Deploy model on machine** selected.
+7. Click **Select model**. In the dialog, browse **My models** or
+   **Registry** to find your trained model.
+8. Select the model, choose a version (or leave it on **Latest**), and click
+   **Choose**. The model path and label path are set automatically.
+9. Click **Save** in the top right.
+
+## 2. Add the vision service
+
+1. Click **+** and select **Configuration block**.
+2. Search for `mlmodel` and find the **mlmodel** block (type: **VISION**,
+   built-in).
+3. Click the block, then click **Add component**.
+4. Enter a name for the service (for example, `my-detector`) and click
+   **Add component**.
+5. In the **ML Model** dropdown, select the ML model service you added in
+   step 1 (for example, `my-ml-model`).
+6. Optionally, select a **Default Camera** and adjust the
+   **Minimum confidence threshold** (default: 0.5).
+7. Click **Save**.
+
+## 3. Verify
+
+1. Navigate to the **CONTROL** tab.
+2. Find your vision service and click **Test**.
+3. Select a camera to run the model against.
+4. You should see live classifications or detections overlaid on the camera
+   feed.
+
+## Use the model in code
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.services.vision import VisionClient
+
+# Get the vision service (assumes you have a robot connection)
+vision = VisionClient.from_robot(robot, "my-detector")
+
+# For classification
+classifications = await vision.get_classifications(
+    image=my_image,
+    count=5,
+)
+for c in classifications:
+    print(f"  {c.class_name}: {c.confidence:.2f}")
+
+# For object detection
+detections = await vision.get_detections(image=my_image)
+for d in detections:
+    print(f"  {d.class_name}: {d.confidence:.2f} "
+          f"at ({d.x_min}, {d.y_min}) to ({d.x_max}, {d.y_max})")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+import "go.viam.com/rdk/services/vision"
+
+// Get the vision service (assumes you have a robot connection)
+visionSvc, err := vision.FromProvider(robot, "my-detector")
+if err != nil {
+    logger.Fatal(err)
+}
+
+// For classification
+classifications, err := visionSvc.Classifications(ctx, myImage, 5, nil)
+if err != nil {
+    logger.Fatal(err)
+}
+for _, c := range classifications {
+    fmt.Printf("  %s: %.2f\n", c.Label(), c.Score())
+}
+
+// For object detection
+detections, err := visionSvc.Detections(ctx, myImage, nil)
+if err != nil {
+    logger.Fatal(err)
+}
+for _, d := range detections {
+    box := d.BoundingBox()
+    fmt.Printf("  %s: %.2f at (%d, %d) to (%d, %d)\n",
+        d.Label(), d.Score(),
+        box.Min.X, box.Min.Y, box.Max.X, box.Max.Y)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "Model not appearing on the machine" >}}
+
+- **Check the ML model service configuration.** Open the service card in the
+  **CONFIGURE** tab and verify a model is selected. If you see the
+  **Select model** button, no model has been chosen yet.
+- **Restart viam-server.** In some cases, the machine may need to restart to
+  pick up a new model version.
+- **Check machine connectivity.** The machine must be online and connected to
+  the cloud to download model updates.
+
+{{< /expand >}}
+
+{{< expand "Vision service returns no results" >}}
+
+- **Check the ML Model dropdown.** The vision service's **ML Model** dropdown
+  must reference your ML model service by name. If it shows
+  **No models available**, add an ML model service first.
+- **Check the camera.** Verify that the camera is working in the **CONTROL** tab
+  before testing the vision service.
+- **Lower the confidence threshold.** The model may be producing results below
+  your current threshold. Adjust the **Minimum confidence threshold** slider.
+
+{{< /expand >}}
+
+## What's next
+
+- [Add computer vision](/vision/configure/) -- the full guide to configuring
+  vision services and cloud inference.
+- [Detect objects (2D)](/vision/detect/) -- use your
+  object detection model to find and locate objects in camera images.
+- [Classify images](/vision/classify/) -- use your
+  classification model to categorize images from your machine's camera.
diff --git a/docs/train/overview.md b/docs/train/overview.md
new file mode 100644
index 0000000000..15bebb7824
--- /dev/null
+++ b/docs/train/overview.md
@@ -0,0 +1,103 @@
+---
+linkTitle: "Overview"
+title: "Train ML models"
+weight: 1
+layout: "docs"
+type: "docs"
+description: "Create datasets from captured images and train ML models for classification or object detection."
+---
+
+Your machines capture images in the field. ML model training turns those images
+into models that can classify what a camera sees or detect specific objects in
+real time. Viam handles the training infrastructure so you can focus on your
+data and your use case.
+
+## The training workflow
+
+Training an ML model follows a repeating cycle:
+
+1. **Create a dataset.** Collect images from your machines into a named,
+   organization-level collection. You can pull images from multiple machines
+   across different locations into a single dataset.
+
+2. **Label your images.** Tag images for classification (the whole image gets a
+   label) or draw bounding boxes for object detection (each object in the image
+   gets a labeled rectangle). You can label manually or use an existing model to
+   auto-annotate and review predictions.
+
+3. **Train a model.** Submit a training job and Viam runs it on cloud
+   infrastructure. No GPU provisioning, no framework installation. Training
+   times range from minutes to an hour depending on dataset size. When training
+   completes, the model is stored in your organization's registry.
+
+4. **Deploy to your machine.** Configure the `tflite_cpu` module and an ML
+   model service on your machine. Add a vision service to apply the model to
+   live camera frames. The machine pulls the model from the registry
+   automatically.
+
+5. **Iterate.** Deploy the model, collect data on its failures, auto-annotate
+   new images with the current model, review the predictions, retrain, and
+   redeploy. Each cycle tightens the feedback loop and improves accuracy. In ML
+   this is called active learning.
+
+## Managed training or custom scripts
+
+Viam offers two paths for training:
+
+**Managed training** handles everything. You select a dataset, pick a framework
+and task type, and start the job. Use this for standard classification and
+object detection with TFLite or TensorFlow. Most users start here.
+
+**Custom training scripts** let you bring your own Python training code. Use
+any framework (PyTorch, ONNX, or anything installable with pip), write custom
+preprocessing, train on non-image data, or implement transfer learning. Viam
+runs your script in the same cloud infrastructure, and the output model is
+published to the registry just like a managed training job.
+
+## Model frameworks
+
+**TensorFlow Lite (TFLite)** produces compact models optimized for edge
+devices. TFLite models run directly on single-board computers like the
+Raspberry Pi without requiring a GPU. This is the right choice for most Viam
+use cases: quality inspection, object detection on a camera feed, simple
+classification.
+
+**TensorFlow (TF)** produces larger models that require more compute resources.
+Use TF when you are running on hardware with a capable CPU or GPU and need
+additional model capacity.
+
+Custom training scripts can use any framework, including PyTorch and ONNX.
+
+## Task types
+
+The task type determines what the model learns to do. It must match how you
+labeled your dataset.
+
+- **Single label classification** assigns exactly one label to each image. Your
+  dataset should have tags with exactly one tag per image.
+- **Multi label classification** assigns one or more labels to each image. Your
+  dataset should have tags, and images may have multiple tags.
+- **Object detection** finds objects in an image and draws bounding boxes around
+  them with labels. Your dataset should have bounding box annotations.
+
+## Automatic deployment
+
+When training completes, the model is stored in your organization's registry.
+If a machine is already configured to use that model, Viam automatically
+deploys the new version. The machine pulls the latest version the next time it
+checks for updates. No manual download or restart is needed.
+
+## Dataset versioning
+
+Each time you train a model from a dataset, Viam snapshots the dataset's
+contents at that point. You can continue adding images and labels to a dataset
+after training without affecting previously trained models.
+
+{{< cards >}}
+{{% card link="/train/create-a-dataset/" %}}
+{{% card link="/train/annotate-images/" %}}
+{{% card link="/train/automate-annotation/" %}}
+{{% card link="/train/train-a-model/" %}}
+{{% card link="/train/deploy-a-model/" %}}
+{{% card link="/train/custom-training-scripts/" %}}
+{{< /cards >}}
diff --git a/docs/train/train-a-model.md b/docs/train/train-a-model.md
new file mode 100644
index 0000000000..6600a8307a
--- /dev/null
+++ b/docs/train/train-a-model.md
@@ -0,0 +1,249 @@
+---
+linkTitle: "Train a model"
+title: "Train a model"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "Train a classification or object detection model from a labeled dataset."
+date: "2025-01-30"
+aliases:
+  - /build/train/train-a-model/
+---
+
+Submit a training job from your labeled dataset. Viam runs the job on cloud
+infrastructure -- no GPU provisioning or framework installation needed.
+Training logs are available for 7 days after the job completes.
+
+For background on model frameworks (TFLite and TensorFlow), task types, and
+how deployment works, see the [overview](/train/overview/).
+
+## 1. Start a training job from the web UI
+
+1. Go to [app.viam.com](https://app.viam.com).
+2. Click the **DATA** tab in the top navigation.
+3. Click the **DATASETS** subtab.
+4. Click the dataset you want to train on.
+5. Click **Train model**.
+6. Select the model framework:
+   - **TFLite** for edge devices (recommended for most use cases)
+   - **TF** for general-purpose models requiring more compute
+7. Enter a name for your model. Use a descriptive name like
+   `part-inspector-v1` or `package-detector-v1`. This name identifies the model
+   in your organization's registry.
+8. Select the task type:
+   - **Single Label Classification** if each image has one tag
+   - **Multi Label Classification** if images have multiple tags
+   - **Object Detection** if you used bounding box annotations
+9. Select which labels to include in training. You can exclude labels that have
+   too few examples or that you do not want the model to learn.
+10. Click **Train model**.
+
+The training job starts. You will see a confirmation message with the job ID.
+
+## 2. Start a training job from the CLI
+
+If you prefer the command line, use the Viam CLI:
+
+```bash
+viam train submit managed \
+  --dataset-id=YOUR-DATASET-ID \
+  --model-org-id=YOUR-ORG-ID \
+  --model-name=part-inspector-v1 \
+  --model-type=single_label_classification \
+  --model-framework=tflite \
+  --model-labels=good-part,defective-part
+```
+
+**Required flags:**
+
+| Flag                | Description                       | Accepted values                                                                 |
+| ------------------- | --------------------------------- | ------------------------------------------------------------------------------- |
+| `--dataset-id`      | Dataset to train on               | Your dataset ID                                                                 |
+| `--model-org-id`    | Organization to save the model in | Your organization ID                                                            |
+| `--model-name`      | Name for the trained model        | Any string                                                                      |
+| `--model-type`      | Task type                         | `single_label_classification`, `multi_label_classification`, `object_detection` |
+| `--model-framework` | Model framework                   | `tflite`, `tensorflow`                                                          |
+| `--model-labels`    | Labels to train on                | Comma-separated list of labels from your dataset                                |
+
+`--model-version` is optional and defaults to the current timestamp.
+
+The command returns a training job ID that you can use to check status.
+
+## 3. Monitor training progress
+
+**Web UI:**
+
+1. In the Viam app, click the **DATA** tab.
+2. Click the **MODELS** subtab, then expand **Active Training**.
+3. You will see a list of training jobs with their status:
+   - **Pending** -- the job is queued
+   - **In Progress** -- training is running
+   - **Completed** -- the model is ready
+   - **Failed** -- something went wrong
+   - **Canceled** -- the job was canceled before completing
+4. Click a job ID to view detailed logs.
+
+**CLI:**
+
+Check the status of a training job:
+
+```bash
+viam train get --job-id=YOUR-JOB-ID
+```
+
+View training logs:
+
+```bash
+viam train logs --job-id=YOUR-JOB-ID
+```
+
+Training logs expire after 7 days. If you need to retain logs for longer,
+copy them before they expire.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+async def main():
+    viam_client = await connect()
+    ml_training_client = viam_client.ml_training_client
+
+    job = await ml_training_client.get_training_job(
+        id="YOUR-TRAINING-JOB-ID",
+    )
+    print(f"Status: {job.status}")
+    print(f"Model name: {job.model_name}")
+    print(f"Created: {job.created_on}")
+
+    viam_client.close()
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+job, err := mlTrainingClient.GetTrainingJob(ctx, "YOUR-TRAINING-JOB-ID")
+if err != nil {
+    logger.Fatal(err)
+}
+fmt.Printf("Status: %s\n", job.Status)
+fmt.Printf("Model name: %s\n", job.ModelName)
+fmt.Printf("Created: %s\n", job.CreatedOn)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## 4. Test your model
+
+After training completes, test the model by deploying it to a machine with a vision service and checking its predictions against live or captured data.
+
+1. [Deploy the model](/train/deploy-a-model/) to a machine with a camera.
+2. [Configure a vision service](/vision/configure/) that uses the model.
+3. On the machine's **CONTROL** tab, open the vision service panel to see live classifications or detections.
+4. Evaluate the results against a variety of conditions:
+   - Images that clearly belong to each class (should get high confidence)
+   - Ambiguous images (helps you understand the model's decision boundary)
+   - Images from conditions not in the training set (reveals generalization gaps)
+
+## 5. Deploy and iterate
+
+When training completes, the model is stored in your organization's registry.
+See [Deploy a model to a machine](/train/deploy-a-model/) to configure the
+module, ML model service, and vision service on your machine.
+
+After deploying, improve your model by collecting targeted data where it
+struggles (edge cases, counterexamples, varied conditions), using
+[auto-annotation](/train/automate-annotation/) to label efficiently, and
+retraining. If your machine is configured to use the model, the new version
+deploys automatically.
+
+To review past training jobs:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+async def main():
+    viam_client = await connect()
+    ml_training_client = viam_client.ml_training_client
+
+    jobs = await ml_training_client.list_training_jobs(
+        org_id=ORG_ID,
+    )
+    for job in jobs:
+        print(f"Job: {job.id}, Status: {job.status}, "
+              f"Model: {job.model_name}, Created: {job.created_on}")
+
+    viam_client.close()
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+jobs, err := mlTrainingClient.ListTrainingJobs(
+    ctx, orgID, app.TrainingStatusUnspecified)
+if err != nil {
+    logger.Fatal(err)
+}
+for _, job := range jobs {
+    fmt.Printf("Job: %s, Status: %d, Model: %s, Created: %s\n",
+        job.ID, job.Status, job.ModelName, job.CreatedOn)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Troubleshooting
+
+{{< expand "Training job fails" >}}
+
+- **Check the training logs.** In the **MODELS** tab, expand **Active Training**
+  and click the failed job ID to view logs. The error message usually indicates
+  the problem.
+- **Dataset too small.** Training requires at least 15 images with at least 80%
+  labeled. Check your dataset in the **DATASETS** tab.
+- **No labels selected.** You must select at least two labels. A model cannot
+  learn to classify if there is only one category.
+- **Bounding box format issue.** For object detection, verify that bounding box
+  coordinates are normalized between 0.0 and 1.0, and `x_min` is less than
+  `x_max`.
+
+{{< /expand >}}
+
+{{< expand "Low confidence scores" >}}
+
+- **Add more training data.** Low confidence usually means the model has not seen
+  enough examples. More diverse images of each class will help.
+- **Check label balance.** If one label dominates the dataset, the model may
+  assign low confidence to minority labels. Balance the dataset and retrain.
+- **Verify image quality.** Blurry, dark, or low-resolution images make it
+  harder for the model to learn distinctive features.
+- **Lower the confidence threshold.** If the model is correct but with scores
+  around 0.4-0.6, your threshold may be set too high.
+
+{{< /expand >}}
+
+{{< expand "Training takes too long" >}}
+
+- **Large datasets take longer.** A dataset with thousands of images may take an
+  hour or more. This is normal.
+- **TF models take longer than TFLite.** If training time is a concern, switch
+  to TFLite.
+- **Training is queued.** If the status stays at "Pending", the training
+  infrastructure may be busy. Jobs are processed in order.
+
+{{< /expand >}}
+
+## What's next
+
+- [Deploy a model to a machine](/train/deploy-a-model/) -- configure the module,
+  ML model service, and vision service to run your model.
+- [Add computer vision](/vision/configure/) -- the full guide to configuring
+  vision services and cloud inference.
+- [Detect objects (2D)](/vision/detect/) -- use your
+  object detection model to find and locate objects in camera images.
+- [Classify images](/vision/classify/) -- use your
+  classification model to categorize images from your machine's camera.
diff --git a/docs/try/_index.md b/docs/try/_index.md
new file mode 100644
index 0000000000..916b8850d1
--- /dev/null
+++ b/docs/try/_index.md
@@ -0,0 +1,20 @@
+---
+linkTitle: "Try"
+title: "Try Viam"
+weight: 20
+layout: "docs"
+type: "docs"
+no_list: true
+description: "Hands-on guided tutorials to experience Viam end-to-end."
+manualLink: "/try/overview/"
+date: "2025-01-30"
+aliases:
+  - /dev/reference/try-viam/
+  - /dev/reference/try-viam/reserve-a-rover/
+  - /dev/reference/try-viam/try-viam-tutorial/
+  - /dev/reference/try-viam/rover-resources/
+  - /dev/reference/try-viam/rover-resources/rover-tutorial/
+  - /dev/reference/try-viam/rover-resources/rover-tutorial-1/
+  - /dev/reference/try-viam/rover-resources/rover-tutorial-fragments/
+  - /dev/reference/try-viam/rover-resources/rover-tutorial/jetson-rover-setup/
+---
diff --git a/docs/try/gazebo-setup.md b/docs/try/gazebo-setup.md
new file mode 100644
index 0000000000..2856425cfd
--- /dev/null
+++ b/docs/try/gazebo-setup.md
@@ -0,0 +1,187 @@
+---
+linkTitle: "Gazebo Simulation Setup"
+title: "Gazebo Simulation Setup"
+weight: 5
+layout: "docs"
+type: "docs"
+description: "Set up the Gazebo simulation environment for the inspection tutorial."
+date: "2025-01-30"
+aliases:
+  - /try/first-project/gazebo-setup/
+---
+
+This guide walks you through setting up the Gazebo simulation used in the [Your First Project](../) tutorial.
+
+## Prerequisites
+
+- **Docker Desktop** installed and running
+- A free [Viam account](https://app.viam.com)
+- ~5GB disk space for the Docker image
+
+## Step 1: Build the Docker Image
+
+The simulation runs in a Docker container with Gazebo Harmonic and viam-server pre-installed.
+
+**Clone the simulation repository:**
+
+```bash
+git clone https://github.com/viamrobotics/can-inspection-simulation.git
+cd can-inspection-simulation
+```
+
+**Build the Docker image:**
+
+```bash
+docker build -t gz-harmonic-viam .
+```
+
+This takes 5-10 minutes depending on your internet connection.
+
+## Step 2: Create a Machine in Viam
+
+1. Go to [app.viam.com](https://app.viam.com) and log in
+2. Click the **Locations** tab
+3. Click **+ Add machine**
+4. Name it `inspection-station-1`
+5. Click **Add machine**
+
+## Step 3: Create a credentials file
+
+1. Click the **Awaiting setup** button
+2. Click **Machine cloud credentials** to copy your machine's credentials
+3. In the `can-inspection-simulation` directory, create a file called `station1-viam.json`
+4. Paste your machine's credentials into this file and save
+
+## Step 4: Start the Container
+
+{{< alert title="Note" color="note" >}}
+If you have a local installation of `viam-agent` running on your machine, it uses port 8080 by default. Running the container with `-p 8080:8080` will conflict with it. To avoid this, either stop the local `viam-agent` before starting the container, or change the host port mapping (for example, `-p 8090:8080`) and access the container on the new port instead.
+{{< /alert >}}
+
+{{< tabs >}}
+{{% tab name="Mac/Linux" %}}
+
+```bash
+docker run --name gz-station1 -d \
+  -p 8080:8080 -p 8081:8081 -p 8443:8443 \
+  -v "$(pwd)/station1-viam.json:/etc/viam.json" \
+  gz-harmonic-viam
+```
+
+{{% /tab %}}
+{{% tab name="Windows (PowerShell)" %}}
+
+```powershell
+docker run --name gz-station1 -d `
+  -p 8080:8080 -p 8081:8081 -p 8443:8443 `
+  -v "${PWD}\station1-viam.json:/etc/viam.json" `
+  gz-harmonic-viam
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Step 5: Verify the Setup
+
+**Check container logs:**
+
+```bash
+docker logs gz-station1
+```
+
+Look for:
+
+- "Can Inspection Station 1 Running!"
+- viam-server startup messages
+
+**View the simulation:**
+
+Open your browser to `http://localhost:8081`
+
+You should see a web-based 3D view of the inspection station with:
+
+- A conveyor belt
+- Cans moving along the belt
+- An overhead camera view
+
+{{<imgproc src="/tutorials/first-project/gazebo-simulation.png" resize="x1100" declaredimensions=true alt="Gazebo web viewer showing the Can Inspection Station with Overview Camera and Inspection Camera views." class="imgzoom shadow">}}
+
+**Verify machine connection:**
+
+1. Go to [app.viam.com](https://app.viam.com)
+2. Click on `inspection-station-1`
+3. The status indicator should show **Live** (in green)
+
+## Troubleshooting
+
+{{< expand "Container won't start" >}}
+**Check if ports are in use:**
+
+{{< tabs >}}
+{{% tab name="Mac/Linux" %}}
+
+```bash
+lsof -i :8080
+lsof -i :8081
+```
+
+{{% /tab %}}
+{{% tab name="Windows (PowerShell)" %}}
+
+```powershell
+netstat -ano | findstr :8080
+netstat -ano | findstr :8081
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+If something is using these ports, stop it or use different port mappings.
+{{< /expand >}}
+
+{{< expand "Machine shows Offline in Viam" >}}
+
+1. Check container is running: `docker ps`
+2. Check logs for errors: `docker logs gz-station1`
+3. Verify credentials in your config file match the Viam app
+4. Try restarting: `docker restart gz-station1`
+   {{< /expand >}}
+
+{{< expand "Simulation viewer is blank or slow" >}}
+
+- The web viewer requires WebGL support
+- Try a different browser (Chrome usually works best)
+- Check your system has adequate resources (4GB+ RAM recommended)
+  {{< /expand >}}
+
+## Container Management
+
+**Stop the container:**
+
+```bash
+docker stop gz-station1
+```
+
+**Start a stopped container:**
+
+```bash
+docker start gz-station1
+```
+
+**Remove the container (to recreate):**
+
+```bash
+docker rm gz-station1
+```
+
+**View logs:**
+
+```bash
+docker logs -f gz-station1
+```
+
+## Ready to Continue
+
+Once your machine shows **Live** in the Viam app, you're ready to continue with the tutorial.
+
+**[Continue to Part 1: Vision Pipeline →](../part-1/)**
diff --git a/docs/try/overview.md b/docs/try/overview.md
new file mode 100644
index 0000000000..01cb838477
--- /dev/null
+++ b/docs/try/overview.md
@@ -0,0 +1,95 @@
+---
+linkTitle: "Overview"
+title: "Overview"
+weight: 1
+layout: "docs"
+type: "docs"
+no_list: true
+description: "Build a complete quality inspection system with Viam — from camera setup to customer-facing product."
+date: "2025-01-30"
+aliases:
+  - /try/first-project/
+---
+
+**Time:** ~55 minutes
+
+## Scenario
+
+This tutorial uses the simplest work cell (camera + compute) to teach patterns that apply to _all_ Viam applications.
+
+You're building a **quality inspection station** for a canning line. Cans move past a camera on a conveyor belt. Your system must:
+
+1. Detect when a can is present
+2. Classify it as PASS or FAIL (identifying dented cans)
+3. Log results for review and analysis
+4. Provide a monitoring dashboard for operators
+
+### Tutorial
+
+In this tutorial you will work through a series of tasks that are common to many robotics applications. The techniques you learn here are applicable regardless of what hardware, software, data, or machine learning models you are working with.
+
+| Part                                        | Time    | What you'll do                                         |
+| ------------------------------------------- | ------- | ------------------------------------------------------ |
+| [Gazebo Simulation Setup](../gazebo-setup/) | ~10 min | Set up the Gazebo simulation environment               |
+| [Part 1: Vision pipeline](../part-1/)       | ~10 min | Set up camera, ML model, and vision service            |
+| [Part 2: Data capture](../part-2/)          | ~5 min  | Configure automatic image capture and cloud sync       |
+| [Part 3: Control logic](../part-3/)         | ~10 min | Generate module, write inspection logic, test from CLI |
+| [Part 4: Deploy a module](../part-4/)       | ~10 min | Deploy module, configure detection data capture        |
+| [Part 5: Productize](../part-5/)            | ~10 min | Build monitoring dashboard with Teleop                 |
+
+{{< expand "Full section outline" >}}
+
+**[Gazebo Simulation Setup](../gazebo-setup/)** (~10 min)
+
+- [Prerequisites](../gazebo-setup/#prerequisites)
+- [Step 1: Build the Docker Image](../gazebo-setup/#step-1-build-the-docker-image)
+- [Step 2: Create a Machine in Viam](../gazebo-setup/#step-2-create-a-machine-in-viam)
+- [Step 3: Create a credentials file](../gazebo-setup/#step-3-create-a-credentials-file)
+- [Step 4: Start the Container](../gazebo-setup/#step-4-start-the-container)
+- [Step 5: Verify the Setup](../gazebo-setup/#step-5-verify-the-setup)
+
+**[Part 1: Vision pipeline](../part-1/)** (~10 min)
+
+- [1.1 Verify your machine is online](../part-1/#11-verify-your-machine-is-online)
+- [1.2 Locate your machine part](../part-1/#12-locate-your-machine-part)
+- [1.3 Configure the camera](../part-1/#13-configure-the-camera)
+- [1.4 Test the camera](../part-1/#14-test-the-camera)
+- [1.5 Add a vision pipeline with a fragment](../part-1/#15-add-a-vision-pipeline-with-a-fragment)
+
+**[Part 2: Data capture](../part-2/)** (~5 min)
+
+- [2.1 Configure data capture](../part-2/#21-configure-data-capture)
+- [2.2 View captured data](../part-2/#22-view-captured-data)
+- [2.3 Summary](../part-2/#23-summary)
+
+**[Part 3: Control logic](../part-3/)** (~10 min)
+
+- [3.1 Generate the module scaffolding](../part-3/#31-generate-the-module-scaffolding)
+- [3.2 Add remote machine connection](../part-3/#32-add-remote-machine-connection)
+- [3.3 Add detection logic](../part-3/#33-add-detection-logic)
+- [3.4 Summary](../part-3/#34-summary)
+
+**[Part 4: Deploy a module](../part-4/)** (~10 min)
+
+- [4.1 Review the generated module structure](../part-4/#41-review-the-generated-module-structure)
+- [4.2 Build and upload your module](../part-4/#42-build-and-upload-your-module)
+- [4.3 Add the module to your machine](../part-4/#43-add-the-module-to-your-machine)
+- [4.4 Configure detection data capture](../part-4/#44-configure-detection-data-capture)
+- [4.5 Summary](../part-4/#45-summary)
+
+**[Part 5: Productize](../part-5/)** (~10 min)
+
+- [5.1 Create a workspace](../part-5/#51-create-a-workspace)
+- [5.2 Add a camera stream widget](../part-5/#52-add-a-camera-stream-widget)
+- [5.3 Add a defects per minute widget](../part-5/#53-add-a-defects-per-minute-widget)
+- [5.4 Add a confidence trend widget](../part-5/#54-add-a-confidence-trend-widget)
+- [5.5 Arrange your dashboard](../part-5/#55-arrange-your-dashboard)
+- [5.6 Summary](../part-5/#56-summary)
+
+{{< /expand >}}
+
+## Get started
+
+Before starting, set up the Gazebo simulation environment by following the **[Gazebo Simulation Setup](../gazebo-setup/)** guide (~10 min).
+
+**[Begin Gazebo Simulation Setup →](../gazebo-setup/)**
diff --git a/docs/try/part-1.md b/docs/try/part-1.md
new file mode 100644
index 0000000000..142e83b397
--- /dev/null
+++ b/docs/try/part-1.md
@@ -0,0 +1,191 @@
+---
+linkTitle: "Part 1: Vision Pipeline"
+title: "Part 1: Vision Pipeline"
+weight: 10
+layout: "docs"
+type: "docs"
+description: "Set up a camera, ML model, and vision service to detect defects."
+date: "2025-01-30"
+aliases:
+  - /try/first-project/part-1/
+---
+
+**Goal:** Get a computer vision pipeline working.
+
+**Skills:** Connect a machine to Viam, configure components in the Viam UI, use fragments to add preconfigured services.
+
+**Time:** ~10 min
+
+## Prerequisites
+
+Before starting this tutorial, you need the can inspection simulation running. Follow the **[Gazebo Simulation Setup Guide](../gazebo-setup/)** to:
+
+1. Build the Docker image with Gazebo Harmonic
+2. Create a machine in Viam and get credentials
+3. Start the container with your Viam credentials
+
+Once you see "Can Inspection Simulation Running!" in the container logs and your machine shows **Live** in the Viam app, return here to continue.
+
+{{< alert title="What you're working with" color="info" >}}
+The simulation runs Gazebo Harmonic inside a Docker container. It simulates a conveyor belt with cans (some dented) passing under an inspection camera. viam-server runs on the Linux virtual machine inside the container and connects to Viam's cloud, just like it would on a physical machine. Everything you configure in the Viam app applies to the simulated hardware.
+{{< /alert >}}
+
+## 1.1 Verify Your Machine is Online
+
+If you followed the [setup guide](../gazebo-setup/), your machine should already be online.
+
+1. Open [app.viam.com](https://app.viam.com) (the "Viam app")
+2. Navigate to your machine (for example, `inspection-station-1`)
+3. Verify the status indicator shows **Live**
+4. Click the **CONFIGURE** tab if not already selected
+
+{{<imgproc src="/tutorials/first-project/machine-live-status.png" resize="x1100" declaredimensions=true alt="Machine page showing the green Live status indicator next to the machine name." class="imgzoom shadow">}}
+
+Ordinarily, after creating a machine in Viam, you would download and install `viam-server` together with the cloud credentials for your machine. For this tutorial, we've already installed `viam-server` and launched it in the simulation Docker container.
+
+## 1.2 Locate Your Machine Part
+
+Your machine is online but empty. To configure your machine, you will add components and services to your machine part in the Viam app. Your machine part is the compute hardware for your robot. This might be a PC, Mac, Raspberry Pi, or another computer.
+
+In the case of this tutorial, your machine part is a virtual machine running Linux in the Docker container.
+
+Find `inspection-station-1-main` in the **CONFIGURE** tab.
+
+## 1.3 Configure the Camera
+
+You'll now add the camera as a _component_.
+
+{{< expand "What's a component?" >}}
+In Viam, a **component** is any piece of hardware: cameras, motors, arms, sensors, grippers. You configure components by declaring what they are, and Viam handles the drivers and communication.
+
+**The power of Viam's component model:** All cameras expose the same API—USB webcams, Raspberry Pi camera modules, IP cameras, simulated cameras. Your application code uses the same `GetImages()` method regardless of the underlying hardware. Swap hardware by changing configuration, not code.
+{{< /expand >}}
+
+### Add a camera component
+
+To add the camera component to your machine part:
+
+1. Click the **+** button and select **Configuration block**
+2. Click **Camera**
+3. Search for `gz-camera`
+4. Select `gz-camera/rgb-camera`
+5. Click **Add Component**
+6. Enter `inspection-cam` for the name
+
+{{< expand "Why were two items added to my machine part?" >}}
+After adding the camera component, you will see two items appear under your machine part. One is the actual camera hardware (`inspection-cam`) that you will use through the Viam camera API. The other is the software module (`gz-camera`) that implements this API for the specific model of camera you are using. All components that are supported through modules available in the Viam registry will appear this way in the **CONFIGURE** tab. For built-in components, such as webcams, you will not also see a module appear in the configuration.
+{{< /expand >}}
+
+### Configure the camera
+
+To configure your camera component to work with the camera in the simulation, you need to specify the correct camera ID. Most components require a few configuration parameters.
+
+1. In the **Attributes** section, add:
+
+   ```json
+   {
+     "id": "/inspection_camera"
+   }
+   ```
+
+2. Click **Save** in the top right
+
+{{< alert title="What happened behind the scenes" color="info" >}}
+You declared "this machine has a camera called `inspection-cam`" by editing the configuration in the Viam app. When you clicked **Save**, `viam-server` loaded the camera module, added a camera component, and made the camera available through Viam's standard camera API. Software you write, other services, and user interface components will use the API to get the images they need. Using the API as an abstraction means that everything still works if you swap cameras.
+{{< /alert >}}
+
+## 1.4 Test the Camera
+
+Verify the camera is working. Every component in Viam has a built-in test card right in the configuration view.
+
+### Open the test panel
+
+1. You should still be on the **CONFIGURE** tab with your `inspection-cam` selected
+2. Look for the **Test** section at the bottom of the camera's configuration panel
+3. Click **Test** to expand the camera's test card
+
+The camera component test card uses the camera API to add an image feed to the Viam app, enabling you to determine whether your camera is working. You should see a live video feed from the simulated camera. This is an overhead view of the conveyor/staging area.
+
+{{< alert title="Checkpoint" color="success" >}}
+Your camera is working. You can stream video and capture images from the simulated inspection station.
+{{< /alert >}}
+
+## 1.5 Add a vision pipeline with a fragment
+
+Now you'll add machine learning to run inference on your camera feed. You need two services:
+
+1. **ML model service** that loads a trained model for the inference task
+2. **Vision service** that connects the camera to the model and returns detections
+
+{{< expand "Components versus services" >}}
+
+- **Components** are hardware: cameras, motors, arms
+- **Services** are capabilities: vision (ML inference), motion (arm kinematics), custom control logic
+
+Services often _use_ components. A **vision service** takes images from a camera, runs them through an ML model, and returns structured results, detections with bounding boxes and labels, or classifications with confidence scores.
+
+The **ML model service** loads a trained model (TensorFlow, ONNX, or PyTorch) and exposes an `Infer()` method. The vision service handles the rest: converting camera images to tensors, calling the model, and interpreting outputs into usable detections.
+{{< /expand >}}
+
+Instead of adding each service manually, you'll use a **fragment**. A fragment is a reusable block of configuration that can include components, services, modules, and ML models. Fragments let you share tested configurations across machines and teams.
+
+The `try-vision-pipeline` fragment includes an ML model service loaded with a can defect detection model and a vision service wired to that model. The fragment accepts a `camera_name` variable so it works with any camera.
+
+### Add the fragment
+
+1. Click **+** next to your machine name
+2. Select **Configuration block**
+3. Search for `try-vision-pipeline`
+4. Select `try-vision-pipeline` and click **Add Fragment**
+
+### Set the camera variable
+
+The fragment needs to know which camera to use for inference.
+
+1. In the fragment's configuration panel, find the **Variables** section
+2. Set the `camera_name` variable to `inspection-cam`
+
+   ```json
+   {
+     "camera_name": "inspection-cam"
+   }
+   ```
+
+3. Click **Save** in the upper right corner
+
+{{< alert title="What the fragment added" color="info" >}}
+The fragment added two services and their dependencies to your machine:
+
+- **model-service**: An ML model service running TensorFlow Lite with the `can-defect-detection` model from the Viam registry. This model classifies cans as PASS or FAIL.
+- **vision-service**: A vision service that takes images from your camera, runs them through the ML model, and returns structured detection results.
+
+The fragment also added the TFLite CPU module and the ML model package. Everything is wired together and ready to use.
+{{< /alert >}}
+
+{{< alert title="Fragments and reuse" color="tip" >}}
+This fragment works with any camera. If you were using a USB webcam instead of the simulation camera, you'd set `camera_name` to whatever you named your webcam component. The ML pipeline stays the same. This is how fragments enable reuse across different hardware setups.
+{{< /alert >}}
+
+### Test the vision service
+
+1. Find the **Test** section at the bottom of the `vision-service` configuration panel
+2. Expand the **Test** card
+3. If not already selected, select `inspection-cam` as the camera source
+4. Set **Detections/Classifications** to `Live`
+5. Check that detection and labeling are working
+
+{{<imgproc src="/tutorials/first-project/vision-service-test.png" resize="x1100" declaredimensions=true alt="Vision service test panel showing a can detected with a bounding box and FAIL label." class="imgzoom shadow">}}
+
+{{< alert title="What you've built" color="info" >}}
+A complete ML inference pipeline. The vision service grabs an image from the camera, runs it through the TensorFlow Lite model, and returns structured detection results. This same pattern works for any ML task: object detection, classification, segmentation. Swap the model and camera, and the pipeline still works.
+{{< /alert >}}
+
+{{< alert title="Checkpoint" color="success" >}}
+You added a camera component manually and used a fragment to add a complete ML vision pipeline. The system can detect defective cans. Next, you'll set up continuous data capture so every detection is recorded and queryable.
+{{< /alert >}}
+
+{{< alert title="Explore the JSON configuration" color="tip" >}}
+Everything you configured through the UI is stored as JSON. Click **JSON** in the upper left of the Configure tab to see the raw configuration. You'll see your camera component, the fragment reference, and how the fragment's services connect to your camera. As configurations grow more complex, the JSON view helps you understand how components and services connect.
+{{< /alert >}}
+
+**[Continue to Part 2: Data Capture →](../part-2/)**
diff --git a/docs/try/part-2.md b/docs/try/part-2.md
new file mode 100644
index 0000000000..cd0656b9e3
--- /dev/null
+++ b/docs/try/part-2.md
@@ -0,0 +1,110 @@
+---
+linkTitle: "Part 2: Data Capture"
+title: "Part 2: Data Capture"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "Configure automatic image capture and cloud sync for your inspection system."
+date: "2025-01-30"
+aliases:
+  - /try/first-project/part-2/
+---
+
+**Goal:** Configure and use a machine to cloud data capture pipeline.
+
+**Skills:** Data capture configuration, cloud sync, browsing captured data.
+
+**Time:** ~5 min
+
+For inspection applications such as this one, monitoring defect detection is important both to ensure production line health and product quality.
+You want to ensure the vision model is detecting a very high percentage of defects and quickly detect any problems.
+In addition, it's important to collect production training data to improve defect detection models over time.
+
+In this part of the tutorial, you'll configure continuous data capture to support these goals.
+To do this, you'll use Viam's built-in data capture and cloud sync.
+Once enabled, data capture services run automatically in the background.
+Data gets buffered locally, synced to the cloud at an interval you configure, and is then available for review in the Viam app.
+
+## 2.1 Configure Data Capture
+
+**Include the data service in your machine configuration:**
+
+1. Click **+** next to **inspection-station-1-main** in the **CONFIGURE** tab
+2. Click **Configuration block**
+3. Select **data_manager/builtin**
+4. Name it `data-service`
+5. Click **Create**
+6. **Save** your updated machine configuration
+
+The default configuration options for the data service are correct for our application so we can move on to capturing data from the vision service.
+
+**Enable data capture on the vision service:**
+
+1. Click `vision-service` in your machine configuration
+2. Click the **Data Capture** button
+3. Select the method to capture: `CaptureAllFromCamera`
+4. Set **Frequency (hz)** to `0.5` (every 2 seconds)
+5. Set **Camera name** to `inspection-cam`
+6. **Save** your configuration
+
+**Verify it's working:**
+
+1. In the **DATA CAPTURE** section of the `vision-service` configuration panel you should now see a collapsible component labeled **Latest capture** with a day and time specified
+2. Click on **Latest capture** and view the most recent image captured
+
+Your machine is now capturing detection results and images every 2 seconds and syncing them to the Viam cloud application. Once synced to the cloud, the data is removed from your machine to free up storage.
+
+{{< alert title="Tip" color="tip" >}}
+Click **JSON** in the Configure tab to see how data capture settings appear in the raw configuration. Each component and service with data capture enabled has a `service_configs` entry containing `capture_methods`.
+{{< /alert >}}
+
+## 2.2 View Captured Data
+
+Up to this point in the tutorial, you've focused on configuring your machine.
+To view the data you are now capturing, you will need to open the data user interface in Viam.
+Find the main Viam menu that includes: **Fleet**, **Data**, and **Registry** at the top of the page.
+Right click on **Data** to open in a separate tab.
+
+**View captured data:**
+
+1. Review the grid of images captured from your work cell
+2. Click on an image to see the detection results for that image
+3. Click on a few other images to see how detection results vary for cans labeled `PASS` versus `FAIL`
+
+{{<imgproc src="/tutorials/first-project/data-tab-images.png" resize="x1100" declaredimensions=true alt="Data tab showing a grid of captured images from the inspection camera." class="imgzoom shadow">}}
+
+**Verify the data includes:**
+
+- **Detection results**—Each row shows label (PASS/FAIL) and confidence score
+- **Camera images**—Click any row to see the image that was analyzed
+- **Timestamps**—When each capture occurred
+- **Machine ID**—Which machine captured it (matters when you have multiple stations)
+
+**Filter the data:**
+
+1. Click **Filter** and select your machine: `inspection-station-1`
+2. Set time range to "Last hour"
+3. You can also filter by component to see only vision service results or only camera images
+
+This captured data serves multiple purposes:
+
+- **Compliance**—Auditable record of every inspection
+- **Quality trends**—"FAIL rate increased 20% this week"
+- **Model improvement**—Export images of cans to retrain your ML model
+- **Incident review**—"Show me all FAILs from Tuesday's shift"
+
+## 2.3 Summary
+
+Data capture is now running in the background:
+
+- Captures images with detection overlays
+- Syncs to cloud automatically
+- Available for visual review and filtering
+
+This foundation records everything your vision pipeline sees. In Part 3, you'll write custom control logic to act on detections. Later, you'll configure tabular data capture to enable SQL queries on detection results.
+
+{{< alert title="Checkpoint" color="success" >}}
+Your system captures every detection as an image. Data syncs to the cloud where you can browse, filter, and review results.
+{{< /alert >}}
+
+**[Continue to Part 3: Control Logic →](../part-3/)**
diff --git a/docs/try/part-3.md b/docs/try/part-3.md
new file mode 100644
index 0000000000..aa94dc4aab
--- /dev/null
+++ b/docs/try/part-3.md
@@ -0,0 +1,588 @@
+---
+linkTitle: "Part 3: Control Logic"
+title: "Part 3: Control Logic"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "Write inspection logic that detects defective cans."
+date: "2025-01-30"
+aliases:
+  - /try/first-project/part-3/
+---
+
+**Goal:** Write inspection logic that detects defective cans.
+
+**Skills:** Generate module scaffolding using the Viam CLI, experience with Viam SDKs, develop code iteratively against remote hardware
+
+**Time:** ~10 min
+
+## What You'll Build
+
+Your vision pipeline detects defective cans and records the results with images synced to the cloud. Now you'll write a module that calls the vision service and exposes detection results through `DoCommand`. This detection data can drive dashboards, alerts, or—in a production system—trigger actuators to reject defective cans.
+
+You'll use the **module-first development pattern**: write code on your laptop, test it against remote hardware over the network. This workflow lets you iterate quickly—edit code, run it, see results—without redeploying after every change.
+
+## Prerequisites
+
+This part of the tutorial requires the Go programming language and the Viam CLI.
+
+### Install Go
+
+Check your Go version:
+
+```bash
+go version
+```
+
+You need Go 1.25.1 or later. If Go isn't installed or is outdated, download it from [go.dev/dl](https://go.dev/dl/).
+
+### Install the Viam CLI
+
+The Viam CLI is used for authentication, module generation, and deployment.
+
+{{< tabs >}}
+{{% tab name="macOS" %}}
+
+```bash
+brew tap viamrobotics/brews
+brew install viam
+```
+
+{{% /tab %}}
+{{% tab name="Linux" %}}
+
+```bash
+sudo curl -o /usr/local/bin/viam https://storage.googleapis.com/packages.viam.com/apps/viam-cli/viam-cli-stable-linux-amd64
+sudo chmod +x /usr/local/bin/viam
+```
+
+{{% /tab %}}
+{{% tab name="Windows" %}}
+
+```powershell
+Invoke-WebRequest -Uri "https://storage.googleapis.com/packages.viam.com/apps/viam-cli/viam-cli-stable-windows-amd64.exe" -OutFile "viam.exe"
+```
+
+Then run as `.\viam.exe` or add the directory to your PATH.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Verify and Log In
+
+Verify the CLI is installed:
+
+```bash
+viam version
+```
+
+Log in to Viam:
+
+```bash
+viam login
+```
+
+This stores credentials that your code will use to connect to remote machines.
+
+{{< alert title="Note" color="info" >}}
+The Viam CLI (`viam`) is different from `viam-server`. The CLI runs on your development machine; `viam-server` runs on your robot/machine.
+{{< /alert >}}
+
+## 3.1 Generate the Module Scaffolding
+
+A **module** in Viam is a package of code that adds capabilities to a machine. Modules run alongside viam-server and can provide custom components (like a new type of sensor) or services (like our inspection logic). By packaging code as a module, you can deploy it to any machine, share it with others, and manage versions through the Viam registry.
+
+The Viam CLI can generate module boilerplate—saving you from writing registration code, build configuration, and project structure from scratch. This lets you focus on your business logic instead of infrastructure.
+
+**Set your organization's namespace:**
+
+Before creating a module, your organization needs a public namespace. This is a unique identifier used in module names (for example, `my-namespace:inspection-module`).
+
+1. Click the organization dropdown in the upper right corner of the Viam app next to your initials
+2. Select **Settings**
+3. Click **Set a public namespace** and enter a unique name (lowercase letters, numbers, hyphens)
+4. Click **Save**
+
+{{<imgproc src="/tutorials/first-project/org-settings-dropdown.png" resize="x1100" declaredimensions=true alt="Organization dropdown menu showing Settings option." class="imgzoom shadow">}}
+
+If your organization already has a namespace, you can skip this step.
+
+**Generate the module scaffolding:**
+
+```bash
+viam module generate
+```
+
+Enter these values when prompted:
+
+| Prompt                 | Value                      |
+| ---------------------- | -------------------------- |
+| Module name            | `inspection-module`        |
+| Language               | `Go`                       |
+| Visibility             | `Private`                  |
+| Namespace/Organization | _Select your organization_ |
+| Resource type          | `Generic Service`          |
+| Model name             | `inspector`                |
+| Register module        | `Yes`                      |
+
+**Why Generic Service?** Viam has built-in APIs for hardware (camera, motor, arm). When your logic doesn't fit those categories, Generic Service provides a flexible `DoCommand` interface—ideal for application-specific logic like inspection.
+
+**What does "Register module" do?** Creates an entry in the Viam registry (just metadata, not your code). This enables cloud deployment later.
+
+### Files You'll Work With
+
+The generator creates a complete module structure. You'll focus on three files:
+
+- **`module.go`**—Your service implementation. Contains Config, constructor, and methods. This is where your inspection logic goes.
+- **`cmd/cli/main.go`**—CLI for local testing. We'll modify this to connect to your remote machine so you can test against real hardware without deploying.
+- **`cmd/module/main.go`**—Entry point when deployed. Registers your service with viam-server. You won't modify this.
+
+This is the **module-first development pattern**: write logic in `module.go`, test locally with the CLI against your real machine, then deploy.
+
+## 3.2 Add Remote Machine Connection
+
+The generated CLI creates your service with empty dependencies—fine for testing logic in isolation, but useless for testing against real hardware. We'll modify it to connect to your remote machine and access its resources. With this approach to Viam application development, your code runs locally on your laptop, but it talks to real cameras and other hardware your machine configuration includes.
+
+Why is this valuable? Traditional embedded development requires: edit code → build → deploy → test → repeat. With module-first development: edit code → run locally → see results on real hardware. The iteration cycle drops from minutes to seconds.
+
+**Get your machine address:**
+
+1. In the Viam app, go to your machine's **Configure** page
+2. Click the **Live** dropdown
+3. Click **Remote address** to copy your machine address
+
+{{<imgproc src="/tutorials/first-project/machine-address.png" resize="x1100" declaredimensions=true alt="Live dropdown showing Remote address option with machine address visible." class="imgzoom shadow">}}
+
+### Step 1: Connect to Your Machine
+
+The generated `realMain` function creates your inspector with empty dependencies—useful for testing in isolation, but it can't access your remote machine. We'll replace it with code that:
+
+- Accepts a `-host` flag for your machine's address
+- Uses your `viam login` credentials to authenticate
+- Establishes a secure connection to the remote machine
+
+Open `cmd/cli/main.go` and replace the import block with:
+
+```go
+import (
+    "context"
+    "flag"
+    "fmt"
+
+    "github.com/erh/vmodutils"
+    "go.viam.com/rdk/logging"
+)
+```
+
+Then replace the `realMain` function with:
+
+```go
+func realMain() error {
+    ctx := context.Background()
+    logger := logging.NewLogger("cli")
+
+    host := flag.String("host", "", "Machine address (required)")
+    flag.Parse()
+
+    if *host == "" {
+        return fmt.Errorf("need -host flag (get address from Viam app)")
+    }
+
+    logger.Infof("Connecting to %s...", *host)
+    machine, err := vmodutils.ConnectToHostFromCLIToken(ctx, *host, logger)
+    if err != nil {
+        return fmt.Errorf("failed to connect: %w", err)
+    }
+    defer machine.Close(ctx)
+
+    logger.Info("Connected successfully!")
+    return nil
+}
+```
+
+**Test the connection:**
+
+```bash
+go run cmd/cli/main.go -host YOUR_MACHINE_ADDRESS
+```
+
+{{< alert title="Note" color="note" >}}
+If the build fails with missing package errors, run `go get <missing-package>` for each missing dependency, then re-run the command.
+{{< /alert >}}
+
+You'll see WebRTC diagnostic output as the connection is established. Look for these messages confirming the connection:
+
+```text
+Connecting to your-machine.abc123.viam.cloud...
+...
+successfully (re)connected to remote at address
+...
+Connected successfully!
+```
+
+If you see an error, verify:
+
+- Your machine is online (check the Viam app)
+- You're logged in (`viam login`)
+- The address is correct
+
+### Step 2: Access Remote Resources
+
+Now let's verify we can access the camera on the remote machine.
+
+**Add the camera import:**
+
+At the top of `cmd/cli/main.go`, add this import:
+
+```go
+"go.viam.com/rdk/components/camera"
+```
+
+**Fetch the camera dependencies:**
+
+```bash
+go mod tidy
+```
+
+**Add camera access after the connection:**
+
+After the `logger.Info("Connected successfully!")` line, add:
+
+```go
+// Get the camera from the remote machine
+cam, err := camera.FromProvider(machine, "inspection-cam")
+if err != nil {
+    return fmt.Errorf("failed to get camera: %w", err)
+}
+
+// Capture an image
+images, _, err := cam.Images(ctx, nil, nil)
+if err != nil {
+    return fmt.Errorf("failed to get images: %w", err)
+}
+
+if len(images) == 0 {
+    return fmt.Errorf("no images returned from camera")
+}
+
+logger.Infof("Got image from camera: %s", images[0].SourceName)
+```
+
+If your editor doesn't auto-format, run `gofmt -w cmd/cli/main.go` to fix indentation.
+
+**Test resource access:**
+
+```bash
+go mod tidy
+go run cmd/cli/main.go -host YOUR_MACHINE_ADDRESS
+```
+
+You'll see the same WebRTC diagnostic output, followed by the camera confirmation:
+
+```text
+Connected successfully!
+Got image from camera: inspection-cam
+```
+
+You've just accessed a camera on a remote machine from your local development environment. This same pattern works for any Viam resource—motors, sensors, vision services, or custom components.
+
+{{< alert title="Takeaway" color="tip" >}}
+The `vmodutils.ConnectToHostFromCLIToken` function uses your `viam login` credentials to establish a secure connection. Once connected, you access resources the same way you would in deployed code. This abstraction is what makes module-first development possible.
+{{< /alert >}}
+
+## 3.3 Add Detection Logic
+
+Now we'll implement the actual inspection logic. The generator created `module.go` with stub methods—we'll fill them in to call the vision service and process results.
+
+Complete all five steps below, then test at the end.
+
+{{< alert title="Concept: Dependency Injection" color="info" >}}
+Your inspector needs a vision service to detect cans. Rather than hardcoding how to find that service, you _declare_ the dependency in your Config, and Viam _injects_ it into your constructor. This means:
+
+- Your code doesn't know where resources live (local or remote)
+- The same code works in CLI testing and deployed modules
+  {{< /alert >}}
+
+### Step 1: Declare Dependencies
+
+The Config struct tells Viam what resources your inspector needs. The Validate method returns those resource names so Viam knows to inject them.
+
+Remember in Part 1 when you configured the camera with `"id": "/inspection_camera"`? When you add the service we're building now to your machine (in Part 4 of this tutorial), you'll configure it with attributes for the camera and vision service to use.
+
+The Config struct in the code below specifies what the names of those attributes will be in the configuration JSON you'll update after including this module in your machine config.
+
+In `module.go`, find the `Config` struct and `Validate` method and replace them with the code below.
+
+```go
+type Config struct {
+    Camera        string `json:"camera"`
+    VisionService string `json:"vision"`
+}
+
+func (cfg *Config) Validate(path string) ([]string, []string, error) {
+    if cfg.Camera == "" {
+        return nil, nil, fmt.Errorf("camera is required")
+    }
+    if cfg.VisionService == "" {
+        return nil, nil, fmt.Errorf("vision is required")
+    }
+    return []string{cfg.Camera, cfg.VisionService}, nil, nil
+}
+```
+
+The first return value from Validate lists dependencies—Viam ensures these resources exist before creating your service.
+
+### Step 2: Store Dependencies
+
+The generated struct needs a field to hold the vision service that Viam will inject.
+
+Find the `inspectionModuleInspector` struct in `module.go` and add a `detector` field:
+
+```go
+type inspectionModuleInspector struct {
+    resource.AlwaysRebuild
+
+    name   resource.Name
+    logger logging.Logger
+    cfg    *Config
+
+    cancelCtx  context.Context
+    cancelFunc func()
+
+    detector vision.Service  // Add this field
+}
+```
+
+The `detector` field will hold a reference to the vision service.
+
+Add the vision import to your import block:
+
+```go
+"go.viam.com/rdk/services/vision"
+```
+
+### Step 3: Wire Dependencies
+
+The constructor extracts the vision service from the dependencies map and stores it in the struct. This validates that the vision service exists on the machine and that methods on that struct in the module we're writing have access to it.
+
+Update `NewInspector` in `module.go`:
+
+```go
+func NewInspector(ctx context.Context, deps resource.Dependencies, name resource.Name, cfg *Config, logger logging.Logger) (resource.Resource, error) {
+    cancelCtx, cancelFunc := context.WithCancel(context.Background())
+
+    detector, err := vision.FromProvider(deps, cfg.VisionService)
+    if err != nil {
+        return nil, fmt.Errorf("failed to get vision service %q: %w", cfg.VisionService, err)
+    }
+
+    s := &inspectionModuleInspector{
+        name:       name,
+        logger:     logger,
+        cfg:        cfg,
+        cancelCtx:  cancelCtx,
+        cancelFunc: cancelFunc,
+        detector:   detector,
+    }
+    return s, nil
+}
+```
+
+`vision.FromProvider` looks up the resource by name and returns it as the correct type. If the resource doesn't exist or isn't a vision service, it returns an error.
+
+### Step 4: Add Detection Logic
+
+Now add the internal method that performs inspection, and update `DoCommand` to expose it.
+
+Add the `detect` method to `module.go` (lowercase—it's internal):
+
+```go
+func (s *inspectionModuleInspector) detect(ctx context.Context) (string, float64, error) {
+    detections, err := s.detector.DetectionsFromCamera(ctx, s.cfg.Camera, nil)
+    if err != nil {
+        return "", 0, err
+    }
+
+    if len(detections) == 0 {
+        return "NO_DETECTION", 0, nil
+    }
+
+    best := detections[0]
+    for _, det := range detections[1:] {
+        if det.Score() > best.Score() {
+            best = det
+        }
+    }
+
+    return best.Label(), best.Score(), nil
+}
+```
+
+`DetectionsFromCamera` tells the vision service which camera to use. The vision service grabs an image, runs the ML model, and returns structured detection results. We find the highest-confidence detection and return its label and score.
+
+Now update the generated `DoCommand` stub to dispatch to `detect`:
+
+```go
+func (s *inspectionModuleInspector) DoCommand(ctx context.Context, cmd map[string]interface{}) (map[string]interface{}, error) {
+    if _, ok := cmd["detect"]; ok {
+        label, confidence, err := s.detect(ctx)
+        if err != nil {
+            return nil, err
+        }
+        return map[string]interface{}{
+            "label":      label,
+            "confidence": confidence,
+        }, nil
+    }
+    return nil, fmt.Errorf("unknown command: %v", cmd)
+}
+```
+
+`DoCommand` is the public API for generic services. External callers pass a command map, and the method dispatches to internal logic. This pattern keeps implementation details private while exposing a flexible interface.
+
+### Step 5: Update the CLI
+
+Now wire everything together in `cmd/cli/main.go` so we can test. This replaces the camera test code from section 3.2.
+
+Replace the `realMain` function:
+
+```go
+func realMain() error {
+    ctx := context.Background()
+    logger := logging.NewLogger("cli")
+
+    host := flag.String("host", "", "Machine address (required)")
+    flag.Parse()
+
+    if *host == "" {
+        return fmt.Errorf("need -host flag (get address from Viam app)")
+    }
+
+    logger.Infof("Connecting to %s...", *host)
+    machine, err := vmodutils.ConnectToHostFromCLIToken(ctx, *host, logger)
+    if err != nil {
+        return fmt.Errorf("failed to connect: %w", err)
+    }
+    defer machine.Close(ctx)
+
+    cfg := &inspectionmodule.Config{
+        Camera:        "inspection-cam",
+        VisionService: "vision-service",
+    }
+
+    deps, err := vmodutils.MachineToDependencies(machine)
+    if err != nil {
+        return fmt.Errorf("failed to get dependencies: %w", err)
+    }
+
+    inspector, err := inspectionmodule.NewInspector(
+        ctx,
+        deps,
+        generic.Named("inspector"),
+        cfg,
+        logger,
+    )
+    if err != nil {
+        return fmt.Errorf("failed to create inspector: %w", err)
+    }
+
+    result, err := inspector.DoCommand(ctx, map[string]interface{}{"detect": true})
+    if err != nil {
+        return fmt.Errorf("detection failed: %w", err)
+    }
+
+    label := result["label"].(string)
+    confidence := result["confidence"].(float64)
+    logger.Infof("Detection: %s (%.1f%% confidence)", label, confidence*100)
+    return nil
+}
+```
+
+The CLI creates the inspector with dependencies from the remote machine, then calls `DoCommand` with `{"detect": true}`. This is the same pattern used in production Viam modules, where `DoCommand` is the public API for generic services.
+
+Update the imports:
+
+```go
+import (
+    "context"
+    "flag"
+    "fmt"
+
+    "inspectionmodule"
+    "github.com/erh/vmodutils"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/services/generic"
+)
+```
+
+### Test Detection
+
+Fetch dependencies and run:
+
+```bash
+go mod tidy
+go run ./cmd/cli/main.go -host YOUR_MACHINE_ADDRESS
+```
+
+You should see:
+
+```text
+Connecting to your-machine-main.abc123.viam.cloud...
+Detection: PASS (94.2% confidence)
+```
+
+Run it several times—results change as different cans pass under the camera.
+
+{{< alert title="What just happened" color="info" >}}
+Your laptop connected to the remote machine, your code called the vision service, and the vision service ran ML inference on an image from the camera. The code runs locally but uses remote hardware—this is the module-first pattern in action.
+{{< /alert >}}
+
+{{< expand "Troubleshooting" >}}
+**"failed to connect" or timeout errors:**
+
+- Verify your machine is online in the Viam app
+- Check that you've run `viam login` successfully
+- Confirm the host address is correct
+
+**"failed to get vision service" error:**
+
+- Verify `vision-service` exists in your machine config (Part 1)
+- Check the exact name matches—it's case-sensitive
+
+**"NO_DETECTION" result:**
+
+- Normal if no can is in view—wait for one to appear
+- Check the camera is working in the Viam app's Test panel
+  {{< /expand >}}
+
+{{< alert title="Checkpoint" color="success" >}}
+You can now detect cans from your laptop. You declared dependencies in Config, returned them from Validate, and extracted them in the constructor. This pattern works for any Viam resource.
+{{< /alert >}}
+
+## 3.4 Summary
+
+You built a complete inspection system using the module-first development pattern:
+
+1. **Generated** the module scaffold—infrastructure handled, you focus on logic
+2. **Connected** to remote hardware from local code using vmodutils
+3. **Implemented detection** by calling the vision service and exposing results through `DoCommand`
+
+{{< alert title="Extending the inspector" color="tip" >}}
+In a production system, you could extend `DoCommand` to trigger actuators—for example, a motor that pushes defective cans off the belt. The same dependency injection pattern applies: declare the motor in Config, extract it in the constructor, and call it from your detection logic.
+{{< /alert >}}
+
+### What You Learned
+
+| Concept                      | What It Means                                         | Where You'll Use It                      |
+| ---------------------------- | ----------------------------------------------------- | ---------------------------------------- |
+| **Module-first development** | Test against real hardware without deploying          | Any time you're developing control logic |
+| **Dependency injection**     | Declare what you need, let Viam provide it            | Every module you build                   |
+| **DoCommand pattern**        | Expose functionality through a flexible map-based API | Any generic service                      |
+
+### The Key Insight
+
+Your inspector code doesn't know whether it's running from the CLI on your laptop or deployed as a module on the machine. It just uses the dependencies it's given. This abstraction is what makes rapid iteration possible during development and seamless deployment to production.
+
+**Your code is ready.** In Part 4, you'll deploy it to run on the machine and configure data capture for the detection results.
+
+**[Continue to Part 4: Deploy a Module →](../part-4/)**
diff --git a/docs/try/part-4.md b/docs/try/part-4.md
new file mode 100644
index 0000000000..27d00dae01
--- /dev/null
+++ b/docs/try/part-4.md
@@ -0,0 +1,407 @@
+---
+linkTitle: "Part 4: Deploy a Module"
+title: "Part 4: Deploy a Module"
+weight: 40
+layout: "docs"
+type: "docs"
+description: "Deploy your inspector module and configure queryable detection data capture."
+date: "2025-01-30"
+aliases:
+  - /try/first-project/part-4/
+---
+
+**Goal:** Deploy your inspector to run on the machine autonomously.
+
+**Skills:** Module packaging, registry deployment, tabular data capture.
+
+**Time:** ~10 min
+
+## What You'll Do
+
+In Part 3, you built inspection logic that runs from your laptop. That's great for development, but in production the code needs to run on the machine itself—so it works even when your laptop is closed.
+
+The module generator already created most of what you need:
+
+- `cmd/module/main.go`—module entry point
+- `meta.json`—registry metadata
+- Model registration in `init()`
+
+You just need to build, package, and deploy.
+
+## 4.1 Review the Generated Module Structure
+
+The generator already created everything needed to run as a module. Let's review what's there.
+
+**`cmd/module/main.go`**
+
+```go
+func main() {
+    module.ModularMain(
+        resource.APIModel{API: generic.API, Model: inspectionmodule.Inspector},
+    )
+}
+```
+
+This connects your module to viam-server and registers the inspector model. When you add this service to your machine configuration, viam-server uses this entry point to create and manage instances. You don't need to modify it.
+
+{{< alert title="What is a model?" color="info" >}}
+In Viam, a _model_ is a specific implementation of an API—identified by a triplet like `your-namespace:inspection-module:inspector`. This can be confusing because we also refer to ML models as "models." When you see "model" in the context of modules and resources, it means the implementation type, not a machine learning model.
+{{< /alert >}}
+
+**`module.go`** provides model registration in `init()`:
+
+The generator created an `init()` function that registers your model:
+
+```go
+var Inspector = resource.NewModel("your-namespace", "inspection-module", "inspector")
+
+func init() {
+    resource.RegisterService(generic.API, Inspector,
+        resource.Registration[resource.Resource, *Config]{
+            Constructor: newInspectionModuleInspector,
+        },
+    )
+}
+```
+
+Note the two uses of "inspector" here:
+
+- `Inspector` (capital I)—the Go variable name, exported so `main.go` can reference it
+- `"inspector"` (lowercase, in quotes)—a string that becomes the third part of the model triplet `your-namespace:inspection-module:inspector`
+
+This `init()` function runs automatically when the module starts, telling viam-server how to create instances of your service.
+
+**`meta.json`** Registry metadata:
+
+```json
+{
+  "module_id": "your-namespace:inspection-module",
+  "visibility": "private",
+  "models": [
+    {
+      "api": "rdk:service:generic",
+      "model": "your-namespace:inspection-module:inspector"
+    }
+  ],
+  "entrypoint": "bin/inspection-module"
+}
+```
+
+This tells the registry what your module provides.
+
+{{< alert title="The key pattern" color="tip" >}}
+The generator created module infrastructure. You added business logic (`detect`) and exposed it through `DoCommand`. The same `NewInspector` constructor works for both CLI testing and module deployment.
+{{< /alert >}}
+
+## 4.2 Build and Upload Your Module
+
+**Update the module's model list:**
+
+The module was already registered in the Viam registry when you ran `viam module generate` in Part 3 (you answered "Yes" to "Register module"). Now you need to update its model metadata. First, build a local binary:
+
+```bash
+make
+```
+
+Then run `update-models` to detect which models your module provides and update `meta.json`:
+
+```bash
+viam module update-models --binary /full/path/to/bin/inspection-module
+```
+
+Replace `/full/path/to/` with the absolute path to your module directory.
+
+**Cross-compile for the target platform:**
+
+Your module will run inside a Linux container, not on your development machine. Even if your Mac and the container both use ARM processors, a macOS binary won't run on Linux—you need to cross-compile. Cross-compilation also requires disabling CGO (Go's C interop) and using the `no_cgo` build tag.
+
+{{< tabs >}}
+{{% tab name="Mac (Apple Silicon)" %}}
+
+```bash
+CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -tags no_cgo -o bin/inspection-module ./cmd/module
+```
+
+{{% /tab %}}
+{{% tab name="Mac (Intel)" %}}
+
+```bash
+CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -tags no_cgo -o bin/inspection-module ./cmd/module
+```
+
+{{% /tab %}}
+{{% tab name="Windows" %}}
+
+```bash
+CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -tags no_cgo -o bin/inspection-module ./cmd/module
+```
+
+{{% /tab %}}
+{{% tab name="Linux (Intel/AMD)" %}}
+
+```bash
+go build -o bin/inspection-module ./cmd/module
+```
+
+No cross-compilation needed—you're already on Linux.
+
+{{% /tab %}}
+{{% tab name="Linux (ARM)" %}}
+
+```bash
+go build -o bin/inspection-module ./cmd/module
+```
+
+No cross-compilation needed—you're already on Linux.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+**Package for upload:**
+
+```bash
+tar czf module.tar.gz meta.json bin/
+```
+
+**Upload to the registry:**
+
+The `--platform` flag must match the architecture you compiled for:
+
+{{< tabs >}}
+{{% tab name="Mac (Apple Silicon)" %}}
+
+```bash
+viam module upload --version 0.0.1 --platform linux/arm64 --upload module.tar.gz
+```
+
+{{% /tab %}}
+{{% tab name="Mac (Intel)" %}}
+
+```bash
+viam module upload --version 0.0.1 --platform linux/amd64 --upload module.tar.gz
+```
+
+{{% /tab %}}
+{{% tab name="Windows" %}}
+
+```bash
+viam module upload --version 0.0.1 --platform linux/amd64 --upload module.tar.gz
+```
+
+{{% /tab %}}
+{{% tab name="Linux (Intel/AMD)" %}}
+
+```bash
+viam module upload --version 0.0.1 --platform linux/amd64 --upload module.tar.gz
+```
+
+{{% /tab %}}
+{{% tab name="Linux (ARM)" %}}
+
+```bash
+viam module upload --version 0.0.1 --platform linux/arm64 --upload module.tar.gz
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## 4.3 Add the Module to Your Machine
+
+**Add the inspector service:**
+
+1. In the Viam app, go to your machine's **Configure** tab
+2. Click **+** next to your machine part
+3. Select **Component or service**
+4. Search for your model (for example, `your-namespace:inspection-module:inspector`)
+5. Name it `inspector-service`
+6. Click **Create**
+
+When you add a service from the registry, the module that provides it is added automatically.
+
+**Configure the service attributes:**
+
+```json
+{
+  "camera": "inspection-cam",
+  "vision": "vision-service"
+}
+```
+
+Click **Save**.
+
+**Verify it started:**
+
+1. Go to the **Logs** tab
+2. Look for startup messages from the inspector module
+3. You should see it initialize and connect to the camera and vision service
+
+**Test the inspector:**
+
+1. In the **CONFIGURE** tab, click on `inspector-service` to open its configuration panel
+2. Expand the **Test** section at the bottom
+3. Expand **DoCommand** and enter `{"detect": true}`
+4. Click **Execute**
+5. You should see a response with `label` and `confidence` values
+6. Click **Execute** several more times to see different detections as cans pass beneath the inspection-cam
+
+{{<imgproc src="/tutorials/first-project/docommand-test.png" resize="x1100" declaredimensions=true alt="DoCommand test panel showing detection result with label PASS and confidence score." class="imgzoom shadow">}}
+
+The module is now ready. You'll configure automatic detection in the next section.
+
+## 4.4 Configure Detection Data Capture
+
+In Part 2, you captured images from the vision service. Those images are great for visual review, but they're binary data—you can't query them with SQL. Now you'll configure **tabular data capture** on your inspector's DoCommand, which will let you query detection results.
+
+**Add inspector-service as a data manager dependency:**
+
+The data manager needs to know about your inspector service before it can capture data from it. You'll add this dependency in the JSON configuration.
+
+1. In the **CONFIGURE** tab, click **JSON** in the upper left
+2. Find the `data-service` entry in the `services` array
+3. Add `"depends_on": ["inspector-service"]` to the data-service configuration:
+
+   ```json
+   {
+     "name": "data-service",
+     "api": "rdk:service:data_manager",
+     "model": "rdk:builtin:builtin",
+     "attributes": { ... },
+     "depends_on": ["inspector-service"]
+   }
+   ```
+
+4. Click **Save**
+
+This tells viam-server to wait for `inspector-service` to initialize before the data manager tries to capture data from it.
+
+**Enable data capture on the inspector:**
+
+1. In the **CONFIGURE** tab, click on `inspector-service` to open its configuration panel
+2. Click the **Data Capture** button
+3. Select the method: `DoCommand`
+4. Set **Frequency (hz)** to `0.5` (captures every 2 seconds)
+5. In the **Additional parameters** section, add the DoCommand input:
+
+   ```json
+   {
+     "detect": true
+   }
+   ```
+
+6. **Save** your configuration
+
+This configuration tells the data manager to periodically call `DoCommand({"detect": true})` on your inspector and capture the response—which includes `label` and `confidence`.
+
+**Query detection results:**
+
+After a few minutes of data collection, you can query the results:
+
+1. Open the **Data** tab in the Viam app
+2. Click **Query**
+3. Select **SQL** as your query language
+
+   {{<imgproc src="/tutorials/first-project/data-query-sql.png" resize="x1100" declaredimensions=true alt="Data Query interface with SQL selected." class="imgzoom shadow">}}
+
+4. Run a query to see recent detections:
+
+   ```sql
+   SELECT time_received, component_name, data
+   FROM readings
+   ORDER BY time_received DESC
+   LIMIT 10
+   ```
+
+   You can also filter to show only failures:
+
+   ```sql
+   SELECT time_received,
+          data.docommand_output.label,
+          data.docommand_output.confidence
+   FROM readings
+   WHERE data.docommand_output.label = 'FAIL'
+   ORDER BY time_received DESC
+   LIMIT 10
+   ```
+
+**Understanding the data structure:**
+
+Each captured detection is stored as a JSON document. Here's what the data looks like:
+
+```json
+{
+  "component_name": "inspector-service",
+  "component_type": "rdk:service:generic",
+  "method_name": "DoCommand",
+  "time_received": "2026-02-02T02:23:27.326Z",
+  "data": {
+    "docommand_output": {
+      "label": "PASS",
+      "confidence": 0.9999136328697205
+    }
+  },
+  "additional_parameters": {
+    "docommand_input": {
+      "detect": true
+    }
+  },
+  "organization_id": "...",
+  "location_id": "...",
+  "robot_id": "...",
+  "part_id": "..."
+}
+```
+
+The key fields for analysis are nested under `data.docommand_output`:
+
+- `label`: The detection result—`PASS`, `FAIL`, or `NO_DETECTION`
+- `confidence`: How confident the model is (0.0 to 1.0)
+
+**Querying with MQL:**
+
+You can also query using MQL (MongoDB Query Language), which is useful for aggregations. Select **MQL** in the Query interface. For example, to count failures by hour:
+
+```javascript
+[
+  {
+    $match: {
+      component_name: "inspector-service",
+      "data.docommand_output.label": "FAIL",
+    },
+  },
+  {
+    $group: {
+      _id: { $dateTrunc: { date: "$time_received", unit: "hour" } },
+      count: { $sum: 1 },
+    },
+  },
+  { $sort: { _id: -1 } },
+];
+```
+
+You'll use MQL aggregation pipelines in Part 5 to build dashboard widgets.
+
+{{< alert title="Two types of captured data" color="info" >}}
+You now have two complementary data streams:
+
+- **Vision service images** (Part 2): Visual records for review and model retraining
+- **Inspector tabular data** (this section): Queryable detection results for analytics
+
+The images show what the system saw; the tabular data tracks what it decided.
+{{< /alert >}}
+
+## 4.5 Summary
+
+You deployed your inspection logic as a Viam module:
+
+1. **Reviewed**—the generator already created module structure and registration
+2. **Deployed**—built, packaged, uploaded, configured
+3. **Configured data capture**—detection results are now queryable
+
+**The development pattern:**
+
+- During development: CLI runs locally, uses remote hardware (fast iteration)
+- In production: Module runs on machine, same code (autonomous operation)
+
+**Your inspection system now runs 24/7** detecting defects without your laptop connected.
+
+**[Continue to Part 5: Productize →](../part-5/)**
diff --git a/docs/try/part-5.md b/docs/try/part-5.md
new file mode 100644
index 0000000000..69e953ee60
--- /dev/null
+++ b/docs/try/part-5.md
@@ -0,0 +1,267 @@
+---
+linkTitle: "Part 5: Productize"
+title: "Part 5: Productize"
+weight: 50
+layout: "docs"
+type: "docs"
+description: "Build a monitoring dashboard for your inspection system using Viam's Teleop interface."
+date: "2025-01-30"
+aliases:
+  - /operate/hello-world/first-project/part-6/
+  - /try/first-project/part-5/
+---
+
+**Goal:** Build a dashboard to monitor your inspection system.
+
+**Skills:** Creating Teleop workspaces, configuring dashboard widgets, writing MQL aggregation pipelines.
+
+**Time:** ~10 min
+
+## What You'll Build
+
+You've built a working inspection system—but monitoring it requires navigating through the Viam app's configuration and data tabs. In this section, you'll create a dedicated dashboard that shows everything at a glance: live camera feeds and defect trends over time.
+
+Viam's Teleop interface lets you create custom monitoring dashboards. You'll add widgets for camera streams and time series graphs that use MQL aggregation pipelines to analyze your detection data.
+
+## 5.1 Create a Workspace
+
+A workspace is a custom dashboard view for your machines.
+
+1. In the Viam app, go to **Fleet** → **Teleop**
+2. Click **+ Create workspace**
+3. Replace the placeholder name with `inspection`
+4. In **Select location**, choose `Home` (or your location name)
+5. In **Select machine**, choose `inspection-station-1`
+
+{{<imgproc src="/tutorials/first-project/teleop-workspaces.png" resize="x1100" declaredimensions=true alt="Teleop workspaces page showing the Create workspace button." class="imgzoom shadow">}}
+
+You now have an empty workspace ready for widgets.
+
+## 5.2 Add a camera stream widget
+
+Add a live video feed from your inspection camera.
+
+1. Click **+ Add widget**
+2. Select **Camera stream**
+3. Click the pencil icon to configure
+4. Set **Camera name** to `inspection-cam`
+5. Set **Refresh type** to `Live`
+6. Click **Save**
+
+You should see the live feed from your inspection camera with cans passing on the conveyor belt.
+
+## 5.3 Add a Defects Per Minute Widget
+
+Now you'll create a time series graph showing how many defective cans are detected per minute. This requires a custom MQL aggregation pipeline to filter for failures and count them in time buckets.
+
+**Recall the data structure** from Part 4—each detection looks like:
+
+```json
+{
+  "component_name": "inspector-service",
+  "time_received": "2026-02-02T02:23:27.326Z",
+  "data": {
+    "docommand_output": {
+      "label": "FAIL",
+      "confidence": 0.965815
+    }
+  }
+}
+```
+
+You'll write MQL stages that filter for `FAIL` labels and count them per minute.
+
+**Create the widget:**
+
+1. Click **+ Add widget**
+2. Select **Time series**
+3. Click the pencil icon to configure
+4. Set **Title** to `Defective cans per minute`
+5. Set **Time range (min)** to `60`
+6. Set **Refetch rate (sec)** to `60`
+7. Leave **Y axis lower bound** and **Y axis upper bound** as `auto`
+
+**Configure the line:**
+
+8. Set **Resource name** to `inspector-service`
+9. Set **Capture method** to `DoCommand`
+10. Set **Title** to `Defects`
+11. For **Window method**, select **Custom query**
+
+**Add the MQL stages:**
+
+The custom query method lets you write MongoDB aggregation pipeline stages. You need three stages: match, group, and project.
+
+12. In **Custom MQL Stages**, add a `$match` stage to filter for failures only:
+
+    ```json
+    {
+      "$match": {
+        "data.docommand_output.label": "FAIL"
+      }
+    }
+    ```
+
+13. Click **+ Add stage** and add a `$group` stage to count failures per 60-second bucket:
+
+    ```json
+    {
+      "$group": {
+        "_id": {
+          "$dateTrunc": {
+            "date": "$time_received",
+            "unit": "second",
+            "binSize": 60
+          }
+        },
+        "value": {
+          "$sum": 1
+        }
+      }
+    }
+    ```
+
+14. Click **+ Add stage** and add a `$project` stage to format the output:
+
+    ```json
+    {
+      "$project": {
+        "time": "$_id",
+        "value": true
+      }
+    }
+    ```
+
+15. Click **Save**
+
+The graph now shows the count of defective cans detected in each minute.
+
+{{< alert title="How the pipeline works" color="info" >}}
+
+- **$match** filters to only FAIL detections
+- **$group** buckets data into 60-second intervals and counts documents in each bucket
+- **$project** renames `_id` to `time` (required format for the graph)
+
+<!-- prettier-ignore -->
+{{< /alert >}}
+
+## 5.4 Add a Confidence Trend Widget
+
+Add another time series showing the average confidence of failure detections over time. This helps you monitor model performance—if confidence drops, you may need to retrain.
+
+1. Click **+ Add widget**
+2. Select **Time series**
+3. Click the pencil icon to configure
+4. Set **Title** to `Confidence`
+5. Set **Time range (min)** to `60`
+6. Set **Refetch rate (sec)** to `60`
+7. Set **Y axis lower bound** to `0`
+8. Set **Y axis upper bound** to `1`
+
+**Configure the line:**
+
+9. Set **Resource name** to `inspector-service`
+10. Set **Capture method** to `DoCommand`
+11. Set **Title** to `FAIL confidence`
+12. For **Window method**, select **Custom query**
+
+**Add the MQL stages:**
+
+13. Add a `$match` stage:
+
+    ```json
+    {
+      "$match": {
+        "data.docommand_output.label": "FAIL"
+      }
+    }
+    ```
+
+14. Click **+ Add stage** and add a `$group` stage that averages confidence:
+
+    ```json
+    {
+      "$group": {
+        "_id": {
+          "$dateTrunc": {
+            "date": "$time_received",
+            "unit": "second",
+            "binSize": 60
+          }
+        },
+        "value": {
+          "$avg": {
+            "$convert": {
+              "input": "$data.docommand_output.confidence",
+              "to": "double",
+              "onError": "$data.docommand_output.confidence"
+            }
+          }
+        }
+      }
+    }
+    ```
+
+15. Click **+ Add stage** and add a `$project` stage:
+
+    ```json
+    {
+      "$project": {
+        "time": "$_id",
+        "value": true
+      }
+    }
+    ```
+
+16. Click **Save**
+
+The graph shows average confidence for failure detections over time.
+
+{{< alert title="Why use $convert?" color="info" >}}
+The `$convert` operator ensures the confidence value is treated as a number for averaging. The `onError` fallback handles any edge cases where conversion fails.
+{{< /alert >}}
+
+## 5.5 Arrange Your Dashboard
+
+Drag widgets to create a useful layout:
+
+1. Click and drag the grid icon in the top-left corner of each widget
+2. Position the camera stream on the right for real-time monitoring
+3. Stack the time series graphs on the left to compare defect counts and confidence trends
+
+Your dashboard now provides a complete view of your inspection system:
+
+- **Live video** showing the inspection in progress
+- **Defects per minute** tracking production quality
+- **Confidence trend** monitoring model performance
+
+{{<imgproc src="/tutorials/first-project/finished-dashboard.png" resize="x1100" declaredimensions=true alt="Finished dashboard showing Defective cans per minute graph, Confidence graph, and live camera stream." class="imgzoom shadow">}}
+
+## 5.6 Summary
+
+You've created a monitoring dashboard using MQL aggregation pipelines:
+
+1. **Created a workspace** for your inspection station
+2. **Added a camera stream** for live video monitoring
+3. **Built a defects graph** using $match → $group (count) → $project
+4. **Built a confidence graph** using $match → $group (average) → $project
+
+The same MQL pipeline pattern—filter, aggregate, project—can be adapted for other metrics: pass rate, throughput, detection latency, or any data your system captures.
+
+{{< alert title="Going further" color="tip" >}}
+For fully custom dashboards with your own branding, you can [build a custom app](/build-apps/) using the TypeScript, Flutter, Python, or Go SDK. The SDK provides access to the same data through `tabularDataByMQL()` and `tabularDataBySQL()` methods.
+{{< /alert >}}
+
+## Congratulations
+
+You've completed the tutorial. Here's what you built:
+
+1. **Vision Pipeline**—Camera, ML model, and vision service detecting defects
+2. **Data Capture**—Automatic recording and cloud sync of images and detections
+3. **Control Logic**—Custom inspector module exposing detection through DoCommand
+4. **Module Deployment**—Packaged and deployed to run autonomously
+5. **Productize**—Monitoring dashboard with real-time analytics
+
+You've gone from an empty machine to a production-ready inspection system with monitoring—patterns that apply to any Viam application.
+
+**[← Back to Overview](../overview/)** to review what you learned.
diff --git a/docs/tutorials/_index.md b/docs/tutorials/_index.md
index 91815c23b8..aee6225be4 100644
--- a/docs/tutorials/_index.md
+++ b/docs/tutorials/_index.md
@@ -4,7 +4,9 @@ linkTitle: "Tutorials"
 weight: 300
 type: docs
 layout: "empty"
-canonical: "/dev/tools/tutorials/"
+canonical: "/tutorials/"
+aliases:
+  - /dev/tools/tutorials/
 toc_hide: true
 # do not remove hide children - it causes a layout issue
 no_list: true
diff --git a/docs/tutorials/configure/configure-rover.md b/docs/tutorials/configure/configure-rover.md
index 73f7cb2636..71e2b47716 100644
--- a/docs/tutorials/configure/configure-rover.md
+++ b/docs/tutorials/configure/configure-rover.md
@@ -28,7 +28,7 @@ This tutorial will guide you through configuring a rover.
 If you are using a SCUTTLE, a Yahboom rover, or a different rover, this tutorial covers instructions for your rover model.
 
 {{< alert title="Viam Rover" color="note" >}}
-If you are using a Viam Rover, use the [Viam Rover tutorial fragment](/dev/reference/try-viam/rover-resources/rover-tutorial-fragments/) instead.
+If you are using a Viam Rover, use the [Viam Rover tutorial fragment](/try/) instead.
 {{< /alert >}}
 
 ## Requirements
diff --git a/docs/tutorials/configure/pet-photographer.md b/docs/tutorials/configure/pet-photographer.md
index eb706c7786..d1edd5eb3d 100644
--- a/docs/tutorials/configure/pet-photographer.md
+++ b/docs/tutorials/configure/pet-photographer.md
@@ -24,7 +24,7 @@ After following this tutorial, you will understand how to control sync parameter
 Note: Consider this tutorial alongside filtered camera tutorial.
 -->
 
-If your machine [captures](/data-ai/capture-data/capture-sync/) a lot of data, you might want to filter captured data to selectively store only the data you are interested in.
+If your machine [captures](/data/capture-sync/capture-and-sync-data/) a lot of data, you might want to filter captured data to selectively store only the data you are interested in.
 For example, you might want to use your smart machine's camera to capture images based on specific criteria, such as the presence of a certain color, and omit captured images that don't meet that criteria.
 
 In this tutorial, you will use a custom {{< glossary_tooltip term_id="module" text="module" >}} to function as a color filter, and use it with a [camera](/operate/reference/components/camera/) to only capture images where your pet is in the frame in the following way:
@@ -161,7 +161,7 @@ For more information, refer to [Write your new resource model definition](/opera
 
 The filter function in your custom filter module must contain two critical elements:
 
-1. A utility function that will check if the caller of the filter function is the [data management service](/data-ai/capture-data/capture-sync/).
+1. A utility function that will check if the caller of the filter function is the [data management service](/data/capture-sync/capture-and-sync-data/).
 1. A safeguard that ensures if the data management service is not the caller, an error and the unfiltered data is returned.
 
 {{< alert title="Important" color="note" >}}
@@ -833,12 +833,12 @@ Whether you've downloaded the `colorfilter` module, or written your own color fi
 
 Next, add the following services to your smart machine to support the color filter module:
 
-- The [data management service](/data-ai/capture-data/capture-sync/) enables your smart machine to capture data and sync it to the cloud.
-- The [vision service](/dev/reference/apis/services/vision/#detections) enables your smart machine to perform color detection on objects in a camera stream.
+- The [data management service](/data/capture-sync/capture-and-sync-data/) enables your smart machine to capture data and sync it to the cloud.
+- The [vision service](/reference/apis/services/vision/#detections) enables your smart machine to perform color detection on objects in a camera stream.
 
 ### Add the data management service
 
-To enable data capture on your machine, add and configure the [data management service](/data-ai/capture-data/capture-sync/) to capture and store data on your machine's computer:
+To enable data capture on your machine, add and configure the [data management service](/data/capture-sync/capture-and-sync-data/) to capture and store data on your machine's computer:
 
 {{< tabs >}}
 {{% tab name="Config Builder" %}}
@@ -855,7 +855,7 @@ To enable data capture on your machine, add and configure the [data management s
 
    ![An instance of the data management service named "dm". The cloud sync and capturing options are toggled on and the directory is empty. The interval is set to 0.1](/tutorials/pet-photographer/data-management-services.png)
 
-   For more detailed information, see [Add the data management service](/data-ai/capture-data/capture-sync/).
+   For more detailed information, see [Add the data management service](/data/capture-sync/capture-and-sync-data/).
    {{% /tab %}}
    {{% tab name="JSON Template" %}}
    Add the data management service to the services array in your rover’s raw JSON configuration:
@@ -892,7 +892,7 @@ If you have a different item you want to use, or want to match to a color that m
 1. Enter a name or use the suggested name for your color detector.
    This tutorial uses the name 'my_color_detector' in all example code.
 1. click **Create**.
-1. In the vision service's **Attributes** section, click the color selection box to set the color to be detected.
+1. In the vision service's **Attributes** section, click the color selection box to set the color to detect.
    For this tutorial, set the color to `#43A1D0` or `rgb(67, 161, 208)`.
    Alternatively, you can provide the color of your pet, or use a different brightly-colored collar or ribbon.
 1. Set **Hue Tolerance** to `0.06` and **Segment size px** to `100`.
@@ -1012,5 +1012,5 @@ Try these other tutorials for more on working with the data management and visio
 {{% card link="/tutorials/projects/pet-treat-dispenser/" %}}
 {{% card link="/tutorials/projects/guardian/" %}}
 {{% card link="/tutorials/projects/send-security-photo/" %}}
-{{% card link="/data-ai/ai/deploy/"  %}}
+{{% card link="/vision/configure/"  %}}
 {{< /cards >}}
diff --git a/docs/tutorials/control/air-quality-fleet.md b/docs/tutorials/control/air-quality-fleet.md
index 5ae67d4eb2..ea6f60ef51 100644
--- a/docs/tutorials/control/air-quality-fleet.md
+++ b/docs/tutorials/control/air-quality-fleet.md
@@ -172,7 +172,7 @@ If you do not see readings, check the **LOGS** tab for errors, double-check that
 ### Configure data management
 
 You have configured the sensor so the board can communicate with it, but sensor data is not yet being saved anywhere.
-Viam's [data management service](/data-ai/capture-data/capture-sync/) lets you capture data locally from each sensor and then sync it to the cloud where you can access historical sensor data and see trends over time.
+Viam's [data management service](/data/capture-sync/capture-and-sync-data/) lets you capture data locally from each sensor and then sync it to the cloud where you can access historical sensor data and see trends over time.
 As you configure more sensing machines, you'll be able to remotely access data from all machines.
 
 {{< table >}}
@@ -877,7 +877,7 @@ You, as the organization owner, will be able to manage any necessary configurati
 
 {{<imgproc class="imgzoom" src="/tutorials/air-quality-fleet/example-org-structure.png" resize="x900" declaredimensions=true alt="Diagram of the Pollution Monitoring Made Simple organization. In it are two locations: Antonia's HOme and Robots R Us. Robots R Us contains two sub-locations, each containing some machines. The Antonia's Home location contains two machines (and no sub-locations)." style="width:800px">}}
 
-For more information, see [Organize your machines](/manage/reference/organize/) and [Provision devices](/manage/fleet/provision/setup/).
+For more information, see [Organize your machines](/reference/) and [Provision devices](/fleet/provision-devices/).
 
 ### Organize your fleet
 
@@ -929,7 +929,7 @@ In this section you will create the {{< glossary_tooltip term_id="fragment" text
 
    If you only have one USB device plugged into each of your boards, the `usb_interface` value you configured in the sensor config is likely (conveniently) the same for all of your machines.
 
-   If not, you can use [fragment overwrite](/manage/fleet/reuse-configuration/#modify-fragment-settings-on-a-machine) to modify the value on any machine for which it is different.
+   If not, you can use [fragment overwrite](/fleet/reuse-configuration/) to modify the value on any machine for which it is different.
 
 1. Specify the version for the `sds011` module.
    At the time of writing the version is `0.2.1`.
@@ -975,7 +975,7 @@ Paste the machine cloud credentials into a file on your hard drive called <FILE>
 You will pass the file to the preinstall script later, so you can store it anywhere.
 
 {{< alert title="Tip: Fleet management API" color="tip" >}}
-You can create locations and machines programmatically, with the [Fleet management API](/dev/reference/apis/fleet/).
+You can create locations and machines programmatically, with the [Fleet management API](/reference/apis/fleet/).
 {{< /alert >}}
 
 {{% /tablestep %}}
@@ -1035,7 +1035,7 @@ That's it!
 Your device is now provisioned and ready for your end user!
 
 Having trouble?
-See [Provisioning](/manage/fleet/provision/setup/) for more information and troubleshooting.
+See [Provisioning](/fleet/provision-devices/) for more information and troubleshooting.
 
 ## Update your web application
 
@@ -1064,5 +1064,5 @@ For an example of setting up text alerts, see the [Detect a Person and Send a Ph
 {{< cards >}}
 {{% card link="/tutorials/projects/helmet/" %}}
 {{% card link="/tutorials/projects/send-security-photo/" %}}
-{{% card link="/data-ai/data/visualize/" %}}
+{{% card link="/data/visualize-data/" %}}
 {{< /cards >}}
diff --git a/docs/tutorials/control/control-motor.md b/docs/tutorials/control/control-motor.md
index 4e9d78eb5c..f42059dcdb 100644
--- a/docs/tutorials/control/control-motor.md
+++ b/docs/tutorials/control/control-motor.md
@@ -136,7 +136,7 @@ Use the **Backwards** and **Forwards** buttons to change the direction.
 
 ### Option 2: Control from the mobile app
 
-You can use [the Viam mobile app](/manage/troubleshoot/teleoperate/default-interface/#viam-mobile-app) to control your motor's speed and direction directly from your smart phone.
+You can use [the Viam mobile app](/monitor/default-interface/#viam-mobile-app) to control your motor's speed and direction directly from your smart phone.
 
 Open the Viam mobile app and log in to your account.
 Select the location that your machine is in from the **Locations** tab.
diff --git a/docs/tutorials/control/drive-rover.md b/docs/tutorials/control/drive-rover.md
index f650806609..6b59830c0d 100644
--- a/docs/tutorials/control/drive-rover.md
+++ b/docs/tutorials/control/drive-rover.md
@@ -46,7 +46,7 @@ You don't need to buy or own any hardware to complete this tutorial.
 You only need the following:
 
 - A Linux, macOS or Windows computer that can run SDK code.
-- A [borrowed Viam Rover](https://app.viam.com/try), [your own Viam Rover](/dev/reference/try-viam/rover-resources/), or [another mobile robot](/tutorials/configure/configure-rover/).
+- A [borrowed Viam Rover](https://app.viam.com/try), [your own Viam Rover](/try/), or [another mobile robot](/tutorials/configure/configure-rover/).
   You can use [Try Viam](https://app.viam.com/try) to borrow a rover online at no cost which is already configured with all the components you need.
   If you have your own rover on hand, whether it's a [Viam rover](https://www.viam.com/resources/rover) or not, these instructions work for any wheeled robot that can be configured as a [base component](/operate/reference/components/base/wheeled/).
 
@@ -62,7 +62,7 @@ Go to [Try Viam](https://app.viam.com/try) and borrow a rover.
 If a rover is available, the rover will take up to 30 seconds to be configured for you.
 
 {{< alert title="Tip" color="tip" >}}
-If you are running out of time during your session, you can [extend your rover session](/dev/reference/try-viam/reserve-a-rover/#extend-your-reservation) as long as there are no other reservations.
+If you are running out of time during your session, you can [extend your rover session](/try/) as long as there are no other reservations.
 {{< /alert >}}
 
 {{< /expand >}}
@@ -87,7 +87,7 @@ To install your preferred Viam SDK on your Linux or macOS development machine or
 {{< tabs >}}
 {{% tab name="Python" %}}
 
-If you are using the Python SDK, [set up a virtual environment](/dev/reference/sdks/python/python-venv/) to package the SDK inside before running your code, avoiding conflicts with other projects or your system.
+If you are using the Python SDK, [set up a virtual environment](/reference/sdks/python/python-venv/) to package the SDK inside before running your code, avoiding conflicts with other projects or your system.
 
 For macOS (both Intel `x86_64` and Apple Silicon) or Linux (`x86`, `aarch64`, `armv6l`), run the following commands:
 
@@ -819,7 +819,7 @@ Then run your code and watch your rover move in a square.
 
 {{% alert title="Tip" color="tip" %}}
 
-If you are interested to learn about what other commands you can give to a base, see the standardized [base API](/dev/reference/apis/components/base/#api) for a full list of available API methods.
+If you are interested to learn about what other commands you can give to a base, see the standardized [base API](/reference/apis/components/base/#api) for a full list of available API methods.
 {{% /alert %}}
 
 {{< /expand>}}
diff --git a/docs/tutorials/control/flutter-app.md b/docs/tutorials/control/flutter-app.md
index 8e96b4eca1..03b6d942bc 100644
--- a/docs/tutorials/control/flutter-app.md
+++ b/docs/tutorials/control/flutter-app.md
@@ -29,7 +29,7 @@ Notes:
 </div>
 
 Flutter is Google's user interface toolkit for building applications for mobile, web, and desktop from a single codebase.
-If you're looking to monitor and control individual machines with the same functionality you have on the [**CONTROL** tab](/manage/troubleshoot/teleoperate/default-interface/#web-ui), you can use the general-purpose [Viam mobile app](/manage/troubleshoot/teleoperate/default-interface/#viam-mobile-app) rather than creating your own.
+If you're looking to monitor and control individual machines with the same functionality you have on the [**CONTROL** tab](/monitor/default-interface/#web-ui), you can use the general-purpose [Viam mobile app](/monitor/default-interface/#viam-mobile-app) rather than creating your own.
 If you need custom functionality or a custom interface, you can use Viam's [Flutter SDK](https://flutter.viam.dev/) to build a custom app to interact with your machines that run on Viam.
 
 This tutorial guides you through creating a mobile app that shows your machines and their components.
diff --git a/docs/tutorials/custom/controlling-an-intermode-rover-canbus.md b/docs/tutorials/custom/controlling-an-intermode-rover-canbus.md
index a872341232..27f0993daf 100644
--- a/docs/tutorials/custom/controlling-an-intermode-rover-canbus.md
+++ b/docs/tutorials/custom/controlling-an-intermode-rover-canbus.md
@@ -47,8 +47,8 @@ Once you specify the circumference of the wheels and how far they are apart, you
 
 However, some rovers or other mobile robots do not expose direct motor control.
 For these types of machines, this tutorial shows you how to create a {{< glossary_tooltip term_id="modular-resource" text="modular resource" >}}.
-Creating a modular resource for your robot allows you to issue commands using the same [`base` interface](/dev/reference/apis/components/base/#api) as you would with builtin Viam components.
-Once you have created the custom component, you can control both the Viam components and the modular resources using any of the [Viam SDKs](/dev/reference/apis/).
+Creating a modular resource for your robot allows you to issue commands using the same [`base` interface](/reference/apis/components/base/#api) as you would with builtin Viam components.
+Once you have created the custom component, you can control both the Viam components and the modular resources using any of the [Viam SDKs](/reference/apis/).
 Even if your modular resource is built in Golang, you can use the Python, C++, or any other Viam SDK to issue commands.
 
 {{% alert title="Tip" color="tip"%}}
@@ -115,7 +115,7 @@ You can now power up the rover, which also provides power to your Pi and allows
 
 ## A modular resource for the Intermode base
 
-The Viam platform provides [APIs](/dev/reference/apis/) for common component types within `viam-server`.
+The Viam platform provides [APIs](/reference/apis/) for common component types within `viam-server`.
 For controlling a mobile robot's movements, the [base component](/operate/reference/components/base/) exposes a useful interface.
 
 In the rest of this tutorial, you'll learn how to use this API to create your own custom modular resource.
@@ -184,7 +184,7 @@ The complete triplet is:
 
 The entry point code defines the model name and then registers it with `viam-server`.
 When registering it, the code also provides the API that the new model supports.
-That means in this case that the base should support the default [base API](/dev/reference/apis/components/base/#api) with methods such as `MoveStraight` and `Spin`.
+That means in this case that the base should support the default [base API](/reference/apis/components/base/#api) with methods such as `MoveStraight` and `Spin`.
 
 The **API** of any Viam resource is also represented as colon-separated triplets where the first element is a namespace.
 Since you are using the default Viam API for a [base](/operate/reference/components/base/), the {{< glossary_tooltip term_id="api-namespace-triplet" text="API namespace triplet" >}} is:
@@ -318,7 +318,7 @@ For more information on modules and how they work, see the [Create a module](/op
 
 ### Control the rover
 
-After you configured the base, go to the [**CONTROL**](/manage/troubleshoot/teleoperate/default-interface/#web-ui) tab and expand the base component to view the controls to enable keyboard or discrete control over your machine's movement.
+After you configured the base, go to the [**CONTROL**](/monitor/default-interface/#web-ui) tab and expand the base component to view the controls to enable keyboard or discrete control over your machine's movement.
 
 {{< alert title="Caution" color="caution" >}}
 Be careful, the Intermode is a large and powerful rover - make sure you have the shutoff key in hand for emergencies and make sure your rover has sufficient space to drive around without hitting anyone or anything.
@@ -339,7 +339,7 @@ Check out this [GitHub repository](https://github.com/viam-labs/tutorial-intermo
 
 ## Next steps
 
-Now that you have integrated your rover or mobile base with Viam, you can use the [Viam SDKs](/dev/reference/sdks/) to operate your rover.
+Now that you have integrated your rover or mobile base with Viam, you can use the [Viam SDKs](/reference/sdks/) to operate your rover.
 If your rover has a [`camera`](/operate/reference/components/camera/) or a [`movement_sensor`](/operate/reference/components/movement-sensor/), you can try the following tutorials:
 
 {{< cards >}}
diff --git a/docs/tutorials/custom/custom-base-dog.md b/docs/tutorials/custom/custom-base-dog.md
index 2e63b93155..2199476f51 100644
--- a/docs/tutorials/custom/custom-base-dog.md
+++ b/docs/tutorials/custom/custom-base-dog.md
@@ -271,7 +271,7 @@ This is the file you will modify in the next steps.
 
 ### Connect the module to the Freenove server
 
-When you send a command to the robot using the Viam [base API](/dev/reference/apis/components/base/#api), you need a way to pass the corresponding command to the Freenove dog server.
+When you send a command to the robot using the Viam [base API](/reference/apis/components/base/#api), you need a way to pass the corresponding command to the Freenove dog server.
 In your code, establish a socket and then create a `send_data` helper method to send the command from `viam-server` to the Freenove server.
 
 Start by importing socket:
@@ -340,7 +340,7 @@ class robotdog(Base, Reconfigurable):
 To create a custom base model, you need a script that defines what each base component method (for example `set_power`) makes the robot dog do.
 
 Open your newly created <file>robotdog.py</file> file.
-It contains stubs of all the [base API methods](/dev/reference/apis/components/base/#api), but you need to modify these method definitions to actually send commands to the robot dog.
+It contains stubs of all the [base API methods](/reference/apis/components/base/#api), but you need to modify these method definitions to actually send commands to the robot dog.
 
 Take a look at [<file>robotdog.py</file>](https://github.com/viam-labs/robot-dog-module/blob/main/robotdog/src/robotdog.py).
 
@@ -356,7 +356,7 @@ async def stop(self, extra: Optional[Dict[str, Any]] = None, **kwargs):
 ```
 
 Copy and paste that code into your <file>robotdog.py</file> file.
-Feel free to tweak the specific contents of each of the [base method definitions](/dev/reference/apis/components/base/#api) to do things like make the dog move faster.
+Feel free to tweak the specific contents of each of the [base method definitions](/reference/apis/components/base/#api) to do things like make the dog move faster.
 Don't forget to save.
 
 ### Make your module executable
diff --git a/docs/tutorials/get-started/blink-an-led.md b/docs/tutorials/get-started/blink-an-led.md
index d65703771f..d160b9af51 100644
--- a/docs/tutorials/get-started/blink-an-led.md
+++ b/docs/tutorials/get-started/blink-an-led.md
@@ -35,7 +35,7 @@ This is a great place to start if you have never built a robot or a circuit befo
 {{<gif webm_src="/tutorials/blink-an-led/image9.webm" mp4_src="/tutorials/blink-an-led/image9.mp4" alt="A GIF of the completed project showing a blinking blue LED connected to a Raspberry Pi with jumper cables." max-width="300px">}}
 
 First, you'll use the control interface on [Viam](https://app.viam.com) to turn the LED on and off.
-Then, you'll write code to control the LED using the Viam [software development kits](/dev/reference/sdks/).
+Then, you'll write code to control the LED using the Viam [software development kits](/reference/sdks/).
 
 ## What you'll need for this guide
 
@@ -174,7 +174,7 @@ Click the **Save** button in the top right corner of the page to save your chang
 ## Control your robot using Viam
 
 When you configure your board component, Viam generates a control panel for it.
-Click the [**CONTROL** tab](/manage/troubleshoot/teleoperate/default-interface/#web-ui) to view the control panels for all your machine's components (in this case, just the board).
+Click the [**CONTROL** tab](/monitor/default-interface/#web-ui) to view the control panels for all your machine's components (in this case, just the board).
 
 Click the board card to expand it.
 Here, you can click on **Get** to get the current status of your pin.
@@ -216,7 +216,7 @@ Refer to the appropriate SDK documentation for SDK installation instructions:
 
 ### Connect your robot to the Viam SDK
 
-The easiest way to get started writing an application with Viam is to navigate to the **CONNECT** tab of your machine's page on [Viam](https://app.viam.com/robots) and select the **SDK code sample** page.
+The easiest way to get started writing an application with Viam is to navigate to the **CONNECT** tab of your machine's page on [Viam](https://app.viam.com/robots) and select **API keys** to get your credentials.
 For this tutorial, we provide Python and Golang code snippets.
 Select **Python** or **Golang** and follow the instructions to connect to your machine.
 
@@ -304,7 +304,7 @@ go run blink.go
 
 In order to interact with the GPIO pins on our Raspberry Pi, you need to import the [board component](/operate/reference/components/board/) from the Viam SDK.
 
-The **SDK code sample** page automatically adds the board import for you, but it doesn't hurt to double-check.
+The code sample from the **CONNECT** tab automatically adds the board import for you, but it doesn't hurt to double-check.
 
 {{< tabs >}}
 {{% tab name="Python" %}}
diff --git a/docs/tutorials/projects/_index.md b/docs/tutorials/projects/_index.md
index 4ddc6cbee6..0492284f65 100644
--- a/docs/tutorials/projects/_index.md
+++ b/docs/tutorials/projects/_index.md
@@ -6,5 +6,5 @@ weight: 60
 type: docs
 empty_node: true
 layout: "empty"
-canonical: "/dev/tools/tutorials/"
+canonical: "/tutorials/"
 ---
diff --git a/docs/tutorials/projects/claw-game.md b/docs/tutorials/projects/claw-game.md
index 505c342660..fe172890b9 100644
--- a/docs/tutorials/projects/claw-game.md
+++ b/docs/tutorials/projects/claw-game.md
@@ -437,7 +437,7 @@ Represented in that file are obstacles for the prize drop hole, and each of the
 If the dimensions of your enclosure differ from ours, adjust your `obstacles.json` file to match your enclosure.
 
 The obstacles for our arm are configured in reference to the "world" frame which is defined as a , which is a special frame that represents the starting point for all other frames in the robot's world.
-The list of obstacles are defined in a `WorldState` object, which is passed as an argument in each [move()](/dev/reference/apis/services/motion/#move) call.
+The list of obstacles are defined in a `WorldState` object, which is passed as an argument in each [move()](/reference/apis/services/motion/#move) call.
 
 {{< alert title="Tip" color="tip" >}}
 If the arm is not mounted exactly perpendicular to the x/y axis of the enclosure, you can adjust the theta (_th_) of the arm within the arm component configuration by a number of degrees to compensate.
@@ -931,7 +931,7 @@ In this tutorial, you learned how to:
 For some next steps, you could:
 
 - Use the advanced interface included in the project repository to leverage the [motion service](/operate/reference/services/motion/) for larger, more complex arm movement within the enclosure.
-- Add a camera and use the [vision service](/operate/reference/services/vision/) to add color detection, or use an [ML model](/data-ai/ai/deploy/) to determine grab success rate and create a score counter.
+- Add a camera and use the [vision service](/operate/reference/services/vision/) to add color detection, or use an [ML model](/vision/configure/) to determine grab success rate and create a score counter.
 - Design a hard mode where the prizes are shuffled around with the arm every few attempts.
 - Add a camera and extend the interface to allow folks from anywhere in the world to play the claw game and win.
 
diff --git a/docs/tutorials/projects/helmet.md b/docs/tutorials/projects/helmet.md
index 6991a12a6f..2ad1657ef0 100644
--- a/docs/tutorials/projects/helmet.md
+++ b/docs/tutorials/projects/helmet.md
@@ -196,7 +196,7 @@ Now that the detector is configured, it's time to test it!
 
 ## Configure data capture and sync
 
-Viam's built-in [data management service](/data-ai/capture-data/capture-sync/) allows you to, among other things, capture images and sync them to the cloud.
+Viam's built-in [data management service](/data/capture-sync/capture-and-sync-data/) allows you to, among other things, capture images and sync them to the cloud.
 For this project, you will capture images of people without hard hats so that you can see who wasn't wearing one, and so that you can trigger notifications when these images are captured and synced.
 Configure data capture on the `objectfilter` camera to capture images of people without hard hats:
 
@@ -250,7 +250,7 @@ Now that you have verified that the detector and data sync are working, modify y
 
 ## Set up email notifications
 
-[Triggers](/data-ai/ai/alert/) allow you to send webhook requests or email notifications when certain events happen.
+[Triggers](/vision/alert-on-detections/) allow you to send webhook requests or email notifications when certain events happen.
 
 For example, you can set up a trigger to perform an action whenever an image of someone without a hard hat is uploaded to the cloud.
 
@@ -459,10 +459,10 @@ Here are some ways you could expand on this project:
 - Change your cloud function to send a different kind of notification, or trigger some other action.
   For an example demonstrating how to configure text notifications, see the [Detect a Person and Send a Photo tutorial](/tutorials/projects/send-security-photo/).
 
-- Use a different existing model or [train your own](/data-ai/train/train-tf-tflite/), to detect and send notifications about something else such as [forklifts](https://huggingface.co/keremberke/yolov8m-forklift-detection) appearing in your camera stream.
+- Use a different existing model or [train your own](/train/train-a-model/), to detect and send notifications about something else such as [forklifts](https://huggingface.co/keremberke/yolov8m-forklift-detection) appearing in your camera stream.
 
 {{< cards >}}
 {{% card link="/tutorials/projects/send-security-photo/" %}}
-{{% card link="/data-ai/train/train-tf-tflite/" %}}
+{{% card link="/train/train-a-model/" %}}
 {{% card link="/tutorials/services/navigate-with-rover-base/" %}}
 {{< /cards >}}
diff --git a/docs/tutorials/projects/integrating-viam-with-openai.md b/docs/tutorials/projects/integrating-viam-with-openai.md
index 8c9de6146a..846fd7ce41 100644
--- a/docs/tutorials/projects/integrating-viam-with-openai.md
+++ b/docs/tutorials/projects/integrating-viam-with-openai.md
@@ -77,7 +77,7 @@ This tutorial will show you how to use the Viam platform to create an AI-integra
 ## Rover setup
 
 This tutorial assumes that you have already set up your Viam Rover.
-If not, first follow the Viam Rover [setup instructions](/dev/reference/try-viam/rover-resources/rover-tutorial/).
+If not, first follow the Viam Rover [setup instructions](/try/).
 
 If you are not using a Viam Rover, add a new machine.
 Then follow the {{< glossary_tooltip term_id="setup" text="setup instructions" >}} to install `viam-server` on the computer you're using for your project and connect to Viam.
@@ -242,7 +242,7 @@ We found that if set up this way, the following positions accurately show the co
 
 ### 2. Configure the ML Model and vision services to use the detector
 
-The [ML model service](/data-ai/ai/deploy/) allows you to deploy a machine learning model to your robot.
+The [ML model service](/vision/configure/) allows you to deploy a machine learning model to your robot.
 This tutorial uses a pre-trained machine learning (ML) model from the Viam Registry named [`EfficientDet-COCO`](https://app.viam.com/ml-model/viam-labs/EfficientDet-COCO).
 This model can detect a variety of objects, which you can find in the provided <file>[labels.txt](https://github.com/viam-labs/devrel-demos/raw/main/Light%20up%20bot/labels.txt)</file> file.
 
@@ -422,6 +422,6 @@ Some ideas:
 - Make the voice recognition software listen in the background, so the robot can move and interact with the world while listening and responding.
 - Integrate another ML model that is used to follow a human (when told to do so).
 - Add Lidar and integrate Viam's {{< glossary_tooltip term_id="slam" text="SLAM service" >}} to map the world around it.
-- Use Viam's [Data Management](/data-ai/capture-data/capture-sync/) to collect environmental data and use this data to train new ML models that allow the robot to improve its functionality.
+- Use Viam's [Data Management](/data/capture-sync/capture-and-sync-data/) to collect environmental data and use this data to train new ML models that allow the robot to improve its functionality.
 
 We'd love to see where you decide to take this. If you build your own companion robot, let us and others know on the [Community Discord](https://discord.gg/viam).
diff --git a/docs/tutorials/projects/make-a-plant-watering-robot.md b/docs/tutorials/projects/make-a-plant-watering-robot.md
index 9f238b61e9..8e22528993 100644
--- a/docs/tutorials/projects/make-a-plant-watering-robot.md
+++ b/docs/tutorials/projects/make-a-plant-watering-robot.md
@@ -306,7 +306,7 @@ sudo apt upgrade
 ```
 
 Then run the following command to create and activate the virtual environment:
-If you want to read more on virtual environments, check out [the documentation](/dev/reference/sdks/python/python-venv/).
+If you want to read more on virtual environments, check out [the documentation](/reference/sdks/python/python-venv/).
 
 ```sh {class="command-line" data-prompt="$"}
 python3 -m venv .venv
@@ -335,10 +335,9 @@ pip3 install viam-sdk
 
 Follow these instructions to start working on your Python control code:
 
-1. Navigate to your machine's page, and click on the **CONNECT** tab and the **SDK code sample** page.
-1. Select **Python** as the language.
-1. Follow the instructions shown under step 1 on that page to install the SDK.
-1. Then, under step 2 on that page, click the copy icon to copy the generated code sample, which establishes a connection with your robot when run.
+1. Navigate to your machine's page and click on the **CONNECT** tab.
+1. Select **API keys** and copy your **API key**, **API key ID**, and **machine address**.
+1. Install the Python SDK and create a connection script using your credentials.
 
    {{% snippet "show-secret.md" %}}
 
@@ -356,7 +355,7 @@ nano plant-watering-robot.py
 Now, add code into <file>plant-watering-robot.py</file> to write the logic that defines your plant watering system.
 
 To start, add your system logic code into the `main()` function of the program.
-Use the Viam [board](/dev/reference/apis/components/board/) and [sensor](/dev/reference/apis/components/sensor/) API methods to read from the moisture sensor and control the pump's voltage from a GPIO pin.
+Use the Viam [board](/reference/apis/components/board/) and [sensor](/reference/apis/components/sensor/) API methods to read from the moisture sensor and control the pump's voltage from a GPIO pin.
 
 To access components from the machine, use the following code snippet:
 
@@ -449,6 +448,6 @@ sudo python3 plant-watering-robot.py
 Now that you have created your automatic plant watering system with a resistive soil moisture sensor, you can easily use Viam to automate other aspects of your garden.
 For example, you could add a [light sensor](https://www.amazon.com/Sensor-Module-Raspberry-Integrated-Circuits/dp/B07L15M5JG) or a [temperature sensor](https://www.amazon.com/KY-011-Cathode-Arduino-Starter-2-color/dp/B07869PKKF/ref=as_li_ss_tl?keywords=arduino+two+color+led+module&qid=1556591832&s=gateway&sr=8-2&th=1&linkCode=sl1&tag=murraynet-20&linkId=c36cd98be29498a9883b656c7011b6bb&language=en_US), and get readings from other channels of the MCP3008!
 
-You could set up data capture and [graph your sensor data](/data-ai/data/visualize/), or [create your own custom Typescript dashboard](/tutorials/control/air-quality-fleet/) to display your sensor data.
+You could set up data capture and [graph your sensor data](/data/visualize-data/), or [create your own custom Typescript dashboard](/tutorials/control/air-quality-fleet/) to display your sensor data.
 
 If you build something based on this please share it in our [Community Discord](https://discord.gg/viam) - we'd love to see it.
diff --git a/docs/tutorials/projects/send-security-photo.md b/docs/tutorials/projects/send-security-photo.md
index ac804002c5..368f6290d0 100644
--- a/docs/tutorials/projects/send-security-photo.md
+++ b/docs/tutorials/projects/send-security-photo.md
@@ -24,7 +24,7 @@ Maybe someone is eating your chocolates when you are away.
 You're not sure who, but you suspect Steve.
 This robot will help you catch the culprit.
 
-When someone comes to your desk, the robot will use the [vision service](/operate/reference/services/vision/) and the [ML model service](/data-ai/ai/deploy/) to detect a person, take their photo, and text you an alert with a photo of the person.
+When someone comes to your desk, the robot will use the [vision service](/operate/reference/services/vision/) and the [ML model service](/vision/configure/) to detect a person, take their photo, and text you an alert with a photo of the person.
 
 ![Text message reading "Alert There is someone at your desk beware" with a photo of a person (Steve) detected by the camera as he approaches the desk.](/tutorials/send-security-photo/text-message.png)
 
@@ -87,7 +87,7 @@ This tutorial uses a pre-trained Machine Learning model from the Viam Registry c
 The model can detect a variety of things, including `Persons`.
 You can see a full list of what the model can detect in <file>[labels.txt](https://github.com/viam-labs/devrel-demos/raw/main/Light%20up%20bot/labels.txt)</file> file.
 
-If you want to train your own model instead, follow the instructions to [train a TFlite](/data-ai/train/train-tf-tflite/) or [another model](/data-ai/train/train/).
+If you want to train your own model instead, follow the instructions to [train a TFlite](/train/train-a-model/) or [another model](/train/custom-training-scripts/).
 
 1. **Configure the ML model service**
 
@@ -263,7 +263,7 @@ You need to tell the code how to access your specific machine (which in this cas
 
 Navigate to the machine's **CONNECT** tab.
 Make sure Python is selected in the Language selector.
-Get the machine address, API key, and API key ID from the **CONNECT** tab's **SDK code sample** page and set them as environment variables or add them at the top of <FILE>chocolate_security.py</FILE>.
+Get the machine address, API key, and API key ID from the **CONNECT** tab's **API keys** section and set them as environment variables or add them at the top of <FILE>chocolate_security.py</FILE>.
 
 {{% snippet "show-secret.md" %}}
 
diff --git a/docs/tutorials/projects/verification-system.md b/docs/tutorials/projects/verification-system.md
index f26f47b368..8aeddccc3a 100644
--- a/docs/tutorials/projects/verification-system.md
+++ b/docs/tutorials/projects/verification-system.md
@@ -89,10 +89,10 @@ In order for your machine's camera to detect the presence of a person in its fie
 The model can detect a variety of objects, which you can see in the <file>[labels.txt](https://github.com/viam-labs/devrel-demos/raw/main/Light%20up%20bot/labels.txt)</file> file, including people with the `person` label.
 
 {{< alert title="Want to train your own model instead?" color="note" >}}
-If you wish to train your own ML model, see [Train a TF or TFLite model](/data-ai/train/train-tf-tflite/).
+If you wish to train your own ML model, see [Train a TF or TFLite model](/train/train-a-model/).
 {{< /alert >}}
 
-To run the machine learning model on your machine, use the [ML model service](/data-ai/ai/deploy/):
+To run the machine learning model on your machine, use the [ML model service](/vision/configure/):
 
 1. On your machine's **CONFIGURE** tab, click the **+** icon next to your machine part in the left-hand menu and select **Component or service**.
 1. Select type `ML model`, then select model `TFLite CPU`.
diff --git a/docs/tutorials/services/_index.md b/docs/tutorials/services/_index.md
index a5e1a0673e..33b9557933 100644
--- a/docs/tutorials/services/_index.md
+++ b/docs/tutorials/services/_index.md
@@ -6,5 +6,5 @@ weight: 40
 type: docs
 empty_node: true
 layout: "empty"
-canonical: "/dev/tools/tutorials/"
+canonical: "/tutorials/"
 ---
diff --git a/docs/tutorials/services/color-detection-scuttle.md b/docs/tutorials/services/color-detection-scuttle.md
index 49f72f94aa..eed95ddfef 100644
--- a/docs/tutorials/services/color-detection-scuttle.md
+++ b/docs/tutorials/services/color-detection-scuttle.md
@@ -30,7 +30,7 @@ toc_hide: true
 After following this tutorial, you will understand how the ML model service and the Vision service work together and you will be able to use both alongside the base and camera components to make a machine respond to the world around it.  -->
 
 In this tutorial, you'll learn how to use the [vision service](/operate/reference/services/vision/) to make a rover follow a colored object.
-We're using a [SCUTTLE rover](https://www.scuttlerobot.org/) for this tutorial but you can use any rover, including the [Viam rover](/dev/reference/try-viam/rover-resources/).
+We're using a [SCUTTLE rover](https://www.scuttlerobot.org/) for this tutorial but you can use any rover, including the [Viam rover](/try/).
 
 {{< alert title="You will learn" color="tip" >}}
 
@@ -52,7 +52,7 @@ You don't need to buy or own any hardware to complete this tutorial.
 You will need the following hardware to complete this tutorial:
 
 - A wheeled rover, configured with a base component.
-  If you have your own Viam rover [follow the Viam Rover configuration instructions](/dev/reference/try-viam/rover-resources/).
+  If you have your own Viam rover [follow the Viam Rover configuration instructions](/try/).
   If you own another mobile robot [follow the general configuration instructions](/tutorials/configure/configure-rover/).
 
   This tutorial uses a [SCUTTLE rover](https://www.scuttlerobot.org/shop/) as an example but you can complete this tutorial using a Yahboom 4WD Smart Robot or any other wheeled robot that can be configured as a [base component](/operate/reference/components/base/wheeled/).
@@ -68,7 +68,7 @@ Turn on the power to the rover.
 
 This tutorial uses the color `#a13b4c` or `rgb(161,59,76)` (a reddish color).
 
-To create a [color detector vision service](/dev/reference/apis/services/vision/#detections):
+To create a [color detector vision service](/reference/apis/services/vision/#detections):
 
 {{< tabs >}}
 {{% tab name="Builder" %}}
@@ -122,7 +122,7 @@ To determine the color value from the actual cam component image, you can use a
 
 ### Test your color detector
 
-You can test your detector by clicking on the **Test** area of the vision service's configuration panel or from the [**CONTROL** tab](/manage/troubleshoot/teleoperate/default-interface/#web-ui):
+You can test your detector by clicking on the **Test** area of the vision service's configuration panel or from the [**CONTROL** tab](/monitor/default-interface/#web-ui):
 
 The camera stream will show detections with bounding boxes around the detected colors.
 
@@ -153,13 +153,13 @@ pip3 install viam-sdk
 
 ### Connect
 
-Next, go to the **CONNECT** tab's **SDK code sample** page on your [machine page](https://app.viam.com/robots) and select **Python**.
+Next, go to the **CONNECT** tab on your [machine page](https://app.viam.com/robots) and select **API keys** to get your credentials.
 
 {{% snippet "show-secret.md" %}}
 
 This code snippet imports all the necessary packages and sets up a connection with Viam.
 
-Next, create a file named <file>main.py</file> with the sample code from the **CONNECT** tab's **SDK code sample** page.
+Next, create a file named <file>main.py</file> with the sample code from the **CONNECT** tab.
 Then, save your file.
 
 Run the code to verify that the Viam SDK is properly installed and that the `viam-server` instance on your robot is live.
diff --git a/docs/tutorials/services/constrain-motion.md b/docs/tutorials/services/constrain-motion.md
index 055ad857f5..ab7e43b76d 100644
--- a/docs/tutorials/services/constrain-motion.md
+++ b/docs/tutorials/services/constrain-motion.md
@@ -221,7 +221,7 @@ The following diagram shows this, as well as the global coordinate system.
 
 If you are using a `fake` gripper, there is no real hardware to calibrate and you can [continue to the next section](#use-a-transform-to-represent-a-drinking-cup), imagining that your fake gripper corresponds to the diagram above.
 
-If you are using a real arm and gripper, use the [**CONTROL** tab](/manage/troubleshoot/teleoperate/default-interface/#web-ui) to move the gripper, look at its reported orientations, and map them to its orientation in the real world.
+If you are using a real arm and gripper, use the [**CONTROL** tab](/monitor/default-interface/#web-ui) to move the gripper, look at its reported orientations, and map them to its orientation in the real world.
 If the axes are different from those described above, take these differences into account in your code.
 
 ## Use a transform to represent a drinking cup
@@ -229,7 +229,7 @@ If the axes are different from those described above, take these differences int
 Imagine your cup is 120 millimeters tall with a radius of 45 millimeters.
 You need to take this space into account to avoid bumping objects on the table with the cup.
 
-You can pass transforms to the [motion service `move` method](/dev/reference/apis/services/motion/#move) to represent objects that are connected to the robot but are not actual robotic components.
+You can pass transforms to the [motion service `move` method](/reference/apis/services/motion/#move) to represent objects that are connected to the robot but are not actual robotic components.
 To represent the drinking cup held in your robot's gripper, create a transform with the cup's measurements:
 
 ```python {class="line-numbers linkable-line-numbers"}
diff --git a/docs/tutorials/services/navigate-with-rover-base.md b/docs/tutorials/services/navigate-with-rover-base.md
index 0c64a43c6a..51f17bd9ca 100644
--- a/docs/tutorials/services/navigate-with-rover-base.md
+++ b/docs/tutorials/services/navigate-with-rover-base.md
@@ -97,7 +97,7 @@ If you are using different hardware, configure them according to the instruction
 
 First, configure the [board](/operate/reference/components/board/) local to your rover.
 Follow [these instructions](/operate/reference/components/board/#configuration) to configure your board model.
-We used a [`jetson` board](https://github.com/viam-modules/nvidia/tree/main/jetson), but you can use any model of board you have on hand, as the [resource's API](/dev/reference/apis/components/board/#api) is hardware agnostic.
+We used a [`jetson` board](https://github.com/viam-modules/nvidia/tree/main/jetson), but you can use any model of board you have on hand, as the [resource's API](/reference/apis/components/board/#api) is hardware agnostic.
 
 1. Configure a board named `local` as shown below:
 
@@ -105,7 +105,7 @@ We used a [`jetson` board](https://github.com/viam-modules/nvidia/tree/main/jets
 
 2. Configure [digital interrupts](https://github.com/viam-modules/nvidia/blob/main/README.md#digital-interrupt-configuration) on your board to signal precise GPIO state changes to the [encoders](/operate/reference/components/encoder/) on your rover base.
    Find your board on the **CONFIGURE** tab in **Builder** mode.
-   Click the **{}** (Switch to advanced) button on the right side of your board's card to switch to JSON attributes editing mode.
+   Click the **JSON** button on the right side of your board's card to switch to JSON attributes editing mode.
    Copy and paste the following JSON into your board's attributes field to add [digital interrupts](https://github.com/viam-modules/nvidia/blob/main/README.md#digital-interrupt-configuration) on pins `31`, `29`, `23`, and `21`:
 
 ```json {class="line-numbers linkable-line-numbers"}
@@ -343,8 +343,7 @@ In the **JSON** mode in your machine's **CONFIGURE** tab, add the following JSON
 
     - Make sure your `merged` movement sensor is configured to gather `"position"` readings from the `gps` movement sensor.
     - [Configure the frame system](/operate/reference/services/frame-system/) for this movement sensor so that the navigation service knows where it is in relation to the base.
-
-      - On the **CONFIGURE** tab, add a frame to your movement sensor configuration by clicking **+ Add Frame**.
+      - On the **CONFIGURE** tab, add a frame to your movement sensor configuration by clicking the **Frame** button.
         If your movement sensor is mounted on top of the rover like ours is, leave the default frame values.
       - Set the `base` as the `parent` frame.
 
@@ -539,7 +538,7 @@ Your rover will begin navigating between waypoints.
 
 ### Programmatic method
 
-If you want to do add waypoints programmatically, use the service's [API method `AddWaypoint()`](/dev/reference/apis/services/navigation/#addwaypoint):
+If you want to do add waypoints programmatically, use the service's [API method `AddWaypoint()`](/reference/apis/services/navigation/#addwaypoint):
 
 #### Add waypoints
 
@@ -574,7 +573,7 @@ await my_nav.add_waypoint(point=location)
 
 #### Begin navigation
 
-To start navigating, set your service to `MODE_WAYPOINT` with the service's [API method `SetMode()`](/dev/reference/apis/services/navigation/#setmode):
+To start navigating, set your service to `MODE_WAYPOINT` with the service's [API method `SetMode()`](/reference/apis/services/navigation/#setmode):
 
 {{< tabs >}}
 {{% tab name="Go" %}}
@@ -617,9 +616,9 @@ You can alternatively use [`viam:ultrasonic:camera`](https://app.viam.com/module
 
 {{< /alert >}}
 
-If you want the robot to be able to automatically detect obstacles in front of it, [configure a Vision service segmenter](/dev/reference/apis/services/vision/#segmentations).
+If you want the robot to be able to automatically detect obstacles in front of it, [configure a Vision service segmenter](/reference/apis/services/vision/#segmentations).
 For example, configure the Vision service model [`obstacles_depth`](https://app.viam.com/module/viam/obstacles-pointcloud) to detect obstacles in front of the robot.
-Then, use one of [Viam's client SDKs](/dev/reference/sdks/) to automate obstacle avoidance with the navigation service like in the following Python program:
+Then, use one of [Viam's client SDKs](/reference/sdks/) to automate obstacle avoidance with the navigation service like in the following Python program:
 
 {{%expand "Click to view full example of automated obstacle avoidance with the Python SDK" %}}
 
diff --git a/docs/tutorials/services/plan-motion-with-arm-gripper.md b/docs/tutorials/services/plan-motion-with-arm-gripper.md
index 0b8042e515..89c742c95c 100644
--- a/docs/tutorials/services/plan-motion-with-arm-gripper.md
+++ b/docs/tutorials/services/plan-motion-with-arm-gripper.md
@@ -155,7 +155,7 @@ Additional obstacles can also be _appended_ as desired.
 
 In previous examples you controlled motion of individual components.
 Now you will use the motion service to control the motion of the robot as a whole.
-You will use the motion service's [`Move`](/dev/reference/apis/services/motion/#move) method to execute more general robotic motion.
+You will use the motion service's [`Move`](/reference/apis/services/motion/#move) method to execute more general robotic motion.
 You can designate specific components for motion planning by passing in the resource name (note the use of the arm resource in the code samples below).
 The `worldState` we constructed earlier is also passed in so that the motion service takes that information into account when planning.
 
diff --git a/docs/vision/_index.md b/docs/vision/_index.md
new file mode 100644
index 0000000000..b43a088b23
--- /dev/null
+++ b/docs/vision/_index.md
@@ -0,0 +1,28 @@
+---
+linkTitle: "Computer vision"
+title: "Computer vision"
+weight: 55
+layout: "docs"
+type: "docs"
+no_list: true
+description: "Add computer vision to your machine: deploy ML models, run inference on camera feeds, detect and classify objects, measure depth, and act or alert on results."
+aliases:
+  - /build/vision-detection/
+  - /vision-detection/
+  - /vision/how-to/
+---
+
+Use these guides to add vision capabilities to your machine.
+The standard pipeline is: configure a camera, deploy an ML model, add a vision service, then use detections or classifications in your code.
+
+**Not sure whether to use detection or classification?** Detection finds _where_ objects are in an image (bounding boxes). Classification tells you _what_ the whole image contains (labels). Use detection when you need object locations; use classification when you just need to categorize the scene.
+
+{{< cards >}}
+{{% card link="/vision/configure/" %}}
+{{% card link="/vision/detect/" %}}
+{{% card link="/vision/classify/" %}}
+{{% card link="/vision/track/" %}}
+{{% card link="/vision/measure-depth/" %}}
+{{% card link="/vision/act-on-detections/" %}}
+{{% card link="/vision/alert-on-detections/" %}}
+{{< /cards >}}
diff --git a/docs/vision/act-on-detections.md b/docs/vision/act-on-detections.md
new file mode 100644
index 0000000000..cf49afc7b5
--- /dev/null
+++ b/docs/vision/act-on-detections.md
@@ -0,0 +1,309 @@
+---
+linkTitle: "Act on detections"
+title: "Act on detections"
+weight: 60
+layout: "docs"
+type: "docs"
+description: "Build a module that uses vision service results to control machine behavior."
+aliases:
+  - /vision/act/
+  - /vision/how-to/act-on-detections/
+date: "2025-10-09"
+---
+
+You have a vision service detecting or classifying objects, but you need your machine to respond automatically -- stop an arm when a person is nearby, sort items by color, or trigger an action when an anomaly appears. This guide shows you how to build a module that reads vision results and controls other resources based on what it sees.
+
+## Concepts
+
+### The wrapper pattern
+
+The most common approach is to create a module that wraps an existing resource. The wrapper intercepts API calls, checks vision results, and decides whether to pass the call through or block it.
+
+For example, a "safe arm" module wraps a real arm. When your code calls `move_to_position`, the wrapper first checks the vision service for people in the frame. If no one is detected, it passes the command to the real arm. If a person is detected, it raises an error.
+
+This pattern works with any resource type: arms, bases, motors, or even other services.
+
+### Choosing a resource type
+
+Your module must implement a resource API. Pick the type that matches what you are controlling:
+
+| Scenario                                  | Resource type                                |
+| ----------------------------------------- | -------------------------------------------- |
+| Gate movement commands based on vision    | The component being gated (arm, base, motor) |
+| Classify images with custom logic         | Vision service                               |
+| Trigger actions across multiple resources | Generic service                              |
+
+The choice determines which API methods you must implement. A wrapper around an arm implements the arm API. A standalone logic service might implement the generic service API.
+
+### Dependencies
+
+Your module needs access to the vision service, a camera, and whatever resource it controls. Viam's dependency system handles this: you declare required dependencies in `validate_config`, and `viam-server` ensures they are available before your module starts.
+
+## Steps
+
+### 1. Generate the module scaffold
+
+Install the [Viam CLI](/cli/) and generate a module template. Replace `<ORGANIZATION-ID>` with your organization ID.
+
+```sh {class="command-line" data-prompt="$"}
+viam module generate --language python --model-name safe-arm \
+  --name my-vision-module --public-namespace <ORGANIZATION-ID> --public
+```
+
+The CLI creates a project directory with the files you need. The only file you need to modify is the model file in `src/models/`.
+
+### 2. Add imports
+
+Open the generated model file (for example, `src/models/safe-arm.py`) and add imports for the vision service and any resources you will control:
+
+```python
+from typing import cast
+from viam.services.vision import *
+```
+
+Import additional resource types as needed. For the safe arm example:
+
+```python
+from viam.components.arm import Arm
+```
+
+### 3. Validate configuration
+
+The `validate_config` method parses your module's configuration and returns a list of required dependencies. This tells `viam-server` to wait until all dependencies are available before starting your module.
+
+Your module needs at minimum a camera name and a vision service name:
+
+```python
+@classmethod
+def validate_config(
+    cls, config: ComponentConfig
+) -> Tuple[Sequence[str], Sequence[str]]:
+    req_deps = []
+    fields = config.attributes.fields
+    if "camera_name" not in fields:
+        raise Exception("missing required camera_name attribute")
+    elif not fields["camera_name"].HasField("string_value"):
+        raise Exception("camera_name must be a string")
+    camera_name = fields["camera_name"].string_value
+    if not camera_name:
+        raise ValueError("camera_name cannot be empty")
+    req_deps.append(camera_name)
+    if "vision_name" not in fields:
+        raise Exception("missing required vision_name attribute")
+    elif not fields["vision_name"].HasField("string_value"):
+        raise Exception("vision_name must be a string")
+    vision_name = fields["vision_name"].string_value
+    if not vision_name:
+        raise ValueError("vision_name cannot be empty")
+    req_deps.append(vision_name)
+    return req_deps, []
+```
+
+Add validation for any other resources your module wraps. For the safe arm, add `arm_name` to the required dependencies the same way.
+
+### 4. Initialize dependencies in reconfigure
+
+The `reconfigure` method runs when the module starts and whenever configuration changes. Use it to get references to your dependencies:
+
+```python
+def reconfigure(
+    self, config: ComponentConfig,
+    dependencies: Mapping[ResourceName, ResourceBase]
+):
+    camera_name = config.attributes.fields["camera_name"].string_value
+    vision_name = config.attributes.fields["vision_name"].string_value
+
+    vision_resource_name = VisionClient.get_resource_name(vision_name)
+    if vision_resource_name not in dependencies:
+        raise KeyError(f"Vision service '{vision_name}' not found in "
+                       f"dependencies. Available: "
+                       f"{list(dependencies.keys())}")
+
+    self.vision_service = cast(VisionClient,
+                               dependencies[vision_resource_name])
+    self.camera_name = camera_name
+
+    return super().reconfigure(config, dependencies)
+```
+
+For the safe arm, also initialize the arm reference:
+
+```python
+    arm_name = config.attributes.fields["arm_name"].string_value
+    arm_resource_name = Arm.get_resource_name(arm_name)
+    self.arm = cast(Arm, dependencies[arm_resource_name])
+```
+
+### 5. Implement the vision check
+
+Create a helper method that queries the vision service and returns a decision:
+
+{{< tabs >}}
+{{% tab name="Detections" %}}
+
+```python
+async def _is_safe(self):
+    detections = await self.vision_service.get_detections_from_camera(
+        self.camera_name)
+    for d in detections:
+        if d.confidence > 0.4 and d.class_name == "Person":
+            self.logger.warn(
+                f"Detected {d.class_name} "
+                f"with confidence {d.confidence}.")
+            return False
+    return True
+```
+
+{{% /tab %}}
+{{% tab name="Classifications" %}}
+
+```python
+async def _is_safe(self):
+    classifications = (
+        await self.vision_service.get_classifications_from_camera(
+            self.camera_name, 4))
+    for c in classifications:
+        if c.confidence > 0.6 and c.class_name == "UNSAFE":
+            self.logger.warn(
+                f"Classification {c.class_name} "
+                f"with confidence {c.confidence}.")
+            return False
+    return True
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 6. Wire the check into API methods
+
+Override the API methods where you want vision-based gating. For the safe arm:
+
+```python
+async def move_to_position(
+    self,
+    pose: Pose,
+    *,
+    extra: Optional[Dict[str, Any]] = None,
+    timeout: Optional[float] = None,
+    **kwargs
+):
+    if await self._is_safe():
+        await self.arm.move_to_position(
+            pose, extra=extra, timeout=timeout)
+    else:
+        raise ValueError(
+            "Person detected. Safe arm will not move.")
+
+
+async def move_to_joint_positions(
+    self,
+    positions: JointPositions,
+    *,
+    extra: Optional[Dict[str, Any]] = None,
+    timeout: Optional[float] = None,
+    **kwargs
+):
+    if await self._is_safe():
+        await self.arm.move_to_joint_positions(
+            positions, extra=extra, timeout=timeout)
+    else:
+        raise ValueError(
+            "Person detected. Safe arm will not move.")
+```
+
+Pass through all other methods to the underlying resource:
+
+```python
+async def do_command(
+    self,
+    command: Mapping[str, ValueTypes],
+    *,
+    timeout: Optional[float] = None,
+    **kwargs
+) -> Mapping[str, ValueTypes]:
+    return await self.arm.do_command(
+        command, timeout, **kwargs)
+```
+
+### 7. Test with hot reloading
+
+Use the CLI to build and deploy your module to a machine during development:
+
+```bash
+# Build in the cloud and deploy to the machine
+viam module reload --part-id <machine-part-id>
+
+# Optionally add a resource at the same time
+viam module reload --part-id <machine-part-id> \
+  --model-name my-org:my-module:safe-arm
+```
+
+If your development machine and target machine share the same architecture, you can build locally instead:
+
+```bash
+# Build locally and transfer to the machine
+viam module reload-local --part-id <machine-part-id>
+```
+
+After the module is deployed, configure its attributes in the Viam app:
+
+```json {class="line-numbers linkable-line-numbers"}
+{
+  "camera_name": "my-camera",
+  "vision_name": "my-detector",
+  "arm_name": "my-arm"
+}
+```
+
+**Save** and use the **TEST** panel to verify behavior.
+
+Each time you make changes, run `viam module reload` again to rebuild and redeploy.
+
+### 8. Upload to the registry
+
+Once your module is working:
+
+1. Commit and push your code to a GitHub repository.
+2. Follow the steps to [upload your module](/build-modules/deploy-a-module/) using cloud build.
+
+### 9. Update references
+
+If your module wraps another resource, update any services or processes that reference the original. For example, if motion planning used `my-arm`, update it to use `safe-arm-1` so all movement commands go through the vision check.
+
+## Try It
+
+1. Configure a safe arm module with a person detection model and point the camera at yourself. Attempt to move the arm and verify it refuses.
+2. Move out of frame and try again -- the arm should move normally.
+3. Adjust the confidence threshold in `_is_safe` and observe how it affects sensitivity.
+4. Try swapping detections for classifications to see how the two approaches differ.
+
+## Troubleshooting
+
+{{< expand "Module fails to start" >}}
+
+- Check the **LOGS** tab for error messages.
+- Verify that all dependency names in your config (`camera_name`, `vision_name`, `arm_name`) exactly match the names of configured resources.
+- Ensure the `run.sh` path is correct and the file is executable (`chmod +x run.sh`).
+
+{{< /expand >}}
+
+{{< expand "Vision check always returns safe / unsafe" >}}
+
+- Test the vision service independently using the **TEST** panel to confirm it produces detections.
+- Check that the `class_name` in your code matches the model's output labels exactly (case-sensitive).
+- Log the raw detections or classifications before filtering to see what the model returns.
+
+{{< /expand >}}
+
+{{< expand "Wrapper methods not being called" >}}
+
+- Confirm that other services and processes reference the wrapper resource name, not the original resource.
+- Check that your module registers the correct resource type and model triplet.
+
+{{< /expand >}}
+
+## What's Next
+
+- [Alert on Detections](/vision/alert-on-detections/) -- send email or webhook notifications when specific objects are detected.
+- [Deploy a Module](/build-modules/deploy-a-module/) -- package and upload your module to the Viam Registry.
+- [Vision Service API Reference](/reference/apis/services/vision/) -- full API documentation for detections, classifications, and more.
diff --git a/docs/vision/alert-on-detections.md b/docs/vision/alert-on-detections.md
new file mode 100644
index 0000000000..0fd2a212cb
--- /dev/null
+++ b/docs/vision/alert-on-detections.md
@@ -0,0 +1,178 @@
+---
+linkTitle: "Alert on detections"
+title: "Alert on detections"
+weight: 70
+layout: "docs"
+type: "docs"
+description: "Send email or webhook alerts when your vision service detects specific objects or classifications."
+aliases:
+  - /vision/alert/
+  - /vision/how-to/alert-on-detections/
+date: "2025-10-10"
+---
+
+You want to be notified when your camera detects something specific -- a person in a restricted area, a missing hard hat, or an anomaly on a production line. This guide shows you how to connect your vision service to Viam's trigger system so you receive an email or webhook whenever a detection occurs. No custom code is required.
+
+## Concepts
+
+### The alert pipeline
+
+The alert system chains three resources together:
+
+1. **Filtered camera** -- a camera module that only passes images to the data management service when specific detections or classifications are present.
+2. **Data management service** -- captures images from the filtered camera and syncs them to the Viam cloud.
+3. **Trigger** -- fires when new data syncs, sending an email or webhook notification.
+
+Because the filtered camera only passes images that match your criteria, every synced image represents a detection event. The trigger fires on each sync, turning data events into alerts.
+
+### Filtered camera behavior
+
+The [`filtered-camera`](https://app.viam.com/module/viam/filtered-camera) module wraps an existing camera and applies a vision service as a filter. It functions as a normal camera for live viewing and API calls. The filtering only affects what gets captured by the data management service.
+
+You configure the filter with:
+
+- **A label** -- the detection or classification class name to look for (such as "Person" or "NO-Hardhat").
+- **A confidence threshold** (0.0-1.0) -- the minimum confidence score required. Only images where the model meets this threshold are captured.
+
+### Alert frequency
+
+Triggers support configurable notification frequency to prevent alert fatigue. For example, you can limit alerts to a maximum of one per hour even if detections occur continuously.
+
+## Steps
+
+### 1. Configure a filtered camera
+
+Add the filtered camera module to your machine:
+
+1. Navigate to your machine's **CONFIGURE** tab.
+2. Click **+** and select **Configuration block**.
+3. Search for **filtered-camera** and select it.
+4. Click **Add component**, name it `objectfilter-cam`, and click **Add component** again to confirm.
+5. Add configuration attributes:
+
+   {{< tabs >}}
+   {{% tab name="Template" %}}
+
+   Replace `<camera_name>` and `<vision_service_name>` with the names of your camera and vision service. Choose either `objects` (for bounding-box detections) or `classifications` (for image-level labels) and remove the other.
+
+   ```json {class="line-numbers linkable-line-numbers"}
+   {
+     "camera": "<camera_name>",
+     "vision_services": [
+       {
+         "vision": "<vision_service_name>",
+         "classifications": { "<label>": 0.5 },
+         "objects": { "<label>": 0.5 }
+       }
+     ]
+   }
+   ```
+
+   {{% /tab %}}
+   {{% tab name="Example: Hard hat detection" %}}
+
+   This example uses a YOLOv8 model named `yolo` to detect workers without hard hats:
+
+   ```json {class="line-numbers linkable-line-numbers"}
+   {
+     "camera": "my_webcam",
+     "vision_services": [
+       {
+         "vision": "yolo",
+         "objects": {
+           "NO-Hardhat": 0.6
+         }
+       }
+     ]
+   }
+   ```
+
+   {{% /tab %}}
+   {{< /tabs >}}
+
+6. Click **Save**.
+
+For more details, see the [`filtered-camera` module README](https://app.viam.com/module/viam/filtered-camera).
+
+{{% alert title="Tip" color="tip" %}}
+To verify your confidence threshold, expand the **TEST** panel on your vision service card and observe the confidence levels for live detections.
+{{% /alert %}}
+
+### 2. Configure data capture and sync
+
+Add the data management service to capture and sync filtered images:
+
+1. Click **+** and select **Configuration block**.
+2. Search for **data management** and select it.
+3. Click **Add component**, name it `data-manager`, and click **Add component** again to confirm.
+4. Leave the default attributes and click **Save**.
+
+Enable data capture on the filtered camera:
+
+1. Locate the `objectfilter-cam` panel.
+2. Click the **Data Capture** button.
+3. Select **GetImages** as the type.
+4. Set the capture frequency to `0.2` images per second (one image every 5 seconds). Adjust as needed for your use case.
+
+### 3. Configure a trigger
+
+Add a trigger to send alerts when filtered images sync:
+
+1. Click **+** in the left sidebar and select **Trigger**.
+2. Enter a name and click **Create**.
+3. Set **Type** to **Data has been synced to the cloud**.
+4. Set **Data Types** to **Binary (image)**.
+
+   {{<imgproc src="/tutorials/helmet/trigger.png" resize="x600" style="width: 500px" declaredimensions=true alt="The trigger configured with 'Data has been synced to the cloud' as the type and 'Binary (image)' as the data type." class="shadow imgzoom" >}}
+
+5. Add notification methods:
+
+   **Email specific addresses**: Toggle on, add email addresses, and set the alert frequency.
+
+   **Email all machine owners**: Toggle on and set the alert frequency.
+
+   **Webhook**: Click **Add Webhook**, enter the URL of your cloud function, and implement logic to process the [webhook payload](/reference/triggers/#webhook-attributes). Use this to integrate with external services like Twilio, PagerDuty, or Zapier.
+
+6. Set the notification frequency (for example, maximum one alert per hour).
+7. Click **Save**.
+
+## Try It
+
+1. Point your camera at an object your model recognizes and wait for the capture interval to pass.
+2. Check the **TEST** panel on your vision service to confirm detections are occurring with sufficient confidence.
+3. Navigate to the **DATA** tab and verify that images are syncing.
+4. Check your email or webhook endpoint for the alert.
+
+## Troubleshooting
+
+{{< expand "No alerts received" >}}
+
+- Check the **LOGS** tab for errors from the filtered camera or data management service.
+- Verify your vision service detects objects with confidence above your threshold using the **TEST** panel.
+- Confirm the label in your filtered camera config exactly matches the vision service output (case-sensitive).
+- Check the **DATA** tab to see if images are being captured and synced.
+- Verify trigger configuration: correct type (data synced), correct data type (binary/image), and valid notification settings.
+
+{{< /expand >}}
+
+{{< expand "Too many alerts" >}}
+
+- Increase the confidence threshold in the filtered camera configuration to reduce false positives.
+- Lower the data capture frequency (for example, from `0.2` to `0.1` images per second).
+- Increase the notification frequency limit in the trigger settings (for example, maximum one per hour).
+
+{{< /expand >}}
+
+{{< expand "Images syncing but no trigger fires" >}}
+
+- Confirm the trigger is configured with **Data has been synced to the cloud** as the type.
+- Check that **Binary (image)** is selected as the data type.
+- Verify that at least one notification method (email or webhook) is configured.
+
+{{< /expand >}}
+
+## What's Next
+
+- [Act on Detections](/vision/act-on-detections/) -- build a module that responds to vision results in real time.
+- [Triggers Reference](/reference/triggers/) -- full documentation for trigger types, webhook payloads, and configuration options.
+- [Capture and Sync Data](/data/capture-sync/capture-and-sync-data/) -- learn more about configuring data capture and sync intervals.
diff --git a/docs/vision/classify.md b/docs/vision/classify.md
new file mode 100644
index 0000000000..3ffdb40725
--- /dev/null
+++ b/docs/vision/classify.md
@@ -0,0 +1,429 @@
+---
+linkTitle: "Classify images"
+title: "Classify images"
+weight: 30
+layout: "docs"
+type: "docs"
+description: "Use a vision service to classify images by label and confidence, make decisions based on classification, and monitor scenes continuously."
+date: "2025-01-30"
+aliases:
+  - /build/vision-detection/classify-objects/
+  - /vision-detection/classify-objects/
+---
+
+Detection tells you where objects are in an image. Classification tells you what the entire image (or a region of it) contains. If you need to answer "is this a picture of a cat or a dog?" rather than "where are the cats and dogs in this picture?", classification is the right tool. This how-to shows you how to get classifications from your vision service and use them in application logic.
+
+## Concepts
+
+### What a classification contains
+
+A classification is a label paired with a confidence score. Unlike detections, classifications do not include spatial information -- there are no bounding box coordinates. Each classification describes the image as a whole.
+
+| Field        | Type            | Description                                                          |
+| ------------ | --------------- | -------------------------------------------------------------------- |
+| `class_name` | String          | The label assigned by the model (for example, "cat", "dog", "empty") |
+| `confidence` | Float (0.0-1.0) | How confident the model is in this label                             |
+
+A single classification call returns multiple results ranked by confidence. The `count` parameter controls how many top results to return.
+
+### Single-label vs multi-label classification
+
+**Single-label classification** assumes the image belongs to exactly one category. The confidences across all classes sum to approximately 1.0. If the model says "cat: 0.85", it implicitly says "not-dog: 0.15". Most classification models work this way.
+
+**Multi-label classification** allows the image to belong to multiple categories simultaneously. An image could be classified as both "outdoor: 0.92" and "sunny: 0.88" at the same time. The confidences are independent and do not sum to 1.0.
+
+The API is the same for both. The difference is in how the model was trained and how you interpret the results.
+
+### The count parameter
+
+The `count` parameter tells the vision service how many top classifications to return. If `count=3`, you get the three highest-confidence labels. This is useful for:
+
+- Understanding what else the model considered (was it confused between two classes?)
+- Multi-label classification where you want all relevant labels
+- Debugging model performance by seeing the runner-up predictions
+
+### Classification vs detection: when to use which
+
+| Use classification when              | Use detection when                 |
+| ------------------------------------ | ---------------------------------- |
+| You care about the whole scene       | You care about individual objects  |
+| You need a yes/no or category answer | You need object locations          |
+| There is one dominant subject        | There are multiple objects to find |
+| You want to sort or categorize       | You want to count or track         |
+
+You can use both on the same camera. Run a classifier for scene-level understanding and a detector for object-level detail.
+
+## Steps
+
+### 1. Get classifications from a camera
+
+The simplest approach lets the vision service capture an image and classify it in one call.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.services.vision import VisionClient
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    classifier = VisionClient.from_robot(robot, "my-classifier")
+
+    # Get top 3 classifications from the camera
+    classifications = await classifier.get_classifications_from_camera(
+        "my-camera", count=3
+    )
+
+    for c in classifications:
+        print(f"{c.class_name}: {c.confidence:.2f}")
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/services/vision"
+    "go.viam.com/utils/rpc"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("classify")
+
+    machine, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithDialOptions(rpc.WithEntityCredentials(
+            "YOUR-API-KEY-ID",
+            rpc.Credentials{
+                Type:    rpc.CredentialsTypeAPIKey,
+                Payload: "YOUR-API-KEY",
+            })),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer machine.Close(ctx)
+
+    classifier, err := vision.FromProvider(machine, "my-classifier")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    // Get top 3 classifications from the camera
+    classifications, err := classifier.ClassificationsFromCamera(
+        ctx, "my-camera", 3, nil,
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    for _, c := range classifications {
+        fmt.Printf("%s: %.2f\n", c.Label(), c.Score())
+    }
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 2. Get classifications from an existing image
+
+If you have an image from a previous capture or a file, classify it directly.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.components.camera import Camera
+from viam.services.vision import VisionClient
+
+camera = Camera.from_robot(robot, "my-camera")
+classifier = VisionClient.from_robot(robot, "my-classifier")
+
+# Capture images from the camera
+images, _ = await camera.get_images()
+
+# Classify the first image
+classifications = await classifier.get_classifications(images[0], count=5)
+
+for c in classifications:
+    print(f"{c.class_name}: {c.confidence:.2f}")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+cam, err := camera.FromProvider(machine, "my-camera")
+if err != nil {
+    logger.Fatal(err)
+}
+
+classifier, err := vision.FromProvider(machine, "my-classifier")
+if err != nil {
+    logger.Fatal(err)
+}
+
+images, _, err := cam.Images(ctx, nil, nil)
+if err != nil {
+    logger.Fatal(err)
+}
+img, err := images[0].Image(ctx)
+if err != nil {
+    logger.Fatal(err)
+}
+
+classifications, err := classifier.Classifications(ctx, img, 5, nil)
+if err != nil {
+    logger.Fatal(err)
+}
+
+for _, c := range classifications {
+    fmt.Printf("%s: %.2f\n", c.Label(), c.Score())
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 3. Make decisions based on classification
+
+Classification is most useful when it drives application logic. Use the top classification to branch your program's behavior.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+classifications = await classifier.get_classifications_from_camera(
+    "my-camera", count=1
+)
+
+if not classifications:
+    print("No classification result")
+elif classifications[0].confidence < 0.5:
+    print(f"Uncertain: {classifications[0].class_name} "
+          f"({classifications[0].confidence:.2f})")
+else:
+    label = classifications[0].class_name
+    confidence = classifications[0].confidence
+    print(f"Classified as: {label} ({confidence:.2f})")
+
+    if label == "defective":
+        print("Triggering rejection mechanism")
+        # Add your action here
+    elif label == "good":
+        print("Part passes inspection")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+classifications, err := classifier.ClassificationsFromCamera(
+    ctx, "my-camera", 1, nil,
+)
+if err != nil {
+    logger.Fatal(err)
+}
+
+if len(classifications) == 0 {
+    fmt.Println("No classification result")
+} else if classifications[0].Score() < 0.5 {
+    fmt.Printf("Uncertain: %s (%.2f)\n",
+        classifications[0].Label(), classifications[0].Score())
+} else {
+    label := classifications[0].Label()
+    confidence := classifications[0].Score()
+    fmt.Printf("Classified as: %s (%.2f)\n", label, confidence)
+
+    switch label {
+    case "defective":
+        fmt.Println("Triggering rejection mechanism")
+        // Add your action here
+    case "good":
+        fmt.Println("Part passes inspection")
+    }
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 4. Monitor classifications continuously
+
+Run classifications in a loop to monitor a scene over time. Track when the classification changes.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+import asyncio
+import time
+
+classifier = VisionClient.from_robot(robot, "my-classifier")
+previous_label = ""
+
+while True:
+    classifications = await classifier.get_classifications_from_camera(
+        "my-camera", count=1
+    )
+
+    if classifications and classifications[0].confidence >= 0.6:
+        current_label = classifications[0].class_name
+        confidence = classifications[0].confidence
+
+        if current_label != previous_label:
+            print(f"Scene changed: {previous_label or 'unknown'} "
+                  f"-> {current_label} ({confidence:.2f})")
+            previous_label = current_label
+    else:
+        if previous_label:
+            print(f"Scene uncertain (was: {previous_label})")
+
+    await asyncio.sleep(0.5)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+classifier, err := vision.FromProvider(machine, "my-classifier")
+if err != nil {
+    logger.Fatal(err)
+}
+
+previousLabel := ""
+
+for {
+    classifications, err := classifier.ClassificationsFromCamera(
+        ctx, "my-camera", 1, nil,
+    )
+    if err != nil {
+        logger.Error(err)
+        time.Sleep(time.Second)
+        continue
+    }
+
+    if len(classifications) > 0 && classifications[0].Score() >= 0.6 {
+        currentLabel := classifications[0].Label()
+        confidence := classifications[0].Score()
+
+        if currentLabel != previousLabel {
+            if previousLabel == "" {
+                fmt.Printf("Scene changed: unknown -> %s (%.2f)\n",
+                    currentLabel, confidence)
+            } else {
+                fmt.Printf("Scene changed: %s -> %s (%.2f)\n",
+                    previousLabel, currentLabel, confidence)
+            }
+            previousLabel = currentLabel
+        }
+    } else if previousLabel != "" {
+        fmt.Printf("Scene uncertain (was: %s)\n", previousLabel)
+    }
+
+    time.Sleep(500 * time.Millisecond)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 5. Use the transform camera to overlay classifications
+
+You can add a `transform` camera that overlays classification results directly on the camera feed. This is useful for debugging and monitoring without writing code.
+
+Add a transform camera to your configuration:
+
+```json
+{
+  "name": "classified-feed",
+  "api": "rdk:component:camera",
+  "model": "transform",
+  "attributes": {
+    "source": "my-camera",
+    "pipeline": [
+      {
+        "type": "classifications",
+        "attributes": {
+          "classifier_name": "my-classifier",
+          "confidence_threshold": 0.5,
+          "max_classifications": 3
+        }
+      }
+    ]
+  }
+}
+```
+
+After saving, view the `classified-feed` camera in the CONTROL tab. You will see classification labels overlaid on the camera image.
+
+{{< alert title="Tip" color="tip" >}}
+If you need the image and its classifications together in one call, use [`CaptureAllFromCamera`](/reference/apis/services/vision/#captureallfromcamera). This is more efficient than separate calls and ensures the classifications correspond exactly to the returned image. See [Detect Objects, step 7](/vision/detect/#7-get-everything-in-one-call-with-captureallfromcamera) for a full example.
+{{< /alert >}}
+
+## Try It
+
+1. Run the classification script from step 1. Point the camera at different scenes and observe how the top label changes.
+2. Increase the `count` parameter to 5 or 10 and observe how confidence distributes across labels.
+3. Implement the decision logic from step 3 with labels relevant to your model.
+4. Set up the transform camera from step 5 and watch classifications update in real time from the CONTROL tab.
+
+## Troubleshooting
+
+{{< expand "No classifications returned" >}}
+
+- Verify the vision service is running and the ML model service loaded successfully. Check the `viam-server` logs for errors.
+- Ensure the `count` parameter is at least 1. A `count` of 0 returns no results.
+- Some vision services configured for detection do not support classification. Check that your model was trained for classification.
+
+{{< /expand >}}
+
+{{< expand "All classifications have very low confidence" >}}
+
+- The model may not have been trained on the type of image you are showing it. A model trained on close-up product photos will perform poorly on wide-angle room views.
+- Lighting and image quality affect classification confidence. Test under conditions similar to the training data.
+- If all classes show roughly equal confidence (for example, five classes each at ~0.2), the model is essentially guessing. The input image likely does not match anything in the training set.
+
+{{< /expand >}}
+
+{{< expand "Classification is inconsistent between frames" >}}
+
+- Small changes in lighting, angle, or camera noise can shift classification results. If you need stable results, average classifications over several frames or require a minimum confidence threshold before acting on a result.
+- The monitoring loop in step 4 already handles this by only reacting when the top label changes and exceeds the confidence threshold.
+
+{{< /expand >}}
+
+{{< expand "Transform camera shows no overlay" >}}
+
+- Verify the `classifier_name` in the transform camera configuration matches the name of your vision service exactly.
+- Check that the `source` camera name is correct.
+- Try lowering the `confidence_threshold` in the transform configuration.
+
+{{< /expand >}}
+
+## What's Next
+
+- [Detect Objects (2D)](/vision/detect/) -- get per-object bounding boxes instead of whole-image labels.
+- [Track Objects Across Frames](/vision/track/) -- maintain object identities across consecutive frames.
+- [Alert on Detections](/vision/alert-on-detections/) -- send email or webhook notifications when specific objects or labels are detected.
diff --git a/docs/vision/configure.md b/docs/vision/configure.md
new file mode 100644
index 0000000000..6cfc88fae9
--- /dev/null
+++ b/docs/vision/configure.md
@@ -0,0 +1,551 @@
+---
+linkTitle: "Configure a vision pipeline"
+title: "Configure a vision pipeline"
+weight: 10
+layout: "docs"
+type: "docs"
+modulescript: true
+description: "Deploy an ML model and configure a vision service to give your machine the ability to detect or classify objects."
+date: "2025-01-30"
+aliases:
+  - /build/vision-detection/add-computer-vision/
+  - /vision-detection/add-computer-vision/
+---
+
+You have a trained machine learning model and a camera, and you want your machine to understand what it sees.
+This how-to configures both an ML model service and a vision service so that downstream how-to guides --[Detect Objects](/vision/detect/), [Classify Images](/vision/classify/), [Track Objects](/vision/track/) --have a working vision pipeline to build on.
+
+## Concepts
+
+### The two-service architecture
+
+Most robotics platforms handle ML inference as a monolithic block: one configuration entry that loads a model and runs it against a camera. Viam splits this into two services for a reason.
+
+The **ML model service** handles the mechanics of model loading: reading the file, allocating memory, preparing the inference runtime. The **vision service** handles the semantics: what does "run a detection" mean, how do you map model outputs to bounding boxes, how do you associate results with camera frames.
+
+This separation means:
+
+- You can update your model (retrain, swap architectures) without changing your vision service configuration.
+- You can run the same model against multiple cameras by creating multiple vision services that reference the same ML model service.
+- Different model formats (TFLite, ONNX, TensorFlow, PyTorch) are handled by different ML model service implementations, but the vision service API stays the same.
+
+### Supported frameworks and hardware
+
+Viam currently supports the following frameworks:
+
+<!-- prettier-ignore -->
+| Model Framework | ML Model Service | Hardware Support | Description |
+| --------------- | --------------- | ------------------- | ----------- |
+| [TensorFlow Lite](https://www.tensorflow.org/lite) | [`tflite_cpu`](https://app.viam.com/module/viam/tflite_cpu) | linux/amd64, linux/arm64, darwin/arm64, darwin/amd64 | Quantized version of TensorFlow that has reduced compatibility for models but supports more hardware. Uploaded models must adhere to the [model requirements](https://app.viam.com/module/viam/tflite_cpu). |
+| [ONNX](https://onnx.ai/) | [`onnx-cpu`](https://app.viam.com/module/viam/onnx-cpu), [`triton`](https://app.viam.com/module/viam/mlmodelservice-triton-jetpack) | Nvidia GPU, linux/amd64, linux/arm64, darwin/arm64 | Universal format that is not optimized for hardware-specific inference but runs on a wide variety of machines. |
+| [TensorFlow](https://www.tensorflow.org/) | [`tensorflow-cpu`](https://app.viam.com/module/viam/tensorflow-cpu), [`triton`](https://app.viam.com/module/viam/mlmodelservice-triton-jetpack) | Nvidia GPU, linux/amd64, linux/arm64, darwin/arm64 | A full framework designed for more production-ready systems. |
+| [PyTorch](https://pytorch.org/) | [`torch-cpu`](https://app.viam.com/module/viam/torch-cpu), [`triton`](https://app.viam.com/module/viam/mlmodelservice-triton-jetpack) | Nvidia GPU, linux/arm64, darwin/arm64 | A full framework that was built primarily for research. Because of this, it is much faster to do iterative development with (the model doesn't have to be predefined) but it is not as "production ready" as TensorFlow. It is the most common framework for open-source models because it is the go-to framework for ML researchers. |
+
+{{< alert title="Note" color="note" >}}
+For some ML model services, like the [Triton ML model service](https://github.com/viamrobotics/viam-mlmodelservice-triton/) for Jetson boards, you can configure the service to use either the available CPU or a dedicated GPU.
+{{< /alert >}}
+
+Entry-level devices such as the Raspberry Pi 4 can run small ML models, such as TensorFlow Lite (TFLite).
+More powerful hardware, including the Jetson Xavier or Raspberry Pi 5 with an AI HAT+, can process larger models, including TensorFlow and ONNX.
+If your hardware does not support the model you want to run, see [Cloud inference](#cloud-inference).
+
+### ML model service
+
+The ML model service loads a model file and exposes it for inference. The most common implementation is `tflite_cpu`, which runs TensorFlow Lite models on the CPU. Other implementations support ONNX, TensorFlow SavedModel, and PyTorch.
+
+When you deploy a model from the Viam registry, the model files are downloaded to your machine and referenced with the `${packages.model-name}` variable. You can also point directly to a local file path if you have a model file on disk.
+
+The `tflite_cpu` implementation runs entirely on the CPU, so it works on any hardware --no GPU required. For Raspberry Pi, Jetson Nano, and other edge machines, this is the standard approach. Performance depends on the model size: a MobileNet-based detector typically runs at 5-10 frames per second on a Raspberry Pi 4.
+
+### Vision service
+
+The vision service connects an ML model to a camera and provides high-level APIs for detection and classification. The `mlmodel` implementation takes detections or classifications from the ML model and returns them as structured data: bounding boxes with labels and confidence scores for detections, or label-confidence pairs for classifications.
+
+The vision service is what your code interacts with. You never call the ML model service directly from application code. This means switching from a detection model to a classification model requires only a configuration change to the ML model service, not a rewrite of your application.
+
+The vision service also handles the image capture pipeline. When you call `GetDetectionsFromCamera`, the vision service captures a frame from the specified camera, converts it to the format expected by the model, runs inference, and returns structured results. You do not need to manage image capture and model input formatting yourself.
+
+### Labels and label files
+
+ML models output numeric class IDs, not human-readable names. A detection model might output class ID `3`, which means nothing to you. The **label file** maps these IDs to names: class 3 might be "dog", class 7 might be "car".
+
+The label file is a plain text file with one label per line. The line number (zero-indexed) corresponds to the class ID. For example:
+
+```text
+background
+person
+bicycle
+car
+motorcycle
+```
+
+In this file, class ID 0 is "background", class ID 1 is "person", and so on. When you configure the ML model service with a `label_path`, detections and classifications will use these human-readable names instead of numeric IDs.
+
+If you do not provide a label file, detections will report numeric class IDs as their labels.
+
+### Model sources
+
+The service works with models from various sources:
+
+- You can [train TensorFlow or TensorFlow Lite](/train/train-a-model/) or [other model frameworks](/train/custom-training-scripts/) on data from your machines.
+- You can use [ML models](https://app.viam.com/registry?type=ML+Model) from the [registry](https://app.viam.com/registry).
+- You can upload externally trained models from a model file on the [**MODELS** tab](https://app.viam.com/models).
+- You can use models trained outside the Viam platform whose files are on your machine.
+  See the documentation for the ML model service you're using (pick one that supports your model framework) for instructions on this.
+
+{{< alert title="Add support for other models" color="tip" >}}
+ML models must be designed in particular shapes to work with the `mlmodel` [classification](/vision/configure/) or [detection](/vision/configure/) models of Viam's [vision service](/vision/configure/).
+See [ML Model Design](/reference/) to design a modular ML model service with models that work with vision.
+{{< /alert >}}
+
+## Steps
+
+### 1. Add an ML model service
+
+1. Go to [app.viam.com](https://app.viam.com) and navigate to your machine.
+2. Confirm it shows as **Live**.
+3. Click the **+** button.
+4. Select **Configuration block**.
+5. Search for **tflite_cpu** (or the appropriate implementation for your
+   model format). For help choosing, see [Supported frameworks and hardware](#supported-frameworks-and-hardware).
+6. Click **Add component**, name it `my-ml-model`, and click **Add component**
+   again to confirm.
+
+### 2. Configure the ML model service
+
+After creating the service, configure it to point to your model file.
+
+**If you deployed a model from the Viam registry:**
+
+```json
+{
+  "name": "my-ml-model",
+  "api": "rdk:service:mlmodel",
+  "model": "tflite_cpu",
+  "attributes": {
+    "model_path": "${packages.my-model}/model.tflite",
+    "label_path": "${packages.my-model}/labels.txt"
+  }
+}
+```
+
+The `${packages.my-model}` variable resolves to the directory where the registry package was downloaded. Replace `my-model` with the name of your deployed model package.
+
+**If you have a local model file:**
+
+```json
+{
+  "name": "my-ml-model",
+  "api": "rdk:service:mlmodel",
+  "model": "tflite_cpu",
+  "attributes": {
+    "model_path": "/path/to/your/model.tflite",
+    "label_path": "/path/to/your/labels.txt"
+  }
+}
+```
+
+The `model_path` is the path to the model file on the machine where `viam-server` is running. The `label_path` is optional but recommended --it maps numeric class IDs to human-readable names.
+
+#### Deploy a specific version of an ML model
+
+When you add a model to the ML model service in the app interface, it automatically uses the latest version.
+In the ML model service panel, you can change the version in the version dropdown.
+Save your config to use your specified version of the ML model.
+
+### 3. Add a vision service
+
+1. Click the **+** button.
+2. Select **Configuration block**.
+3. Search for **vision / mlmodel** (`vision:mlmodel`). You can also search for
+   **computer vision**.
+4. Click **Add component**, name it `my-detector`, and click **Add component**
+   again to confirm.
+
+### 4. Configure the vision service
+
+Link the vision service to your ML model service:
+
+```json
+{
+  "name": "my-detector",
+  "api": "rdk:service:vision",
+  "model": "mlmodel",
+  "attributes": {
+    "mlmodel_name": "my-ml-model"
+  }
+}
+```
+
+The `mlmodel_name` must match the name you gave your ML model service in step 1. This is how the vision service knows which model to use for inference.
+
+For the full list of `mlmodel` vision service configuration attributes, see [Configure an mlmodel Detector or Classifier](/vision/configure/).
+
+### 5. Save the configuration
+
+Click **Save** in the upper right. `viam-server` reloads automatically and initializes both services. You do not need to restart anything.
+
+You can verify which capabilities your vision service supports by calling [`GetProperties`](/reference/apis/services/vision/#getproperties). This returns whether the service supports detections, classifications, and 3D object point clouds.
+
+### 6. Test from the CONTROL tab
+
+1. Go to the **CONTROL** tab in the Viam app.
+2. Find your camera in the component list and open it.
+3. Enable the camera stream.
+4. In the vision service overlay dropdown, select your vision service (`my-detector`).
+5. You should see bounding boxes drawn on the camera feed if your model is detecting objects in the current frame.
+
+If the camera feed appears but no detections are shown, point the camera at an object your model was trained to recognize. If you are using a general-purpose COCO model, try pointing the camera at a person, a cup, or a keyboard.
+
+### 7. Verify the full configuration
+
+Your machine configuration should now include both services. The relevant sections look like this:
+
+```json
+{
+  "services": [
+    {
+      "name": "my-ml-model",
+      "api": "rdk:service:mlmodel",
+      "model": "tflite_cpu",
+      "attributes": {
+        "model_path": "${packages.my-model}/model.tflite",
+        "label_path": "${packages.my-model}/labels.txt"
+      }
+    },
+    {
+      "name": "my-detector",
+      "api": "rdk:service:vision",
+      "model": "mlmodel",
+      "attributes": {
+        "mlmodel_name": "my-ml-model"
+      }
+    }
+  ]
+}
+```
+
+The ML model service must be listed before or alongside the vision service. The vision service depends on the ML model service, and `viam-server` resolves dependencies automatically regardless of order in the configuration file.
+
+### mlmodel vision service attributes
+
+The `mlmodel_name` attribute is the only required field. The remaining attributes let you fine-tune how the vision service interprets model output:
+
+| Attribute                    | Type           | Required     | Description                                                                                                                                                                             |
+| ---------------------------- | -------------- | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `mlmodel_name`               | string         | **Required** | Name of the ML model service to use.                                                                                                                                                    |
+| `default_minimum_confidence` | float          | Optional     | Minimum confidence threshold (0.0-1.0) for all labels. Detections and classifications below this are filtered out.                                                                      |
+| `label_confidences`          | object         | Optional     | Per-label confidence thresholds. Keys are label names, values are minimum confidence (0.0-1.0). Overrides `default_minimum_confidence` for specific labels.                             |
+| `label_path`                 | string         | Optional     | Path to a labels file. Overrides the label file specified in the ML model service.                                                                                                      |
+| `camera_name`                | string         | Optional     | Default camera to use when calling methods that take a camera name.                                                                                                                     |
+| `remap_input_names`          | object         | Optional     | Map model input tensor names to the names the vision service expects. Use when the model's input names do not match the standard convention.                                            |
+| `remap_output_names`         | object         | Optional     | Map model output tensor names to the names the vision service expects (for example, `location`, `category`, `score`). Use when the model's output names differ from the expected names. |
+| `xmin_ymin_xmax_ymax_order`  | array of int   | Optional     | Specifies the order of bounding box coordinates in the model's output tensor as indices `[xmin, ymin, xmax, ymax]`. Use when the model outputs coordinates in a non-standard order.     |
+| `input_image_mean_value`     | array of float | Optional     | Per-channel mean values for input image normalization (for example, `[127.5, 127.5, 127.5]`). Subtracted from each pixel before inference.                                              |
+| `input_image_std_dev`        | array of float | Optional     | Per-channel standard deviation values for input normalization (for example, `[127.5, 127.5, 127.5]`). Each pixel is divided by this after mean subtraction.                             |
+| `input_image_bgr`            | bool           | Optional     | Set to `true` if the model expects BGR channel order instead of RGB. Default: `false`.                                                                                                  |
+
+For most pre-trained models from the Viam registry, only `mlmodel_name` is needed. The advanced attributes are useful when working with custom models that have non-standard input/output formats.
+
+### Using an ML model service directly
+
+You can also use the ML model service directly to run raw tensor inference, without a vision service.
+This is useful for non-vision ML models or when you need to interpret the raw model output yourself.
+
+{{< tabs >}}
+{{% tab name="Web UI" %}}
+
+1. Visit your machine's **CONFIGURE** or **CONTROL** page.
+1. Expand the **TEST** area of the ML model service panel to view the tensor output.
+
+{{< imgproc src="/tutorials/data-management/tensor-output.png" alt="Example tensor output" resize="x1000" class="shadow imgzoom fill" >}}
+
+{{% /tab %}}
+{{% tab name="Python" %}}
+
+The following code passes an image to an ML model service, and uses the [`Infer`](/reference/apis/services/ml/#infer) method to make inferences:
+
+{{< read-code-snippet file="/static/include/examples-generated/run-inference.snippet.run-inference.py" lang="py" class="line-numbers linkable-line-numbers" data-line="82-85" >}}
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+The following code passes an image to an ML model service, and uses the [`Infer`](/reference/apis/services/ml/#infer) method to make inferences:
+
+{{< read-code-snippet file="/static/include/examples-generated/run-inference.snippet.run-inference.go" lang="go" class="line-numbers linkable-line-numbers" data-line="161-164" >}}
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Available services and models
+
+### Available ML model services
+
+{{<resources_svc api="rdk:service:mlmodel" type="ML model">}}
+
+### Available vision services
+
+{{% expand "Click to search available vision services" %}}
+
+{{<resources_svc api="rdk:service:vision" type="vision">}}
+
+{{% /expand%}}
+
+{{% expand "Click to view example vision services" %}}
+
+<!-- prettier-ignore -->
+| Example | Description |
+| ------- | ----------- |
+| Detect a variety of objects | Use the [`viam:vision:mlmodel`](/vision/configure/) vision service with the `EfficientDet-COCO` ML model to detect a variety of objects, including people, bicycles, and apples, in a camera feed. |
+| Detect license plates | Use the [`viam-soleng:vision:openalpr`](https://app.viam.com/module/viam-soleng/viamalpr) vision service to detect license plates in images. This service includes its own ML model. |
+
+{{% /expand%}}
+
+### Available machine learning models
+
+You can use these publicly available machine learning models:
+
+{{<mlmodels>}}
+
+## Try It
+
+Verify the full pipeline is working by running a quick detection from code.
+
+Install the SDK if you haven't already:
+
+```bash
+pip install viam-sdk
+```
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+Save this as `vision_test.py`:
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.services.vision import VisionClient
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    detector = VisionClient.from_robot(robot, "my-detector")
+    detections = await detector.get_detections_from_camera("my-camera")
+
+    print(f"Found {len(detections)} detections:")
+    for d in detections:
+        print(f"  {d.class_name}: {d.confidence:.2f}")
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Run it:
+
+```bash
+python vision_test.py
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```bash
+mkdir vision-test && cd vision-test
+go mod init vision-test
+go get go.viam.com/rdk
+```
+
+Save this as `main.go`:
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/services/vision"
+    "go.viam.com/utils/rpc"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("vision-test")
+
+    machine, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithDialOptions(rpc.WithEntityCredentials(
+            "YOUR-API-KEY-ID",
+            rpc.Credentials{
+                Type:    rpc.CredentialsTypeAPIKey,
+                Payload: "YOUR-API-KEY",
+            })),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer machine.Close(ctx)
+
+    detector, err := vision.FromProvider(machine, "my-detector")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    detections, err := detector.DetectionsFromCamera(ctx, "my-camera", nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    fmt.Printf("Found %d detections:\n", len(detections))
+    for _, d := range detections {
+        fmt.Printf("  %s: %.2f\n", d.Label(), d.Score())
+    }
+}
+```
+
+Run it:
+
+```bash
+go run main.go
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+You should see a list of detected objects with their confidence scores. If the list is empty, point the camera at objects your model recognizes.
+
+Replace the placeholder values in both examples:
+
+1. In the Viam app, go to your machine's **CONNECT** tab.
+2. Select **API keys** and copy your API key and API key ID.
+3. Copy the machine address from the same tab.
+
+To confirm the full pipeline is working end-to-end:
+
+1. Run the Python or Go script.
+2. Point the camera at an object your model recognizes.
+3. Verify the script prints at least one detection with a confidence score above 0.5.
+4. Move the object out of frame and run the script again. Verify that no detections (or only low-confidence detections) are returned.
+
+If both tests pass, your vision pipeline is configured correctly and ready for use by downstream how-to guides.
+
+## Cloud inference
+
+Cloud inference enables you to run machine learning models in the Viam cloud, instead of on a local machine.
+Cloud inference provides more computing power than edge devices, enabling you to run more computationally-intensive models or achieve faster inference times.
+
+You can run cloud inference using any TensorFlow and TensorFlow Lite model in the Viam registry, including unlisted models owned by or shared with you.
+
+To run cloud inference, you must pass the following:
+
+- the binary data ID and organization of the data you want to run inference on
+- the name, version, and organization of the model you want to use for inference
+
+You can obtain the binary data ID from the [**DATA** tab](https://app.viam.com/data/view) and the organization ID by running the CLI command `viam org list`.
+You can find the model information on the [**MODELS** tab](https://app.viam.com/models).
+
+```sh {class="command-line" data-prompt="$" data-output="2-18"}
+viam infer --binary-data-id <binary-data-id> --model-name <model-name> --model-org-id <org-id-that-owns-model> --model-version "2025-04-14T16-38-25" --org-id <org-id-that-executes-inference>
+Inference Response:
+Output Tensors:
+  Tensor Name: num_detections
+    Shape: [1]
+    Values: [1.0000]
+  Tensor Name: classes
+    Shape: [32 1]
+    Values: [...]
+  Tensor Name: boxes
+    Shape: [32 1 4]
+    Values: [...]
+  Tensor Name: confidence
+    Shape: [32 1]
+    Values: [...]
+Annotations:
+Bounding Box Format: [x_min, y_min, x_max, y_max]
+  No annotations.
+```
+
+The command returns a list of detected classes or bounding boxes depending on the output of the ML model you specified, as well as a list of confidence values for those classes or boxes.
+The bounding box output uses proportional coordinates between 0 and 1, with the origin `(0, 0)` in the top left of the image and `(1, 1)` in the bottom right.
+
+For more information, see [`viam infer`](/cli/).
+
+## Troubleshooting
+
+{{< expand "Vision service fails to start" >}}
+
+- Check the `viam-server` logs for error messages. The most common cause is a mismatch between the `mlmodel_name` in the vision service config and the name of the ML model service.
+- Verify both services are saved in the configuration.
+
+{{< /expand >}}
+
+{{< expand "ML model service fails to load the model" >}}
+
+- Verify the `model_path` points to a file that exists on the machine. If using `${packages.my-model}`, confirm the model package is deployed to the machine through the ML model service configuration panel.
+- Check that the model file format matches the ML model implementation. A `.tflite` file requires `tflite_cpu`, not `onnx_cpu`.
+- On resource-constrained machines, large models may fail to load due to insufficient memory. Check system memory usage.
+
+{{< /expand >}}
+
+{{< expand "Detections are empty even though the camera works" >}}
+
+- Verify the model is trained to detect the objects in the camera's field of view. A model trained on dogs will not detect cats.
+- Check the confidence threshold. Some models produce low-confidence detections that may be filtered out by default. Try lowering the threshold if your vision service configuration supports it.
+- Ensure the camera resolution and image format are compatible with the model's expected input. Most TFLite models expect RGB images.
+
+{{< /expand >}}
+
+{{< expand "Detections are inaccurate or noisy" >}}
+
+- The model may need more training data. See [Train a Model](/train/train-a-model/) for improving model quality.
+- Lighting conditions affect detection quality significantly. Test under the same lighting conditions the model was trained for.
+- If using a general-purpose model, expect lower accuracy than a model trained specifically for your use case.
+
+{{< /expand >}}
+
+{{< expand "\"Model not found\" error in code" >}}
+
+- The service name in your code must match the name in the Viam app configuration exactly. Names are case-sensitive.
+- Verify the machine is online and `viam-server` is running.
+- Check that you are connecting to the correct machine address.
+
+{{< /expand >}}
+
+{{< expand "Multiple vision services on the same model" >}}
+
+If you configured two vision services that reference the same ML model service, and one works while the other does not, check the `mlmodel_name` attribute in both. A common mistake is pointing both vision services at each other instead of at the ML model service.
+
+{{< /expand >}}
+
+{{< expand "Model loads but inference is very slow" >}}
+
+- On a Raspberry Pi 4, a typical TFLite model runs inference in 100-500ms per frame. This is normal for CPU-based inference.
+- Larger models take longer. If you need faster inference, use a smaller model architecture (MobileNet is faster than EfficientDet) or reduce the input image resolution.
+- Check CPU usage on the machine. If other processes are consuming CPU, inference will be slower. Use `top` or `htop` to monitor.
+
+{{< /expand >}}
+
+{{< expand "Label file format errors" >}}
+
+- The label file must be plain text with one label per line. No headers, no commas, no quotes.
+- The number of labels must match the number of output classes in the model. If your model outputs 80 classes but your label file has 79 lines, the last class will have no name.
+- Encoding must be UTF-8. Non-ASCII characters in labels may cause issues on some systems.
+
+{{< /expand >}}
+
+## What's Next
+
+- [Detect Objects](/vision/detect/) --use the vision service to get bounding boxes, filter by confidence, and process detection results in code.
+- [Classify Images](/vision/classify/) --use the vision service for whole-image classification instead of per-object detection.
+- [Act on Detections](/vision/act-on-detections/) --create modules that act on detection or classification results.
+- [Alert on Detections](/vision/alert-on-detections/) --send alerts when specific objects are detected.
+- [Train a Model](/train/train-a-model/) --train a custom model on your own data for better accuracy on your specific use case.
diff --git a/docs/vision/detect.md b/docs/vision/detect.md
new file mode 100644
index 0000000000..a963fb9b9f
--- /dev/null
+++ b/docs/vision/detect.md
@@ -0,0 +1,516 @@
+---
+linkTitle: "Detect objects"
+title: "Detect objects"
+weight: 20
+layout: "docs"
+type: "docs"
+description: "Retrieve 2D bounding-box detections from a vision service, filter by confidence and class, and run detections in a loop."
+date: "2025-01-30"
+aliases:
+  - /build/vision-detection/detect-objects-2d/
+  - /vision-detection/detect-objects-2d/
+---
+
+Your vision service is configured and running, but you need to do something useful with the results. This how-to shows you how to retrieve detections programmatically, filter them to reduce noise, and extract the information you need to build real applications -- counting objects, triggering actions when something appears, or feeding positions into a control loop.
+
+## Concepts
+
+### What a detection contains
+
+A detection is a single recognized object in an image. Each detection includes:
+
+| Field        | Type            | Description                                                                 |
+| ------------ | --------------- | --------------------------------------------------------------------------- |
+| `class_name` | String          | The label assigned by the model (for example, "person", "dog", "stop-sign") |
+| `confidence` | Float (0.0-1.0) | How confident the model is in this detection                                |
+| `x_min`      | Integer         | Left edge of the bounding box in pixels                                     |
+| `y_min`      | Integer         | Top edge of the bounding box in pixels                                      |
+| `x_max`      | Integer         | Right edge of the bounding box in pixels                                    |
+| `y_max`      | Integer         | Bottom edge of the bounding box in pixels                                   |
+
+The bounding box coordinates use the image coordinate system: (0,0) is the top-left corner, x increases to the right, y increases downward. The bounding box is axis-aligned (not rotated).
+
+Detections also include normalized coordinates (`x_min_normalized`, `y_min_normalized`, `x_max_normalized`, `y_max_normalized`) as floats between 0.0 and 1.0, representing positions relative to image dimensions. These are useful when you need resolution-independent coordinates.
+
+A single call to the detection API can return zero, one, or many detections. The number depends on how many objects the model finds in the frame.
+
+### GetDetections vs GetDetectionsFromCamera
+
+The vision service provides two methods for getting detections:
+
+- **GetDetectionsFromCamera** takes a camera name and handles everything: it captures an image from the camera, runs it through the model, and returns detections. This is the simplest approach and the one you should use in most cases.
+- **GetDetections** takes an image you already have and runs it through the model. Use this when you need to run detection on an image you captured separately, an image from a file, or an image you have preprocessed.
+
+### Confidence thresholds
+
+Every detection has a confidence score between 0.0 and 1.0. A score of 0.95 means the model is very confident; a score of 0.3 means it is guessing. Models often produce many low-confidence detections that are noise rather than real objects.
+
+Choosing the right threshold depends on your application:
+
+- **Safety-critical applications** (such as detecting people before a robot moves): use a low threshold (0.3-0.5) to avoid missing real objects, and accept some false positives.
+- **Counting or logging applications**: use a higher threshold (0.7-0.9) to reduce noise and get accurate counts.
+- **Start at 0.5** and adjust based on what you observe.
+
+### The color_detector alternative
+
+Not every detection task requires a trained ML model. Viam includes a built-in `color_detector` vision service model that detects regions of a specified color. This is useful for simple tasks like finding a red ball or detecting a blue marker. It requires no model training, no GPU, and minimal configuration.
+
+## Steps
+
+### 1. Get detections from a camera
+
+The simplest way to get detections is to let the vision service capture an image and run the model in one call.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.services.vision import VisionClient
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    detector = VisionClient.from_robot(robot, "my-detector")
+
+    # Get detections directly from the camera
+    detections = await detector.get_detections_from_camera("my-camera")
+
+    for d in detections:
+        print(f"{d.class_name}: {d.confidence:.2f} "
+              f"at ({d.x_min},{d.y_min})-({d.x_max},{d.y_max})")
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/services/vision"
+    "go.viam.com/utils/rpc"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("detect")
+
+    machine, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithDialOptions(rpc.WithEntityCredentials(
+            "YOUR-API-KEY-ID",
+            rpc.Credentials{
+                Type:    rpc.CredentialsTypeAPIKey,
+                Payload: "YOUR-API-KEY",
+            })),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer machine.Close(ctx)
+
+    detector, err := vision.FromProvider(machine, "my-detector")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    detections, err := detector.DetectionsFromCamera(ctx, "my-camera", nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    for _, d := range detections {
+        fmt.Printf("%s: %.2f at (%d,%d)-(%d,%d)\n",
+            d.Label(), d.Score(),
+            d.BoundingBox().Min.X, d.BoundingBox().Min.Y,
+            d.BoundingBox().Max.X, d.BoundingBox().Max.Y)
+    }
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 2. Get detections from an existing image
+
+If you already have an image -- from a file, from a previous capture, or from a different camera -- you can run detection on it directly.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.components.camera import Camera
+from viam.services.vision import VisionClient
+
+camera = Camera.from_robot(robot, "my-camera")
+detector = VisionClient.from_robot(robot, "my-detector")
+
+# Capture images from the camera
+images, _ = await camera.get_images()
+
+# Run detection on the first image
+detections = await detector.get_detections(images[0])
+
+for d in detections:
+    print(f"{d.class_name}: {d.confidence:.2f}")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+cam, err := camera.FromProvider(machine, "my-camera")
+if err != nil {
+    logger.Fatal(err)
+}
+
+detector, err := vision.FromProvider(machine, "my-detector")
+if err != nil {
+    logger.Fatal(err)
+}
+
+// Capture an image first
+images, _, err := cam.Images(ctx, nil, nil)
+if err != nil {
+    logger.Fatal(err)
+}
+img, err := images[0].Image(ctx)
+if err != nil {
+    logger.Fatal(err)
+}
+
+// Run detection on the captured image
+detections, err := detector.Detections(ctx, img, nil)
+if err != nil {
+    logger.Fatal(err)
+}
+
+for _, d := range detections {
+    fmt.Printf("%s: %.2f\n", d.Label(), d.Score())
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 3. Filter detections by confidence
+
+In practice, you almost always want to filter out low-confidence detections. Apply a threshold before processing results.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+CONFIDENCE_THRESHOLD = 0.7
+
+detections = await detector.get_detections_from_camera("my-camera")
+
+# Filter to only high-confidence detections
+confident_detections = [
+    d for d in detections
+    if d.confidence >= CONFIDENCE_THRESHOLD
+]
+
+print(f"{len(confident_detections)} of {len(detections)} "
+      f"detections above {CONFIDENCE_THRESHOLD} threshold")
+
+for d in confident_detections:
+    print(f"  {d.class_name}: {d.confidence:.2f}")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+confidenceThreshold := 0.7
+
+detections, err := detector.DetectionsFromCamera(ctx, "my-camera", nil)
+if err != nil {
+    logger.Fatal(err)
+}
+
+total := len(detections)
+var confident []objectdetection.Detection
+for _, d := range detections {
+    if d.Score() >= confidenceThreshold {
+        confident = append(confident, d)
+    }
+}
+
+fmt.Printf("%d of %d detections above %.1f threshold\n",
+    len(confident), total, confidenceThreshold)
+
+for _, d := range confident {
+    fmt.Printf("  %s: %.2f\n", d.Label(), d.Score())
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 4. Filter detections by class
+
+When your model detects multiple object types, you may only care about specific classes.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+TARGET_CLASSES = {"person", "dog"}
+
+detections = await detector.get_detections_from_camera("my-camera")
+
+targets = [
+    d for d in detections
+    if d.class_name in TARGET_CLASSES and d.confidence >= 0.6
+]
+
+for d in targets:
+    width = d.x_max - d.x_min
+    height = d.y_max - d.y_min
+    print(f"{d.class_name}: {d.confidence:.2f}, "
+          f"size {width}x{height} pixels")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+targetClasses := map[string]bool{"person": true, "dog": true}
+
+detections, err := detector.DetectionsFromCamera(ctx, "my-camera", nil)
+if err != nil {
+    logger.Fatal(err)
+}
+
+for _, d := range detections {
+    if targetClasses[d.Label()] && d.Score() >= 0.6 {
+        bb := d.BoundingBox()
+        width := bb.Max.X - bb.Min.X
+        height := bb.Max.Y - bb.Min.Y
+        fmt.Printf("%s: %.2f, size %dx%d pixels\n",
+            d.Label(), d.Score(), width, height)
+    }
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 5. Run detections in a loop
+
+Most real applications need continuous detection, not a single snapshot. Run detections in a loop with a short delay to avoid overwhelming the system.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+import asyncio
+import time
+
+CONFIDENCE_THRESHOLD = 0.7
+
+detector = VisionClient.from_robot(robot, "my-detector")
+
+while True:
+    start = time.time()
+    detections = await detector.get_detections_from_camera("my-camera")
+
+    confident = [d for d in detections if d.confidence >= CONFIDENCE_THRESHOLD]
+    elapsed = time.time() - start
+
+    if confident:
+        names = [f"{d.class_name}({d.confidence:.2f})" for d in confident]
+        print(f"[{elapsed:.2f}s] Detected: {', '.join(names)}")
+    else:
+        print(f"[{elapsed:.2f}s] No detections")
+
+    await asyncio.sleep(0.1)
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+confidenceThreshold := 0.7
+
+detector, err := vision.FromProvider(machine, "my-detector")
+if err != nil {
+    logger.Fatal(err)
+}
+
+for {
+    start := time.Now()
+    detections, err := detector.DetectionsFromCamera(ctx, "my-camera", nil)
+    if err != nil {
+        logger.Error(err)
+        time.Sleep(time.Second)
+        continue
+    }
+
+    elapsed := time.Since(start)
+    var confident []objectdetection.Detection
+    for _, d := range detections {
+        if d.Score() >= confidenceThreshold {
+            confident = append(confident, d)
+        }
+    }
+
+    if len(confident) > 0 {
+        for _, d := range confident {
+            fmt.Printf("[%v] %s: %.2f\n", elapsed, d.Label(), d.Score())
+        }
+    } else {
+        fmt.Printf("[%v] No detections\n", elapsed)
+    }
+
+    time.Sleep(100 * time.Millisecond)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Alternatives and advanced usage
+
+### 6. Use the color_detector (no ML model needed)
+
+For simple color-based detection, configure a vision service with the `color_detector` model instead of `mlmodel`. This requires no trained model.
+
+```json
+{
+  "name": "red-detector",
+  "api": "rdk:service:vision",
+  "model": "color_detector",
+  "attributes": {
+    "detect_color": "#FF0000",
+    "hue_tolerance_pct": 0.1,
+    "segment_size_px": 200
+  }
+}
+```
+
+| Attribute               | Type   | Required     | Description                                                                                                     |
+| ----------------------- | ------ | ------------ | --------------------------------------------------------------------------------------------------------------- |
+| `detect_color`          | string | **Required** | Target color in hex format (for example, `"#FF0000"`). Cannot be black, white, or grayscale.                    |
+| `hue_tolerance_pct`     | float  | **Required** | How much the hue can vary from the target (must be > 0.0 and <= 1.0). A value of 0.1 means 10% tolerance.       |
+| `segment_size_px`       | int    | **Required** | Minimum number of pixels a detected region must contain to count as a detection.                                |
+| `saturation_cutoff_pct` | float  | Optional     | Minimum saturation for a pixel to be considered a match. Default: `0.2`. Increase to reject washed-out colors.  |
+| `value_cutoff_pct`      | float  | Optional     | Minimum brightness value for a pixel to be considered a match. Default: `0.3`. Increase to reject dark regions. |
+| `label`                 | string | Optional     | The label to assign to detections. If omitted, detections have no class name.                                   |
+| `camera_name`           | string | Optional     | Default camera to use with `GetDetectionsFromCamera` if no camera name is specified in the request.             |
+
+The detection API works identically whether you use `mlmodel` or `color_detector`. Your code does not need to change.
+
+### 7. Get everything in one call with CaptureAllFromCamera
+
+If you need the image and its detections (and optionally classifications) together, use `CaptureAllFromCamera` instead of separate calls. This is more efficient when you need multiple result types and ensures the detections correspond exactly to the returned image.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.services.vision import VisionClient
+
+detector = VisionClient.from_robot(robot, "my-detector")
+
+result = await detector.capture_all_from_camera(
+    "my-camera",
+    return_image=True,
+    return_detections=True,
+    return_classifications=True
+)
+
+image = result.image            # The captured image
+detections = result.detections  # Detections for that exact image
+classifications = result.classifications  # Classifications too
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+captOpts := viscapture.CaptureOptions{
+    ReturnImage:           true,
+    ReturnDetections:      true,
+    ReturnClassifications: true,
+}
+
+result, err := detector.CaptureAllFromCamera(
+    context.Background(), "my-camera", captOpts, nil)
+if err != nil {
+    logger.Fatal(err)
+}
+
+img := result.Image
+detections := result.Detections
+classifications := result.Classifications
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+This is particularly useful for data logging, visualization, or any case where you need to correlate results with the exact frame that produced them.
+
+## Try It
+
+1. Run the detection loop from step 5. Point your camera at objects your model recognizes and observe the output.
+2. Adjust the confidence threshold and notice how it affects the number of detections. Try 0.3, 0.5, 0.7, and 0.9.
+3. Add class filtering to focus on a specific object type.
+4. If you do not have a trained model, configure a `color_detector` and point the camera at a brightly colored object.
+
+## Troubleshooting
+
+{{< expand "No detections returned" >}}
+
+- Verify the vision service is working in the CONTROL tab first. If detections appear there but not in your code, the issue is in your code.
+- Check that the camera name in your code matches the camera name in your configuration exactly.
+- Lower the confidence threshold. The model may be producing detections with low confidence that are being filtered out.
+- Ensure the camera is pointing at objects the model was trained to recognize.
+
+{{< /expand >}}
+
+{{< expand "Detections are slow" >}}
+
+- TFLite models on a Raspberry Pi typically run at 2-10 frames per second depending on model size. This is normal.
+- Reduce camera resolution to speed up inference. A 640x480 image processes faster than 1920x1080.
+- Avoid calling `get_detections_from_camera` faster than the model can process. The `asyncio.sleep` or `time.Sleep` in the loop prevents this.
+
+{{< /expand >}}
+
+{{< expand "Bounding boxes are in the wrong position" >}}
+
+- The bounding box coordinates are in pixel space relative to the image dimensions. If you are overlaying boxes on a resized image, scale the coordinates proportionally.
+- Verify the camera orientation. If the camera is mounted upside down, the coordinates will appear inverted.
+
+{{< /expand >}}
+
+{{< expand "Color detector finds nothing" >}}
+
+- Use a color picker tool to get the exact hex color of your target object under the camera's lighting conditions. Colors shift significantly under different lighting.
+- Increase `hue_tolerance_pct` to allow more variation. Start at 0.2 and increase if needed.
+- Decrease `segment_size_px` if the target object appears small in the frame.
+
+{{< /expand >}}
+
+## What's Next
+
+- [Classify Objects](/vision/classify/) -- use whole-image classification instead of per-object bounding boxes.
+- [Track Objects Across Frames](/vision/track/) -- maintain persistent identities for detected objects as they move between frames.
+- [Localize Objects in 3D](/vision/measure-depth/) -- combine 2D detections with depth data to get real-world 3D positions.
diff --git a/docs/vision/measure-depth.md b/docs/vision/measure-depth.md
new file mode 100644
index 0000000000..b15d071185
--- /dev/null
+++ b/docs/vision/measure-depth.md
@@ -0,0 +1,508 @@
+---
+linkTitle: "Measure depth"
+title: "Measure depth"
+weight: 50
+layout: "docs"
+type: "docs"
+description: "Retrieve point clouds and depth images from a depth camera, read depth at specific pixels, and measure distance to detected objects."
+date: "2025-01-30"
+aliases:
+  - /build/vision-detection/measure-depth/
+  - /vision-detection/measure-depth/
+  - /vision-detection/localize-objects-in-3d/
+  - /build/vision-detection/localize-objects-in-3d/
+---
+
+A standard camera gives you a flat 2D image. You can see that there is a box on the table, but you cannot tell whether the box is 30 centimeters away or 3 meters away. This how-to shows you how to get depth data from your camera and extract useful distance measurements for robotics tasks that involve physical interaction.
+
+## Concepts
+
+### What depth cameras provide
+
+Depth cameras capture both color (RGB) and distance information. There are several technologies:
+
+| Technology           | How it works                                       | Common examples                    |
+| -------------------- | -------------------------------------------------- | ---------------------------------- |
+| Structured light     | Projects a known pattern and measures distortion   | Intel RealSense D400 series        |
+| Time of flight (ToF) | Measures how long light takes to bounce back       | Intel RealSense L515, Azure Kinect |
+| Stereo vision        | Uses two cameras to calculate depth from disparity | Oak-D, ZED cameras                 |
+
+All of these produce the same type of output in Viam: a point cloud or a depth map that you access through the standard camera API.
+
+### Point clouds
+
+A point cloud is a collection of 3D points, each with an (x, y, z) position measured in millimeters from the camera's optical center. Some point clouds also include color information for each point.
+
+The coordinate system follows a standard convention:
+
+- **X** increases to the right
+- **Y** increases downward
+- **Z** increases away from the camera (depth)
+
+A typical indoor scene captured by a depth camera contains tens of thousands to hundreds of thousands of points, depending on the camera resolution and range.
+
+### Depth maps vs point clouds
+
+A **depth map** is a 2D image where each pixel value represents the distance from the camera to the surface at that pixel location. It is essentially a grayscale image where brighter pixels are farther away (or vice versa, depending on the encoding).
+
+A **point cloud** is the 3D representation: each pixel in the depth map is projected into 3D space using the camera's intrinsic parameters. The point cloud contains explicit (x, y, z) coordinates.
+
+Viam provides point clouds through the `GetPointCloud` API. If you need a depth map instead, you can capture the depth image directly using `GetImage` with the appropriate MIME type.
+
+### Camera intrinsic parameters
+
+Intrinsic parameters describe the internal geometry of the camera: focal length, principal point, and lens distortion. These parameters are required to accurately project 2D pixel coordinates into 3D space.
+
+When you configure a depth camera in Viam, the intrinsic parameters are typically loaded automatically from the camera hardware. If your camera does not provide them, you can specify them manually in the camera configuration. Without correct intrinsic parameters, 3D projections will be inaccurate.
+
+### 3D object localization
+
+If you need 3D positions for detected objects --for example, to guide a robot arm to pick up a cup --you combine 2D detections with depth data. The workflow is:
+
+1. Run a 2D detector to get bounding boxes.
+2. For each bounding box, extract the corresponding depth pixels.
+3. Project those depth pixels into 3D space using the camera's intrinsic parameters.
+
+The result is a 3D point cloud for each detected object, with coordinates in the camera's frame (x right, y down, z forward, in millimeters). To use these positions with other robot components, transform them through the [frame system](/motion-planning/frame-system/).
+
+Step 5 of this guide shows how to combine detections with depth data to measure distance. For full 3D point clouds, use the vision service's [`GetObjectPointClouds`](/reference/apis/services/vision/#getobjectpointclouds) method if your vision service supports it.
+
+## Steps
+
+### 1. Verify your depth camera is configured
+
+Go to [app.viam.com](https://app.viam.com), navigate to your machine, and verify your depth camera appears in the component list. Open the test panel and confirm it is producing images.
+
+For Intel RealSense cameras, the `webcam` model or the `realsense` module is commonly used. Check that the depth stream is enabled in the camera configuration.
+
+### 2. Get a point cloud
+
+Use the camera API to retrieve a point cloud from your depth camera.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.components.camera import Camera
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    camera = Camera.from_robot(robot, "my-depth-camera")
+
+    # Get a point cloud
+    point_cloud, _ = await camera.get_point_cloud()
+
+    print("Point cloud retrieved")
+    print(f"Type: {type(point_cloud)}")
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "go.viam.com/rdk/components/camera"
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/utils/rpc"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("depth")
+
+    machine, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithDialOptions(rpc.WithEntityCredentials(
+            "YOUR-API-KEY-ID",
+            rpc.Credentials{
+                Type:    rpc.CredentialsTypeAPIKey,
+                Payload: "YOUR-API-KEY",
+            })),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer machine.Close(ctx)
+
+    cam, err := camera.FromProvider(machine, "my-depth-camera")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    pc, err := cam.NextPointCloud(ctx, nil)
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    fmt.Printf("Point cloud retrieved with %d points\n", pc.Size())
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 3. Get a depth image
+
+Instead of a full point cloud, you can capture a depth image. This is a 2D representation where each pixel value is the depth in millimeters.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.components.camera import Camera
+
+camera = Camera.from_robot(robot, "my-depth-camera")
+
+# Get images from the depth camera
+images, _ = await camera.get_images()
+
+# The depth image is typically the second image
+# Check source_name to identify the depth stream
+for img in images:
+    print(f"Source: {img.source_name}, size: {img.width}x{img.height}")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+cam, err := camera.FromProvider(machine, "my-depth-camera")
+if err != nil {
+    logger.Fatal(err)
+}
+
+// Get images including the depth frame
+images, _, err := cam.Images(ctx, nil, nil)
+if err != nil {
+    logger.Fatal(err)
+}
+
+for _, img := range images {
+    fmt.Printf("Source: %s\n", img.SourceName)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 4. Read depth at a specific pixel
+
+Given a depth image, you can look up the distance at any pixel coordinate. This is useful when you know where an object is in the 2D image (from a detection) and want to know how far away it is.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+import numpy as np
+from viam.components.camera import Camera
+
+
+camera = Camera.from_robot(robot, "my-depth-camera")
+
+# Get images from the depth camera
+images, _ = await camera.get_images()
+
+# Find the depth image by checking available images
+# Convert to numpy array for pixel-level access
+depth_array = np.array(images[1].image)
+
+# Read depth at a specific pixel (center of image)
+center_x = depth_array.shape[1] // 2
+center_y = depth_array.shape[0] // 2
+depth_mm = depth_array[center_y, center_x]
+
+print(f"Depth at center ({center_x}, {center_y}): {depth_mm} mm")
+print(f"That is {depth_mm / 1000:.2f} meters")
+
+# Read depth at a specific coordinate
+target_x, target_y = 320, 240
+depth_at_target = depth_array[target_y, target_x]
+print(f"Depth at ({target_x}, {target_y}): {depth_at_target} mm")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+import (
+    "fmt"
+    "image"
+)
+
+cam, err := camera.FromProvider(machine, "my-depth-camera")
+if err != nil {
+    logger.Fatal(err)
+}
+
+images, _, err := cam.Images(ctx, nil, nil)
+if err != nil {
+    logger.Fatal(err)
+}
+
+// Access the depth image (check SourceName to identify the depth stream)
+depthImg, err := images[1].Image(ctx)
+if err != nil {
+    logger.Fatal(err)
+}
+bounds := depthImg.Bounds()
+centerX := (bounds.Min.X + bounds.Max.X) / 2
+centerY := (bounds.Min.Y + bounds.Max.Y) / 2
+
+// Read the depth value at center
+r, _, _, _ := depthImg.At(centerX, centerY).RGBA()
+depthMM := int(r)
+
+fmt.Printf("Depth at center (%d, %d): %d mm\n", centerX, centerY, depthMM)
+fmt.Printf("That is %.2f meters\n", float64(depthMM)/1000.0)
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 5. Measure distance to detected objects
+
+Combine 2D detections with depth data to measure the distance to each detected object. Use the center of the bounding box as the depth sample point.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+from viam.components.camera import Camera
+from viam.services.vision import VisionClient
+import numpy as np
+
+
+camera = Camera.from_robot(robot, "my-depth-camera")
+detector = VisionClient.from_robot(robot, "my-detector")
+
+# Get detections
+detections = await detector.get_detections_from_camera("my-depth-camera")
+
+# Get images including depth
+images, _ = await camera.get_images()
+depth_array = np.array(images[1].image)
+
+for d in detections:
+    if d.confidence < 0.5:
+        continue
+
+    # Use the center of the bounding box
+    center_x = (d.x_min + d.x_max) // 2
+    center_y = (d.y_min + d.y_max) // 2
+
+    # Clamp to image bounds
+    center_x = max(0, min(center_x, depth_array.shape[1] - 1))
+    center_y = max(0, min(center_y, depth_array.shape[0] - 1))
+
+    depth_mm = depth_array[center_y, center_x]
+
+    # Sample a small region around center for more robust measurement
+    region = depth_array[
+        max(0, center_y - 5):min(depth_array.shape[0], center_y + 5),
+        max(0, center_x - 5):min(depth_array.shape[1], center_x + 5)
+    ]
+    # Filter out zero (invalid) depth values
+    valid_depths = region[region > 0]
+    if len(valid_depths) > 0:
+        median_depth = np.median(valid_depths)
+    else:
+        median_depth = depth_mm
+
+    print(f"{d.class_name}: {d.confidence:.2f}, "
+          f"distance: {median_depth:.0f} mm ({median_depth/1000:.2f} m)")
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+import (
+    "fmt"
+    "sort"
+
+    "go.viam.com/rdk/components/camera"
+    "go.viam.com/rdk/services/vision"
+)
+
+cam, err := camera.FromProvider(machine, "my-depth-camera")
+if err != nil {
+    logger.Fatal(err)
+}
+
+detector, err := vision.FromProvider(machine, "my-detector")
+if err != nil {
+    logger.Fatal(err)
+}
+
+detections, err := detector.DetectionsFromCamera(ctx, "my-depth-camera", nil)
+if err != nil {
+    logger.Fatal(err)
+}
+
+images, _, err := cam.Images(ctx, nil, nil)
+if err != nil {
+    logger.Fatal(err)
+}
+
+// Access the depth image (check SourceName to identify the depth stream)
+depthImg, err := images[1].Image(ctx)
+if err != nil {
+    logger.Fatal(err)
+}
+bounds := depthImg.Bounds()
+
+for _, d := range detections {
+    if d.Score() < 0.5 {
+        continue
+    }
+
+    bb := d.BoundingBox()
+    centerX := (bb.Min.X + bb.Max.X) / 2
+    centerY := (bb.Min.Y + bb.Max.Y) / 2
+
+    // Clamp to image bounds
+    if centerX < bounds.Min.X {
+        centerX = bounds.Min.X
+    }
+    if centerX >= bounds.Max.X {
+        centerX = bounds.Max.X - 1
+    }
+    if centerY < bounds.Min.Y {
+        centerY = bounds.Min.Y
+    }
+    if centerY >= bounds.Max.Y {
+        centerY = bounds.Max.Y - 1
+    }
+
+    // Sample center pixel depth
+    r, _, _, _ := depthImg.At(centerX, centerY).RGBA()
+    depthMM := int(r)
+
+    fmt.Printf("%s: %.2f, distance: %d mm (%.2f m)\n",
+        d.Label(), d.Score(), depthMM, float64(depthMM)/1000.0)
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### 6. Use a fake camera for testing
+
+If you do not have a depth camera, configure a `fake` camera that generates simulated point cloud data. This lets you develop and test your depth-related code without hardware.
+
+```json
+{
+  "name": "my-depth-camera",
+  "api": "rdk:component:camera",
+  "model": "fake",
+  "attributes": {}
+}
+```
+
+The fake camera generates both color images and simulated point cloud data. The depth values are synthetic but structurally correct, so your code will work the same way with real hardware.
+
+### 7. Configure camera intrinsic parameters
+
+If your camera does not automatically provide intrinsic parameters, you can set them manually in the configuration. These parameters are needed for accurate 2D-to-3D projection.
+
+```json
+{
+  "name": "my-depth-camera",
+  "api": "rdk:component:camera",
+  "model": "webcam",
+  "attributes": {
+    "intrinsic_parameters": {
+      "fx": 615.0,
+      "fy": 615.0,
+      "ppx": 320.0,
+      "ppy": 240.0,
+      "width_px": 640,
+      "height_px": 480
+    },
+    "distortion_parameters": {
+      "rk1": 0.0,
+      "rk2": 0.0,
+      "rk3": 0.0,
+      "tp1": 0.0,
+      "tp2": 0.0
+    }
+  }
+}
+```
+
+| Parameter               | Description                                      |
+| ----------------------- | ------------------------------------------------ |
+| `fx`, `fy`              | Focal length in pixels (horizontal and vertical) |
+| `ppx`, `ppy`            | Principal point (optical center) in pixels       |
+| `width_px`, `height_px` | Image dimensions                                 |
+| `rk1`, `rk2`, `rk3`     | Radial distortion coefficients                   |
+| `tp1`, `tp2`            | Tangential distortion coefficients               |
+
+Most depth cameras (Intel RealSense, Oak-D) provide these automatically. You only need to set them manually for cameras without built-in calibration data.
+
+{{< alert title="Tip" color="tip" >}}
+If you need an image, its detections, and a point cloud together in one call, use [`CaptureAllFromCamera`](/reference/apis/services/vision/#captureallfromcamera). This is more efficient than separate calls and ensures all results correspond to the same frame. See [Detect Objects, step 7](/vision/detect/#7-get-everything-in-one-call-with-captureallfromcamera) for a full example.
+{{< /alert >}}
+
+## Try It
+
+1. Run the point cloud script from step 2 and verify you get data back.
+2. Run the depth-at-pixel script from step 4. Point the camera at objects at different distances and verify the measurements are reasonable.
+3. If you have a detector configured, run the combined detection + depth script from step 5. Walk toward and away from the camera and observe how the distance measurement changes.
+4. Compare the depth reading at the center of the image with a physical measurement (use a tape measure). Depth cameras are typically accurate to within a few centimeters at ranges under 5 meters.
+
+## Troubleshooting
+
+{{< expand "Point cloud is empty or has very few points" >}}
+
+- Depth cameras have a minimum and maximum range. Objects too close (under ~20 cm) or too far (over ~10 m for structured light cameras) produce no depth data.
+- Reflective surfaces (mirrors, shiny metal) and transparent surfaces (glass, clear plastic) are invisible to most depth cameras. Move these objects out of the scene.
+- Check the camera's USB connection. Depth cameras require USB 3.0 for full resolution. A USB 2.0 connection may work but with reduced depth resolution.
+
+{{< /expand >}}
+
+{{< expand "Depth values are zero at some pixels" >}}
+
+- Zero typically means "no data" -- the camera could not determine the depth at that pixel. This is common at object edges, on featureless surfaces (blank walls), and at extreme distances.
+- When measuring distance to an object, sample multiple pixels around the target and take the median of non-zero values, as shown in step 5.
+
+{{< /expand >}}
+
+{{< expand "Depth measurements are inaccurate" >}}
+
+- Verify the camera's intrinsic parameters are correct. Incorrect focal length values cause systematic depth errors.
+- Depth accuracy degrades with distance. Most consumer depth cameras are accurate to 1-2% at ranges under 4 meters but much less accurate beyond that.
+- Ensure the camera has been running for at least 30 seconds before measuring. Some depth cameras need time to warm up and stabilize.
+
+{{< /expand >}}
+
+{{< expand "\"GetPointCloud not supported\" error" >}}
+
+- Not all camera models support point clouds. The camera must be a depth camera or have depth functionality enabled.
+- If using a module (such as the RealSense module), verify the module is installed and the camera is configured to output depth data.
+- The `fake` camera model supports point clouds for testing purposes.
+
+{{< /expand >}}
+
+## What's Next
+
+- [Detect Objects (2D)](/vision/detect/) -- get 2D detections to combine with depth measurements.
+- [Frame System](/motion-planning/frame-system/) -- set up coordinate frame transforms so 3D positions are usable by other components.
diff --git a/docs/vision/track.md b/docs/vision/track.md
new file mode 100644
index 0000000000..56b5094276
--- /dev/null
+++ b/docs/vision/track.md
@@ -0,0 +1,276 @@
+---
+linkTitle: "Track objects"
+title: "Track objects across frames"
+weight: 40
+layout: "docs"
+type: "docs"
+description: "Track detected objects across consecutive video frames with persistent IDs using the object-tracker module."
+date: "2025-01-30"
+aliases:
+  - /build/vision-detection/track-objects-across-frames/
+  - /vision-detection/track-objects-across-frames/
+---
+
+Object detection operates on single frames. It tells you what is in the image right now, but nothing about what was in the previous frame. When you run detections at 5 frames per second, you get 5 independent lists of bounding boxes with no way to tell whether a detection in frame 2 corresponds to the same object as in frame 1.
+
+The [`viam:object-tracker` module](https://app.viam.com/module/viam/object-tracker) solves this by wrapping an existing detector and camera, matching detections across consecutive frames, and assigning stable track IDs. You can answer questions like: how many cars have passed through this intersection? How long has this person been standing here?
+
+## How it works
+
+The object tracker sits between your detector and your application code:
+
+1. Your **camera** provides the image stream.
+2. Your **detector** (a vision service) runs on each frame and returns detections.
+3. The **object tracker** matches new detections to existing tracks using the Hungarian algorithm. Unmatched detections become new tracks. Tracks with no matching detection for several frames are removed.
+
+Each tracked object gets a persistent class name in the format:
+
+```text
+<class>_<N>_<YYYYMMDD>_<HHMMSS>
+```
+
+For example, the first person detected becomes `person_0_20250413_143052`. The `person_0` portion is the stable track ID. The timestamp records when the object was first detected.
+
+## Prerequisites
+
+- A configured [camera](/hardware/common-components/add-a-camera/)
+- A configured vision service detector (see [Configure a vision pipeline](/vision/configure/))
+
+## Configure the object tracker
+
+### 1. Add the module
+
+1. Click **+** and select **Configuration block**.
+2. Search for **object-tracker** and select `viam:object-tracker`.
+3. Click **Add module**.
+
+### 2. Add the vision service
+
+1. Click **+** and select **Configuration block**.
+2. Search for **object-tracker** under vision services and select `viam:vision:object-tracker`.
+3. Click **Add component**, name it (for example, `my-tracker`), and click **Add component** again to confirm.
+
+### 3. Configure attributes
+
+Set the required attributes:
+
+```json
+{
+  "camera_name": "my-camera",
+  "detector_name": "my-detector"
+}
+```
+
+| Attribute               | Type   | Required | Default | Description                                                                                     |
+| ----------------------- | ------ | -------- | ------- | ----------------------------------------------------------------------------------------------- |
+| `camera_name`           | string | **Yes**  | --      | Name of the configured camera component.                                                        |
+| `detector_name`         | string | **Yes**  | --      | Name of the configured vision detector service.                                                 |
+| `min_confidence`        | float  | No       | 0.2     | Minimum confidence threshold for detections (0 to 1).                                           |
+| `max_frequency_hz`      | float  | No       | 10      | Maximum rate at which the tracker processes frames.                                             |
+| `chosen_labels`         | object | No       | --      | Map of class names to confidence thresholds. Only detections matching these labels are tracked. |
+| `trigger_cool_down_s`   | float  | No       | 5       | Seconds before a trigger resets after firing.                                                   |
+| `buffer_size`           | int    | No       | 30      | Number of frames to buffer lost detections before removing a track (1 to 256).                  |
+| `min_track_persistence` | int    | No       | 1       | Number of consecutive frames a track must appear in before it is returned in detection results. |
+
+Click **Save**.
+
+**Full example configuration:**
+
+```json
+{
+  "camera_name": "my-camera",
+  "detector_name": "my-detector",
+  "min_confidence": 0.5,
+  "max_frequency_hz": 10,
+  "chosen_labels": {
+    "person": 0.7,
+    "dog": 0.3
+  },
+  "buffer_size": 30,
+  "min_track_persistence": 3
+}
+```
+
+## Use the tracker
+
+The object tracker exposes the standard vision service API. Call `GetDetectionsFromCamera` or `GetDetections` to get tracked detections with persistent IDs.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+import asyncio
+from viam.robot.client import RobotClient
+from viam.services.vision import VisionClient
+
+
+async def main():
+    opts = RobotClient.Options.with_api_key(
+        api_key="YOUR-API-KEY",
+        api_key_id="YOUR-API-KEY-ID"
+    )
+    robot = await RobotClient.at_address("YOUR-MACHINE-ADDRESS", opts)
+
+    tracker = VisionClient.from_robot(robot, "my-tracker")
+
+    while True:
+        detections = await tracker.get_detections_from_camera("my-camera")
+
+        for d in detections:
+            # class_name contains the track ID, e.g. "person_0_20250413_143052"
+            print(f"{d.class_name}: {d.confidence:.2f} "
+                  f"at ({d.x_min},{d.y_min})-({d.x_max},{d.y_max})")
+
+        await asyncio.sleep(0.2)
+
+    await robot.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "time"
+
+    "go.viam.com/rdk/logging"
+    "go.viam.com/rdk/robot/client"
+    "go.viam.com/rdk/services/vision"
+    "go.viam.com/utils/rpc"
+)
+
+func main() {
+    ctx := context.Background()
+    logger := logging.NewLogger("tracker")
+
+    machine, err := client.New(ctx, "YOUR-MACHINE-ADDRESS", logger,
+        client.WithDialOptions(rpc.WithEntityCredentials(
+            "YOUR-API-KEY-ID",
+            rpc.Credentials{
+                Type:    rpc.CredentialsTypeAPIKey,
+                Payload: "YOUR-API-KEY",
+            })),
+    )
+    if err != nil {
+        logger.Fatal(err)
+    }
+    defer machine.Close(ctx)
+
+    tracker, err := vision.FromProvider(machine, "my-tracker")
+    if err != nil {
+        logger.Fatal(err)
+    }
+
+    for {
+        detections, err := tracker.DetectionsFromCamera(ctx, "my-camera", nil)
+        if err != nil {
+            logger.Error(err)
+            time.Sleep(time.Second)
+            continue
+        }
+
+        for _, d := range detections {
+            // Label() contains the track ID, e.g. "person_0_20250413_143052"
+            fmt.Printf("%s: %.2f at (%d,%d)-(%d,%d)\n",
+                d.Label(), d.Score(),
+                d.BoundingBox().Min.X, d.BoundingBox().Min.Y,
+                d.BoundingBox().Max.X, d.BoundingBox().Max.Y)
+        }
+
+        time.Sleep(200 * time.Millisecond)
+    }
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Count entries and exits
+
+Use `GetClassificationsFromCamera` to detect when new objects enter the scene. The tracker returns a `new-object-detected` classification when a fresh object appears.
+
+### Extract the track ID
+
+Parse the class name to extract a stable track ID for grouping detections over time:
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+```python
+def get_track_id(class_name: str) -> str:
+    """Extract stable track ID from tracker class name.
+
+    'person_0_20250413_143052' -> 'person_0'
+    """
+    parts = class_name.split("_")
+    if len(parts) >= 2:
+        return f"{parts[0]}_{parts[1]}"
+    return class_name
+```
+
+{{% /tab %}}
+{{% tab name="Go" %}}
+
+```go
+func getTrackID(className string) string {
+    parts := strings.SplitN(className, "_", 3)
+    if len(parts) >= 2 {
+        return parts[0] + "_" + parts[1]
+    }
+    return className
+}
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Tune tracking parameters
+
+- **`min_confidence`**: raise this to reduce noisy detections that create spurious tracks. Start at 0.5 for most use cases.
+- **`buffer_size`**: controls how long a lost track is kept before being removed. Increase for scenes with frequent occlusion (objects passing behind other objects). Decrease for faster exit detection.
+- **`min_track_persistence`**: increase to filter out brief false detections. A value of 3 means an object must be detected in 3 consecutive frames before the tracker reports it.
+- **`max_frequency_hz`**: lower this on resource-constrained devices to reduce CPU usage.
+- **`chosen_labels`**: use this to track only specific classes. For example, to track only people with high confidence: `{"person": 0.7}`.
+
+## Troubleshooting
+
+{{< expand "Tracks keep switching IDs" >}}
+
+- Increase `min_confidence` to reduce noisy detections that confuse the matching algorithm.
+- If objects are close together and frequently swap IDs, increase `min_track_persistence` so only stable tracks are reported.
+
+{{< /expand >}}
+
+{{< expand "Tracks are lost too quickly" >}}
+
+- Increase `buffer_size`. If your detection model occasionally misses an object for a few frames, a higher value keeps the track alive through the gap.
+- Check your detection confidence threshold. If it is too high, the model may intermittently fail to detect objects, causing track loss.
+
+{{< /expand >}}
+
+{{< expand "Too many tracks for the same object" >}}
+
+- Increase `min_track_persistence` so brief, unstable detections are not reported.
+- If the underlying detector produces inconsistent bounding boxes, the tracker may fail to match them across frames. Try a different or better-trained model.
+
+{{< /expand >}}
+
+{{< expand "No detections returned" >}}
+
+- Verify the underlying detector works by testing it directly. On the **CONTROL** tab, check that detections appear from the detector vision service before adding the tracker.
+- Verify `camera_name` and `detector_name` in the tracker configuration match the names of your configured camera and detector exactly.
+
+{{< /expand >}}
+
+## What's next
+
+- [Detect objects](/vision/detect/): learn about the detection API the tracker builds on.
+- [Act on detections](/vision/act-on-detections/): build modules that respond to detection or classification results.
+- [Alert on detections](/vision/alert-on-detections/): send alerts when tracked objects enter or exit a scene.
diff --git a/docs/what-is-viam/_index.md b/docs/what-is-viam/_index.md
new file mode 100644
index 0000000000..aa7fefb2ed
--- /dev/null
+++ b/docs/what-is-viam/_index.md
@@ -0,0 +1,160 @@
+---
+linkTitle: "What is Viam?"
+title: "What is Viam?"
+weight: 10
+layout: "docs"
+type: "docs"
+no_list: true
+images: ["/general/understand.png"]
+imageAlt: "Viam platform overview"
+description: "Viam is a software platform for building, deploying, and managing robotics applications."
+aliases:
+  - /understand/
+  - /understand/what-is-viam/
+  - /what-is-viam/problems-viam-solves/
+  - /what-is-viam/what-is-viam/
+date: "2025-01-30"
+---
+
+Viam is a software platform for building, deploying, and managing robotics applications.
+
+With Viam, you declare the hardware and services you need in a JSON config. Viam installs the drivers and any additional software modules required to support your configuration.
+Vision, motion planning, and most other capabilities you need are built in or available in the Viam module Registry, all with well-defined APIs to support your use case.
+Application code versioning, deployment, and rollback are native to the Viam platform.
+It's the development workflow you're used to, applied to physical devices.
+
+Viam brings software engineering practices to robotics: version control, remote monitoring and diagnostics, staged rollouts, and a registry of modules and models you can build on.
+
+<img src="/what-is-viam-technical.svg" alt="Architecture diagram showing how a Viam machine works: app.viam.com at top, connected to your machine running viam-agent and viam-server with hardware drivers, software integrations, built-in services, and your code, connected to physical peripherals at bottom." style="width:100%;max-width:720px;height:auto;display:block" >
+
+## Viam fundamentals
+
+Every Viam machine starts with `viam-agent`.
+Install it with a single command.
+`viam-agent` installs `viam-server`, supervises it, and keeps it up to date.
+
+`viam-server` is the core runtime.
+It pulls your machine's configuration from app.viam.com, fetches the necessary modules from the Viam Registry, launches required processes, and keeps them running to support all the hardware and services your application requires.
+
+The [Viam Registry](https://app.viam.com/registry) is a central repository of modules, ML models, and training scripts maintained by Viam and the robotics community.
+All registry assets support semantic versioning, enabling controlled deployment to individual robots and across your fleet.
+
+Registry modules provide drivers for cameras, motors, sensors, arms, and other hardware, plus services like object detection.
+`viam-server` also includes built-in services such as motion planning and data management.
+For machine learning, the Registry includes pretrained models for common tasks. You can also train and use your own models.
+
+Viam supports reusable configuration through [fragments](/fleet/reuse-configuration/).
+Define a combination of components, services, and modules once, then apply that configuration across any number of machines.
+Use fragments to configure a camera-arm combination, a camera-to-object-detection pipeline, or an entire work cell.
+Fragments support variable substitution and per-machine overwrites, so you can deploy the same base configuration to hundreds of machines while accommodating site-specific settings.
+
+## Viam capabilities
+
+{{< alert title="In this section" color="note" >}}
+
+- [Get hardware running in minutes](#get-hardware-running-in-minutes)
+- [Operate from anywhere](#operate-from-anywhere)
+- [Capture data from edge to cloud](#capture-data-from-edge-to-cloud)
+- [Train and deploy models](#train-and-deploy-models)
+- [Develop code remotely](#develop-code-remotely)
+- [Manage software deployments](#manage-software-deployments)
+- [Scale easily](#scale-easily)
+- [Productize with Viam apps](#productize-with-viam-apps)
+
+{{< /alert >}}
+
+### Get hardware running in minutes
+
+Add a camera, motor, arm, or sensor to your JSON config with a few parameters: model, connection type, any device-specific settings.
+`viam-server` handles the rest—pulls the driver, initializes the device, and exposes it through a consistent API.
+You don't have to write device drivers or worry about dependencies.
+
+- **Consistent APIs across hardware:** All cameras expose the same interface regardless of manufacturer. Same for motors, sensors, arms, and other component types. Your code doesn't change when hardware does.
+- **Swap hardware without changing code:** Replace an Intel RealSense with an Orbbec Astra camera, or swap one motor controller for another—update the config and your application keeps working.
+- **Drivers for hundreds of devices:** The Registry includes modules for most common hardware. If yours isn't supported, write a module once and reuse it everywhere.
+
+### Operate from anywhere
+
+Connect to your machine from anywhere.
+No VPN, no port forwarding, no firewall configuration.
+Viam handles NAT traversal automatically.
+The web app, SDKs, and CLI all use the same connection infrastructure, so you can debug from your laptop and monitor from the Viam web app.
+
+- **Stream logs remotely:** View machine logs in the web app, filtered by level, keyword, or time range.
+- **Run code against remote hardware:** Write scripts on your laptop that connect to a machine over the network. Inspect component state, run diagnostics, or test behavior without deploying code.
+- **View live camera and sensor data:** See camera feeds and sensor readings in the web app's TEST panel for each component.
+- **Teleoperate from the browser:** Drive a base with keyboard controls, move an arm to specific positions, or reposition a gantry, all from the web UI.
+- **Visualize in 3D:** See a live 3D view of your machine showing component positions, camera feeds, and point clouds. Move components and watch the visualization update in real time.
+
+### Capture data from edge to cloud
+
+Configure [data capture](/data/) in JSON: which components, how often, what to keep.
+Viam handles the pipeline.
+Data syncs to the cloud when connectivity allows, survives network interruptions and restarts, and queues locally on devices with constrained bandwidth.
+No custom sync logic, no managing local storage, no worrying about edge cases.
+
+- **Capture from any component:** Record images from cameras, readings from sensors, or custom data from your own modules—all with configuration, no code required.
+- **Sync automatically:** Data syncs when bandwidth is available. If your machine goes offline, data queues locally and syncs when connectivity returns.
+- **Filter at the edge:** Reduce bandwidth and storage costs by filtering before sync. Keep only images with detections, sensor readings outside normal ranges, or samples at specified intervals.
+- **Query across your fleet:** Find data by machine, location, time range, component, or tags. Export for analysis or training.
+- **Manage storage automatically:** Set retention policies to delete old data. Configure local storage limits for edge devices with constrained disk space.
+
+### Train and deploy models
+
+[Train models](/train/) on data you've captured, or bring models trained elsewhere.
+Deploy to your fleet with the same versioning and update mechanisms as code.
+
+- **Train in Viam:** Select captured data, annotate, choose a model architecture, and start a training job. No GPU provisioning, no training pipeline setup. Viam handles it.
+- **Bring your own model:** Import models trained in TensorFlow, PyTorch, ONNX, or other frameworks. Upload to the Registry and deploy like any other versioned asset.
+- **Deploy to your fleet:** Push a model to the Registry and configure machines to pull it. Pin to specific versions or allow automatic updates—same as modules.
+- **Run inference on device:** The ML model service runs on the machine. Inference happens locally without round-trips to the cloud.
+
+### Develop code remotely
+
+Traditional robotics development means standing next to the robot or SSH'ing into it.
+Viam lets you treat your robot like a machine in the cloud.
+Develop and test from your laptop.
+Your code connects to your robot machine over the network, through firewalls and NAT, without VPN.
+
+- **Iterate from your IDE:** Write code on your laptop, run it against your robot hardware over the network. No copying files, no deploy step. Just run and see results.
+- **Run on the robot machine when latency matters:** For tight control loops, run scripts directly on your robot machine. Same code, same APIs—just a different execution environment.
+- **Package as a module for production:** When you're ready, package your code as a module. `viam-agent` ensures it starts on boot and stays updated. `viam-server` manages the module process, restarts it on failure, and reconfigures it when settings change.
+- **Call built-in services from your code:** Motion planning, computer vision, navigation, and data capture are available as services you call from any SDK.
+
+### Manage software deployments
+
+Package your control logic as a [module](/build-modules/write-a-logic-module/) and deploy through the Viam Registry for version control, remote updates, and fleet-wide rollouts.
+No cross-compiling.
+Viam handles everything.
+
+- **Managed lifecycle:** `viam-agent` installs and updates your modules. `viam-server` manages module processes at runtime—starts them, restarts on failure, and reconfigures when settings change.
+- **Reconfigure on the fly:** Tune the application parameters you define with configuration updates in the Viam app. Changes apply within seconds. No restarts or redeployment.
+- **Version control:** Pin machines to exact versions for stability, or allow automatic updates at the patch, minor, or major level.
+- **OTA updates:** `viam-agent` pulls new versions of `viam-server`, modules, and ML models from the Registry. Push a new version with the CLI; `viam-agent` handles delivery to your fleet.
+
+### Scale easily
+
+Your prototype configuration becomes your production configuration.
+Turn a working machine setup into a [fragment](/fleet/reuse-configuration/) and apply it to several, dozens, or even hundreds of machines.
+No deployment scripts, no copying files, no per-machine setup.
+
+- **Create a fragment from your prototype:** Once your machine works, export the configuration as a fragment. That exact setup is now reusable across any number of machines. `viam-agent` provisions new devices automatically—sets up networking, connects to the cloud, and installs `viam-server` and your configuration.
+- **Update configurations fleet-wide:** Change a fragment and every machine using it pulls the update. No scripting, no SSH loops.
+- **Override per-machine differences:** If some machines have a different camera model or site-specific parameter value, override for just those machines without forking the base fragment.
+- **Roll out changes incrementally:** Deploy configuration changes, module versions, or ML models to a subset of machines first. Validate before rolling out fleet-wide.
+- **Roll back with one change:** Viam maintains configuration history. Revert to a previous version of a fragment, module, or model with a single update.
+
+### Productize with Viam apps
+
+Building a robotics product means building customer infrastructure—auth systems, dashboards, billing.
+Viam provides these so you can focus on your product.
+
+- **White-label authentication:** Customers authenticate through a login screen with your logo and branding, not Viam's.
+- **Build customer-facing apps:** Use the TypeScript SDK for web dashboards or the Flutter SDK for iOS and Android apps. Both handle authentication and provide access to all component and service APIs.
+- **Built-in billing:** Define pricing tiers—per-machine fees, data costs, or both. Viam handles invoicing and payment collection.
+
+## Next steps
+
+We recommend putting these concepts into practice by following the [Desk Safari tutorial](/operate/hello-world/tutorial-desk-safari/) to build your first machine.
+
+For more information on cloud capabilities like fleet management and provisioning, see [Monitor Air Quality with a Fleet of Sensors](/tutorials/control/air-quality-fleet/).
diff --git a/layouts/404.html b/layouts/404.html
index 686a02f2a4..1d2db6e3e5 100644
--- a/layouts/404.html
+++ b/layouts/404.html
@@ -11,7 +11,7 @@ <h2>But maybe these could be helpful?</h2>
             {{ partial "card.html" (dict "link" "/tutorials/control/drive-rover/" "class" "" "customTitle" "" "customDescription" "" "customCanonicalLink" "" ) }}
             {{ partial "card.html" (dict "link" "/operate/install/setup/" "class" "" "customTitle" "" "customDescription" "" "customCanonicalLink" "" ) }}
             {{ partial "card.html" (dict "link" "/operate/" "class" "" "customTitle" "" "customDescription" "" "customCanonicalLink" "" ) }}
-            {{ partial "card.html" (dict "link" "/dev/reference/sdks/" "class" "" "customTitle" "" "customDescription" "" "customCanonicalLink" "" ) }}
+            {{ partial "card.html" (dict "link" "/reference/sdks/" "class" "" "customTitle" "" "customDescription" "" "customCanonicalLink" "" ) }}
         </div>
     </div>
     <br />
diff --git a/layouts/docs/content.html b/layouts/docs/content.html
index 1b30c68f94..b3a68e8798 100644
--- a/layouts/docs/content.html
+++ b/layouts/docs/content.html
@@ -57,132 +57,6 @@ <h4 class="alert-heading">DRAFT</h4>
 	<i style="font-size:x-large;" class="fas fa-chevron-up"></i>
 	</button>
 
-	{{ if ne .Params.no_list true}}
-	{{ $pages := union .Sections .Pages }}
-	<div id="next-page" class="card-container">
-	<hr>
-
-	<!-- Build a flat list of all pages respecting hierarchical structure and weights -->
-	{{ $allPages := slice }}
-
-	<!-- Collect pages from all top-level sections in order -->
-	{{ range .Site.Sections }}
-		<!-- Process each top-level section -->
-		{{ range .Pages.ByWeight }}
-			{{ if eq .Params.layout "empty" }}
-				<!-- If this is an empty page, include its subpages recursively -->
-				{{ range .Pages.ByWeight }}
-					{{ if and (ne .Params.layout "empty") (not .Params.toc_hide) }}
-						{{ $allPages = $allPages | append . }}
-					{{ end }}
-					<!-- Process third level pages -->
-					{{ if .Pages }}
-						{{ range .Pages.ByWeight }}
-							{{ if and (ne .Params.layout "empty") (not .Params.toc_hide) (ne .Params.no_list true) }}
-								{{ $allPages = $allPages | append . }}
-							{{ end }}
-							<!-- Process fourth level pages -->
-							{{ if .Pages }}
-								{{ range .Pages.ByWeight }}
-									{{ if and (ne .Params.layout "empty") (not .Params.toc_hide) (ne .Params.no_list true) }}
-										{{ $allPages = $allPages | append . }}
-									{{ end }}
-									<!-- Process fifth level pages -->
-									{{ if .Pages }}
-										{{ range .Pages.ByWeight }}
-											{{ if and (ne .Params.layout "empty") (not .Params.toc_hide) (ne .Params.no_list true) }}
-												{{ $allPages = $allPages | append . }}
-											{{ end }}
-										{{ end }}
-									{{ end }}
-								{{ end }}
-							{{ end }}
-						{{ end }}
-					{{ end }}
-				{{ end }}
-			{{ else }}
-				<!-- If this is not an empty page, include it if it's not hidden -->
-				{{ if and (not .Params.toc_hide) (ne .Params.no_list true) (ne .Kind "section") }}
-					{{ $allPages = $allPages | append . }}
-				{{ end }}
-				<!-- Also include its subpages recursively if it has any -->
-				{{ if .Pages }}
-					{{ range .Pages.ByWeight }}
-						{{ if and (ne .Params.layout "empty") (not .Params.toc_hide) (ne .Params.no_list true) }}
-							{{ $allPages = $allPages | append . }}
-						{{ end }}
-						<!-- Process third level pages -->
-						{{ if .Pages }}
-							{{ range .Pages.ByWeight }}
-								{{ if and (ne .Params.layout "empty") (not .Params.toc_hide) (ne .Params.no_list true) }}
-									{{ $allPages = $allPages | append . }}
-								{{ end }}
-								<!-- Process fourth level pages -->
-								{{ if .Pages }}
-									{{ range .Pages.ByWeight }}
-										{{ if and (ne .Params.layout "empty") (not .Params.toc_hide) (ne .Params.no_list true) }}
-											{{ $allPages = $allPages | append . }}
-										{{ end }}
-										<!-- Process fifth level pages -->
-										{{ if .Pages }}
-											{{ range .Pages.ByWeight }}
-												{{ if and (ne .Params.layout "empty") (not .Params.toc_hide) (ne .Params.no_list true) }}
-													{{ $allPages = $allPages | append . }}
-												{{ end }}
-											{{ end }}
-										{{ end }}
-									{{ end }}
-								{{ end }}
-							{{ end }}
-						{{ end }}
-					{{ end }}
-				{{ end }}
-			{{ end }}
-		{{ end }}
-	{{ end }}
-
-	<!-- Find next and previous pages from filtered list -->
-	{{ $nextPage := false }}
-	{{ $prevPage := false }}
-	{{ $currentPage := . }}
-	{{ range $i, $pageIterator := $allPages }}
-		{{ if eq $pageIterator $currentPage }}
-			{{ if lt $i (sub (len $allPages) 1) }}
-				{{ $nextPage = index $allPages (add $i 1) }}
-			{{ end }}
-			{{ if gt $i 0 }}
-				{{ $prevPage = index $allPages (sub $i 1) }}
-			{{ end }}
-		{{ end }}
-	{{ end }}
-
-
-	<!-- These are swapped in order -->
-	{{ if or $prevPage .Params.prev }}
-	<div class="row-no-margin">
-	{{ else }}
-	<div class="row-no-margin {{ if not .Params.prev }}right-only{{ end }}">
-	{{ end }}
-
-	{{ if .Params.prev }}
-		{{ partial "nextcard.html" (dict "link" (.Params.prev) "class" "left"  "customCanonicalLink" (.Page.Params.canonical) ) }}
-	{{ else }}
-		{{ with $prevPage }}
-			{{ partial "nextcard.html" (dict "link" (.Page.File.Path) "class" "left"  "customCanonicalLink" (.Page.Params.canonical) ) }}
-		{{ end }}
-	{{ end }}
-
-	{{ if .Params.next }}
-		{{ partial "nextcard.html" (dict "link" (.Params.next) "class" "right"  "customCanonicalLink" (.Page.Params.canonical) ) }}
-	{{ else }}
-		{{ with $nextPage }}
-			{{ partial "nextcard.html" (dict "link" (.Page.File.Path) "class" "right"  "customCanonicalLink" (.Page.Params.canonical) ) }}
-		{{ end }}
-	{{ end }}
-	</div>
-	</div>
-	{{ end }}
-
 	{{ if (.Site.Params.DisqusShortname) }}
 		<br />
 		{{ partial "disqus-comment.html" . }}
diff --git a/layouts/partials/glossary-terms.html b/layouts/partials/glossary-terms.html
index c9fbf18482..9cd5f49f13 100644
--- a/layouts/partials/glossary-terms.html
+++ b/layouts/partials/glossary-terms.html
@@ -1,7 +1,7 @@
-{{ $glossaryItems := site.GetPage "page" "dev/reference/glossary" }}
+{{ $glossaryItems := site.GetPage "page" "reference/glossary" }}
 {{- if $glossaryItems -}}
   {{ $pages := $glossaryItems.Resources.ByType "page" }}
   {{- $.Scratch.Set "glossary_items"  $pages -}}
 {{- else -}}
-{{- errorf "No glossary items. Please create items in dev/reference/glossary" -}}
+{{- errorf "No glossary items. Please create items in reference/glossary" -}}
 {{- end -}}
\ No newline at end of file
diff --git a/layouts/partials/navbar.html b/layouts/partials/navbar.html
index ecdf1b06a1..6e382a6855 100644
--- a/layouts/partials/navbar.html
+++ b/layouts/partials/navbar.html
@@ -74,17 +74,4 @@
     </div>
 
   </div>
-  <div class="second-nav">
-    <ul>
-      <li><a href="/" title="Overview" class="{{ if .IsHome }}active-path{{ end }}">Overview</a></li>
-    {{ with .Site.GetPage "/" }}
-    {{- range .Pages -}}
-    {{- $activePath := or ($currentPage.IsDescendant .) (eq $currentPage .) -}}
-    {{- if not (eq .LinkTitle "Tutorials") -}}
-    <li><a href="{{.RelPermalink}}" title="{{ .Title }}" class="{{ if $activePath}} active-path{{ end }}">{{ .LinkTitle }}</a></li>
-    {{- end -}}
-    {{- end -}}
-    {{- end -}}
-    </ul>
-  </div>
 </nav>
diff --git a/layouts/partials/sidebar-tree.html b/layouts/partials/sidebar-tree.html
index bf5c14999a..2457af60bc 100644
--- a/layouts/partials/sidebar-tree.html
+++ b/layouts/partials/sidebar-tree.html
@@ -55,7 +55,7 @@
 
 {{ if eq $p.Section "tutorials"}}
 <!-- If this is a tutorial -->
-<a href="/dev/tools/tutorials/" target="{{ . }}" rel="noopener" class="">
+<a href="/tutorials/" target="{{ . }}" rel="noopener" class="">
 <span> Tutorials </span>
 </a>
 <li class="active-path tutorial-heading">
@@ -64,7 +64,7 @@
 {{ else }}
 
 {{ if or ( or (not $toc_hide) ($activePath) ) $active }}
-<li class="{{ if $withChild }}nav-fold{{ end }}{{ if $activePath }} active-path{{ else }}{{ if $p.Parent }} hide-if-desktop{{ end }}{{ end }}{{ if (not (or $show $p.Site.Params.ui.sidebar_menu_foldable )) }} {{ if not $activePath }}collapse{{ end }}{{ end }}{{ if $empty_node }} empty-node-submenu{{ end }}{{if $s.Params.menuindent }} indent{{ end }}{{ if $headerOnly }} header-only{{ end }} {{ if $active}} active{{ end }}"  >
+<li class="{{ if $withChild }}nav-fold{{ end }}{{ if $activePath }} active-path{{ end }}{{ if (not (or $show $p.Site.Params.ui.sidebar_menu_foldable )) }} {{ if not $activePath }}collapse{{ end }}{{ end }}{{ if $empty_node }} empty-node-submenu{{ end }}{{if $s.Params.menuindent }} indent{{ end }}{{ if $headerOnly }} header-only{{ end }} {{ if $active}} active{{ end }}{{ if (eq $ulNr 1) }} nav-top-section{{ end }}"  >
   {{ if (and $p.Site.Params.ui.sidebar_menu_foldable (ge $ulNr 1)) -}}
   <input type="checkbox" id="{{ $mid }}-check"{{ if $activePath}} checked{{ end }}/>
   <label for="{{ $mid }}-check"><a href="{{ $manualLink }}"{{ if ne $s.LinkTitle $manualLinkTitle }} title="{{ $manualLinkTitle }}"{{ end }}{{ with $s.Params.manualLinkTarget }} target="{{ . }}"{{ if eq . "_blank" }} rel="noopener"{{ end }}{{ end }} class="{{ if $active}} active{{ end }}{{ if $treeRoot }} tree-root{{ end }}">{{ $s.LinkTitle }}</a>
@@ -80,11 +80,7 @@
       {{ else }}
         {{ if (not (eq $s.LinkTitle "Tutorials"))}}
           <a href="{{ $manualLink }}"{{ if ne $s.LinkTitle $manualLinkTitle }} title="{{ $manualLinkTitle }}"{{ end }}{{ with $s.Params.manualLinkTarget }} target="{{ . }}"{{ if eq . "_blank" }} rel="noopener"{{ end }}{{ end }} class="{{ if $active}} active{{ end }}{{ if $treeRoot }} tree-root{{ end }}">
-          {{ if $s.Params.overview }}
-            <span class="section-overview"> Overview </span><span class="section-overview-title"> {{ $s.LinkTitle }} </span>
-          {{ else }}
             <span> {{ $s.LinkTitle }} </span>
-          {{ end }}
           {{ if $s.Params.canonical }}<i class="fas fa-external-link-alt fa-sm"></i>{{ end }}
           </a>
         {{ end }}
@@ -94,7 +90,7 @@
       {{- if (or $hideChildren $treeRoot) -}}
       {{- else -}}
           <span class="menu-toggle">
-          {{ if (or $activePath $active (eq $ulNr 2)) }}
+          {{ if (or $activePath $active) }}
             <i class="fas fa-chevron-down"></i>
           {{ else }}
             <i class="fas fa-chevron-right"></i>
diff --git a/layouts/shortcodes/glossary_tooltip.html b/layouts/shortcodes/glossary_tooltip.html
index 06a4529bb4..aef8899808 100644
--- a/layouts/shortcodes/glossary_tooltip.html
+++ b/layouts/shortcodes/glossary_tooltip.html
@@ -8,11 +8,11 @@
 {{- else -}}
 {{- $term_info := $glossary_items.GetMatch (printf "%s.md" $id ) -}}
 {{- if not $term_info -}}
-{{- errorf "%q: %q is not a valid glossary term_id, see ./docs/dev/reference/glossary/* for a full list" .Page.Path $id -}}
+{{- errorf "%q: %q is not a valid glossary term_id, see ./docs/reference/glossary/* for a full list" .Page.Path $id -}}
 {{- end }}
 {{- with $term_info -}}
 {{- $text := $text | default $term_info.Title -}}
-{{- $glossary_home := "/dev/reference/glossary/" | relLangURL -}}
+{{- $glossary_home := "/reference/glossary/" | relLangURL -}}
 {{- $external_link := $term_info.Params.full_link | default (printf "%s#term-%s" $glossary_home $id | safeURL  ) -}}
 {{- $tooltip :=  $term_info.Params.short_description | markdownify -}}
 
diff --git a/netlify.toml b/netlify.toml
index b1f8651d5d..b02f7d7d32 100644
--- a/netlify.toml
+++ b/netlify.toml
@@ -1,6 +1,141 @@
 [build]
   publish = "public"
 
+[[redirects]]
+  from = "/data/"
+  to = "/data/overview/"
+  status = 301
+
+[[redirects]]
+  from = "/foundation/initialize-a-viam-machine/"
+  to = "/foundation/"
+  status = 301
+
+[[redirects]]
+  from = "/fleet/scheduled-jobs/"
+  to = "/fleet/schedule-jobs/"
+  status = 301
+
+[[redirects]]
+  from = "/fleet/update-software/"
+  to = "/fleet/manage-versions/"
+  status = 301
+
+[[redirects]]
+  from = "/data-ai/capture-data/*"
+  to = "/data/"
+  status = 301
+
+[[redirects]]
+  from = "/data-ai/data/*"
+  to = "/data/"
+  status = 301
+
+[[redirects]]
+  from = "/data-ai/ai/*"
+  to = "/vision/"
+  status = 301
+
+[[redirects]]
+  from = "/data-ai/train/*"
+  to = "/train/"
+  status = 301
+
+[[redirects]]
+  from = "/data-ai/reference/*"
+  to = "/reference/"
+  status = 301
+
+[[redirects]]
+  from = "/data-ai/*"
+  to = "/data/"
+  status = 301
+
+[[redirects]]
+  from = "/manage/fleet/*"
+  to = "/fleet/"
+  status = 301
+
+[[redirects]]
+  from = "/manage/manage/*"
+  to = "/organization/"
+  status = 301
+
+[[redirects]]
+  from = "/manage/software/*"
+  to = "/fleet/"
+  status = 301
+
+[[redirects]]
+  from = "/manage/troubleshoot/*"
+  to = "/monitor/"
+  status = 301
+
+[[redirects]]
+  from = "/manage/reference/*"
+  to = "/reference/"
+  status = 301
+
+[[redirects]]
+  from = "/manage/*"
+  to = "/"
+  status = 301
+
+[[redirects]]
+  from = "/dev/reference/apis/*"
+  to = "/reference/apis/"
+  status = 301
+
+[[redirects]]
+  from = "/dev/reference/sdks/*"
+  to = "/reference/sdks/"
+  status = 301
+
+[[redirects]]
+  from = "/dev/reference/glossary/*"
+  to = "/reference/glossary/"
+  status = 301
+
+[[redirects]]
+  from = "/dev/reference/*"
+  to = "/reference/"
+  status = 301
+
+[[redirects]]
+  from = "/dev/*"
+  to = "/reference/"
+  status = 301
+
+[[redirects]]
+  from = "/reference/components/*"
+  to = "/reference/"
+  status = 301
+
+[[redirects]]
+  from = "/reference/services/*"
+  to = "/reference/"
+  status = 301
+
+[[redirects]]
+  from = "/reference/account/*"
+  to = "/reference/"
+  status = 301
+
+[[redirects]]
+  from = "/reference/advanced-modules/*"
+  to = "/reference/"
+  status = 301
+
+[[redirects]]
+  from = "/reference/glossary_tmp/*"
+  to = "/reference/glossary/"
+  status = 301
+
+[[redirects]]
+  from = "/reference/module-configuration/"
+  to = "/reference/"
+  status = 301
+
 [[plugins]]
   package = "netlify-plugin-hugo-cache-resources"
 
@@ -57,7 +192,7 @@
   [plugins.inputs]
 
   # change this key to a new one any time you need to restart from scratch
-  cacheKey = ["Nov272025"]
+  cacheKey = "Apr142026b"
   # either "warn" or "error"
   failBuildOnError = true
 
@@ -71,6 +206,7 @@
 
   failBuildOnError = true
   failPluginOnError = true
+  skipPatterns = ["/dev/", "/reference/components/", "/reference/services/", "/reference/account/", "/reference/advanced-modules/", "/reference/glossary_tmp/", "/reference/module-configuration/", "/reference/configuration/"]
 
 
 [[context.branch-deploy.plugins]]
@@ -80,3 +216,4 @@
 
   failBuildOnError = true
   failPluginOnError = true
+  skipPatterns = ["/dev/", "/reference/components/", "/reference/services/", "/reference/account/", "/reference/advanced-modules/", "/reference/glossary_tmp/", "/reference/module-configuration/", "/reference/configuration/"]
diff --git a/scripts/verify-svg.py b/scripts/verify-svg.py
new file mode 100644
index 0000000000..c4d1c1e5b4
--- /dev/null
+++ b/scripts/verify-svg.py
@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Verify SVG diagram layout: nesting, balance, and text fitting.
+Run after every SVG edit before presenting to reviewer.
+
+Usage: python3 scripts/verify-svg.py static/what-is-viam-technical.svg
+"""
+
+import re
+import sys
+from collections import defaultdict
+
+
+def parse_rects(svg_content):
+    """Extract all rects with their x, y, width, height."""
+    rects = []
+    # Match rect elements, capturing the line they're on
+    for i, line in enumerate(svg_content.split('\n')):
+        match = re.search(r'<rect\s+x="([^"]+)"\s+y="([^"]+)"\s+width="([^"]+)"\s+height="([^"]+)"', line)
+        if match:
+            x, y, w, h = float(match.group(1)), float(match.group(2)), float(match.group(3)), float(match.group(4))
+            # Try to find a comment or nearby text for labeling
+            rects.append({
+                'x': x, 'y': y, 'w': w, 'h': h,
+                'right': x + w, 'bottom': y + h,
+                'line': i + 1,
+                'src': line.strip()[:80]
+            })
+    return rects
+
+
+def parse_texts(svg_content):
+    """Extract all text elements with position and content."""
+    texts = []
+    for i, line in enumerate(svg_content.split('\n')):
+        match = re.search(r'<text\s+x="([^"]+)".*?font-size:(\d+)px.*?>([^<]+)</text>', line)
+        if match:
+            x = float(match.group(1))
+            font_size = int(match.group(2))
+            content = match.group(3).strip()
+            # Estimate pixel width: bold ~7px/char at 13px, normal ~6px/char at 10-11px, italic ~5.5px/char at 9px
+            if font_size >= 13:
+                px_per_char = 7.5
+            elif font_size >= 10:
+                px_per_char = 6.0
+            else:
+                px_per_char = 5.5
+            est_width = len(content) * px_per_char
+            texts.append({
+                'x': x, 'font_size': font_size, 'content': content,
+                'est_width': est_width, 'line': i + 1
+            })
+    return texts
+
+
+def check_nesting(rects):
+    """Check that smaller rects fit inside larger rects that share similar x positions."""
+    issues = []
+    # Sort by area (largest first)
+    by_area = sorted(rects, key=lambda r: r['w'] * r['h'], reverse=True)
+
+    for i, child in enumerate(by_area):
+        for parent in by_area:
+            if parent is child:
+                continue
+            # Check if child is roughly inside parent (overlapping y range and similar x)
+            if (child['x'] >= parent['x'] - 5 and
+                child['y'] >= parent['y'] and
+                child['w'] < parent['w'] and
+                child['bottom'] <= parent['bottom'] + 5):
+                # This looks like a parent-child relationship
+                if child['right'] > parent['right']:
+                    issues.append(
+                        f"  OVERFLOW: rect at line {child['line']} (right={child['right']:.0f}) "
+                        f"exceeds parent at line {parent['line']} (right={parent['right']:.0f}) "
+                        f"by {child['right'] - parent['right']:.0f}px"
+                    )
+                # Check horizontal balance
+                left_pad = child['x'] - parent['x']
+                right_pad = parent['right'] - child['right']
+                if abs(left_pad - right_pad) > 3 and left_pad > 0 and right_pad > 0:
+                    issues.append(
+                        f"  UNBALANCED: rect at line {child['line']} in parent at line {parent['line']}: "
+                        f"left={left_pad:.0f}px right={right_pad:.0f}px (diff={abs(left_pad-right_pad):.0f}px)"
+                    )
+                break  # Only check immediate parent
+    return issues
+
+
+def check_text_overflow(texts, rects):
+    """Check if text is wider than its containing rect."""
+    issues = []
+    for text in texts:
+        # Find the smallest rect that contains this text
+        containing = None
+        for rect in rects:
+            if (rect['x'] <= text['x'] <= rect['right'] and
+                rect['y'] <= 400):  # rough y check
+                if containing is None or rect['w'] < containing['w']:
+                    containing = rect
+        if containing and text['est_width'] > containing['w']:
+            issues.append(
+                f"  TEXT OVERFLOW: \"{text['content']}\" (~{text['est_width']:.0f}px) "
+                f"in rect width={containing['w']:.0f}px at line {containing['line']}"
+            )
+    return issues
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python3 verify-svg.py <svg-file>")
+        sys.exit(1)
+
+    with open(sys.argv[1]) as f:
+        content = f.read()
+
+    rects = parse_rects(content)
+    texts = parse_texts(content)
+
+    print(f"Found {len(rects)} rects, {len(texts)} text elements\n")
+
+    print("=== Nesting & Balance ===")
+    nesting_issues = check_nesting(rects)
+    if nesting_issues:
+        for issue in nesting_issues:
+            print(issue)
+    else:
+        print("  All rects properly nested and balanced")
+
+    print("\n=== Text Overflow ===")
+    text_issues = check_text_overflow(texts, rects)
+    if text_issues:
+        for issue in text_issues:
+            print(issue)
+    else:
+        print("  No text overflow detected")
+
+    print()
+    if nesting_issues or text_issues:
+        print(f"ISSUES FOUND: {len(nesting_issues)} nesting, {len(text_issues)} text")
+        sys.exit(1)
+    else:
+        print("ALL CHECKS PASSED")
+        sys.exit(0)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/static/data/data-flow-overview.svg b/static/data/data-flow-overview.svg
new file mode 100644
index 0000000000..499b988558
--- /dev/null
+++ b/static/data/data-flow-overview.svg
@@ -0,0 +1,73 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 720 190" font-family="'Inter', 'Helvetica Neue', Arial, sans-serif">
+  <defs>
+    <style>
+      .stage-label { font-size: 13px; font-weight: 600; fill: #252525; }
+      .detail { font-size: 10px; fill: #808080; }
+      .layer-label { font-size: 11px; font-weight: 600; letter-spacing: 0.05em; text-transform: uppercase; fill: #252525; }
+    </style>
+  </defs>
+
+  <!-- Layer boundaries -->
+  <rect x="0" y="0" width="310" height="190" rx="6" fill="none" stroke="#252525" stroke-width="1.5"/>
+  <text x="12" y="18" class="layer-label">On the machine</text>
+
+  <rect x="320" y="0" width="400" height="190" rx="6" fill="none" stroke="#252525" stroke-width="1.5"/>
+  <text x="332" y="18" class="layer-label">In the cloud</text>
+
+  <!-- Stage 1: Capture -->
+  <rect x="12" y="30" width="135" height="146" rx="4" fill="#fff" stroke="#e0e0e0" stroke-width="1"/>
+  <text x="79.5" y="52" text-anchor="middle" class="stage-label">Capture</text>
+  <line x1="20" y1="58" x2="139" y2="58" stroke="#e0e0e0" stroke-width="0.5"/>
+  <text x="79.5" y="76" text-anchor="middle" class="detail">viam-server records</text>
+  <text x="79.5" y="92" text-anchor="middle" class="detail">component data at a</text>
+  <text x="79.5" y="108" text-anchor="middle" class="detail">configured frequency</text>
+  <line x1="20" y1="116" x2="139" y2="116" stroke="#e0e0e0" stroke-width="0.5"/>
+  <text x="79.5" y="134" text-anchor="middle" class="detail">Saves to .capture</text>
+  <text x="79.5" y="150" text-anchor="middle" class="detail">files on local disk</text>
+
+  <!-- Arrow 1→2 -->
+  <line x1="147" y1="103" x2="163" y2="103" stroke="#252525" stroke-width="1.2"/>
+  <polygon points="160,99 169,103 160,107" fill="#252525"/>
+
+  <!-- Stage 2: Sync -->
+  <rect x="169" y="30" width="130" height="146" rx="4" fill="#fff" stroke="#e0e0e0" stroke-width="1"/>
+  <text x="234" y="52" text-anchor="middle" class="stage-label">Sync</text>
+  <line x1="177" y1="58" x2="291" y2="58" stroke="#e0e0e0" stroke-width="0.5"/>
+  <text x="234" y="76" text-anchor="middle" class="detail">Uploads captured</text>
+  <text x="234" y="92" text-anchor="middle" class="detail">data to Viam cloud</text>
+  <line x1="177" y1="100" x2="291" y2="100" stroke="#e0e0e0" stroke-width="0.5"/>
+  <text x="234" y="118" text-anchor="middle" class="detail">Deletes local files</text>
+  <text x="234" y="134" text-anchor="middle" class="detail">after upload</text>
+  <line x1="177" y1="142" x2="291" y2="142" stroke="#e0e0e0" stroke-width="0.5"/>
+  <text x="234" y="160" text-anchor="middle" class="detail">Default: every 6s</text>
+
+  <!-- Arrow 2→3 (dashed, crosses machine-to-cloud boundary) -->
+  <line x1="299" y1="103" x2="329" y2="103" stroke="#252525" stroke-width="1.2" stroke-dasharray="4,3"/>
+  <polygon points="326,99 335,103 326,107" fill="#252525"/>
+
+  <!-- Stage 3: Store -->
+  <rect x="335" y="30" width="145" height="146" rx="4" fill="#fff" stroke="#e0e0e0" stroke-width="1"/>
+  <text x="407.5" y="52" text-anchor="middle" class="stage-label">Store</text>
+  <line x1="343" y1="58" x2="472" y2="58" stroke="#e0e0e0" stroke-width="0.5"/>
+  <text x="407.5" y="76" text-anchor="middle" class="detail">Tabular data</text>
+  <text x="407.5" y="92" text-anchor="middle" class="detail">(readings, positions)</text>
+  <text x="407.5" y="108" text-anchor="middle" class="detail">→ MongoDB</text>
+  <line x1="343" y1="116" x2="472" y2="116" stroke="#e0e0e0" stroke-width="0.5"/>
+  <text x="407.5" y="134" text-anchor="middle" class="detail">Binary data</text>
+  <text x="407.5" y="150" text-anchor="middle" class="detail">(images, point clouds)</text>
+  <text x="407.5" y="166" text-anchor="middle" class="detail">→ Blob storage</text>
+
+  <!-- Arrow 3→4 -->
+  <line x1="480" y1="103" x2="496" y2="103" stroke="#252525" stroke-width="1.2"/>
+  <polygon points="493,99 502,103 493,107" fill="#252525"/>
+
+  <!-- Stage 4: Use -->
+  <rect x="502" y="30" width="206" height="146" rx="4" fill="#fff" stroke="#e0e0e0" stroke-width="1"/>
+  <text x="605" y="52" text-anchor="middle" class="stage-label">Use</text>
+  <line x1="510" y1="58" x2="700" y2="58" stroke="#e0e0e0" stroke-width="0.5"/>
+  <text x="605" y="78" text-anchor="middle" class="detail">Query with SQL or MQL</text>
+  <text x="605" y="98" text-anchor="middle" class="detail">Export to your tools</text>
+  <text x="605" y="118" text-anchor="middle" class="detail">Build ML datasets</text>
+  <text x="605" y="138" text-anchor="middle" class="detail">Visualize in dashboards</text>
+  <text x="605" y="158" text-anchor="middle" class="detail">Trigger alerts</text>
+</svg>
diff --git a/static/include/app/apis/generated/app-table.md b/static/include/app/apis/generated/app-table.md
index 79b3de5cd1..cdae6cc721 100644
--- a/static/include/app/apis/generated/app-table.md
+++ b/static/include/app/apis/generated/app-table.md
@@ -1,86 +1,86 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`GetUserIDByEmail`](/dev/reference/apis/fleet/#getuseridbyemail) | Get the ID of a user by email. |
-| [`CreateOrganization`](/dev/reference/apis/fleet/#createorganization) | Create an organization. |
-| [`ListOrganizations`](/dev/reference/apis/fleet/#listorganizations) | List the {{< glossary_tooltip term_id="organization" text="organizations" >}} the user is an authorized user of. |
-| [`GetOrganizationsWithAccessToLocation`](/dev/reference/apis/fleet/#getorganizationswithaccesstolocation) | Get all organizations that have access to a location. |
-| [`ListOrganizationsByUser`](/dev/reference/apis/fleet/#listorganizationsbyuser) | List the organizations a user belongs to. |
-| [`GetOrganization`](/dev/reference/apis/fleet/#getorganization) | Retrieve the organization object for the requested organization containing the organization's ID, name, public namespace, and more. |
-| [`GetOrganizationNamespaceAvailability`](/dev/reference/apis/fleet/#getorganizationnamespaceavailability) | Check the availability of an {{< glossary_tooltip term_id="organization" text="organization" >}} namespace. |
-| [`UpdateOrganization`](/dev/reference/apis/fleet/#updateorganization) | Updates organization details. |
-| [`DeleteOrganization`](/dev/reference/apis/fleet/#deleteorganization) | Delete an organization. |
-| [`ListOrganizationMembers`](/dev/reference/apis/fleet/#listorganizationmembers) | List the members and invites of the {{< glossary_tooltip term_id="organization" text="organization" >}} that you are currently authenticated to. |
-| [`CreateOrganizationInvite`](/dev/reference/apis/fleet/#createorganizationinvite) | Create an {{< glossary_tooltip term_id="organization" text="organization" >}} invite and send it by email. |
-| [`UpdateOrganizationInviteAuthorizations`](/dev/reference/apis/fleet/#updateorganizationinviteauthorizations) | Update (add or remove) the authorizations attached to an organization invite that has already been created. |
-| [`DeleteOrganizationMember`](/dev/reference/apis/fleet/#deleteorganizationmember) | Remove a member from the {{< glossary_tooltip term_id="organization" text="organization" >}} you are currently authenticated to. |
-| [`DeleteOrganizationInvite`](/dev/reference/apis/fleet/#deleteorganizationinvite) | Delete a pending organization invite to the organization you are currently authenticated to. |
-| [`ResendOrganizationInvite`](/dev/reference/apis/fleet/#resendorganizationinvite) | Resend a pending organization invite email. |
-| [`GetOrganizationMetadata`](/dev/reference/apis/fleet/#getorganizationmetadata) | Gets the user-defined metadata for an organization. |
-| [`UpdateOrganizationMetadata`](/dev/reference/apis/fleet/#updateorganizationmetadata) | Updates the user-defined metadata for an organization. |
-| [`CreateLocation`](/dev/reference/apis/fleet/#createlocation) | Create and name a {{< glossary_tooltip term_id="location" text="location" >}} under the organization you are currently authenticated to. |
-| [`GetLocation`](/dev/reference/apis/fleet/#getlocation) | Get a {{< glossary_tooltip term_id="location" text="location" >}} by its location ID. |
-| [`UpdateLocation`](/dev/reference/apis/fleet/#updatelocation) | Change the name of a {{< glossary_tooltip term_id="location" text="location" >}} and/or assign a parent location to a location. |
-| [`DeleteLocation`](/dev/reference/apis/fleet/#deletelocation) | Delete a {{< glossary_tooltip term_id="location" text="location" >}}. |
-| [`ListLocations`](/dev/reference/apis/fleet/#listlocations) | Get a list of all {{< glossary_tooltip term_id="location" text="locations" >}} under the organization you are currently authenticated to. |
-| [`ShareLocation`](/dev/reference/apis/fleet/#sharelocation) | Share a location with an organization. |
-| [`UnshareLocation`](/dev/reference/apis/fleet/#unsharelocation) | Stop sharing a location with an organization. |
-| [`LocationAuth`](/dev/reference/apis/fleet/#locationauth) | Get a location’s `LocationAuth` (location secret or secrets). |
-| [`CreateLocationSecret`](/dev/reference/apis/fleet/#createlocationsecret) | Create a new location secret. |
-| [`DeleteLocationSecret`](/dev/reference/apis/fleet/#deletelocationsecret) | Delete a location secret. |
-| [`GetLocationMetadata`](/dev/reference/apis/fleet/#getlocationmetadata) | Get the user-defined metadata for a location. |
-| [`UpdateLocationMetadata`](/dev/reference/apis/fleet/#updatelocationmetadata) | Update the user-defined metadata for a location. |
-| [`GetRobot`](/dev/reference/apis/fleet/#getrobot) | Get a {{< glossary_tooltip term_id="machine" text="machine" >}} by its ID. |
-| [`GetRobotAPIKeys`](/dev/reference/apis/fleet/#getrobotapikeys) | Gets the API keys for the machine. |
-| [`GetRobotParts`](/dev/reference/apis/fleet/#getrobotparts) | Get a list of all the {{< glossary_tooltip term_id="part" text="parts" >}} under a specific {{< glossary_tooltip term_id="machine" text="machine" >}}. |
-| [`GetRobotPart`](/dev/reference/apis/fleet/#getrobotpart) | Get a specific machine {{< glossary_tooltip term_id="part" text="part" >}} including its part config, part address, and other information. |
-| [`GetRobotPartLogs`](/dev/reference/apis/fleet/#getrobotpartlogs) | Get the logs associated with a specific machine {{< glossary_tooltip term_id="part" text="part" >}}. |
-| [`GetRobotPartByNameAndLocation`](/dev/reference/apis/fleet/#getrobotpartbynameandlocation) | Query a specific robot part by name and location id. |
-| [`TailRobotPartLogs`](/dev/reference/apis/fleet/#tailrobotpartlogs) | Get an asynchronous iterator that receives live machine part logs. |
-| [`GetRobotPartHistory`](/dev/reference/apis/fleet/#getrobotparthistory) | Get a list containing the history of a machine {{< glossary_tooltip term_id="part" text="part" >}}. |
-| [`UpdateRobotPart`](/dev/reference/apis/fleet/#updaterobotpart) | Change the name of and assign an optional new configuration to a machine {{< glossary_tooltip term_id="part" text="part" >}}. |
-| [`NewRobotPart`](/dev/reference/apis/fleet/#newrobotpart) | Create a new machine {{< glossary_tooltip term_id="part" text="part" >}}. |
-| [`DeleteRobotPart`](/dev/reference/apis/fleet/#deleterobotpart) | Delete the specified machine {{< glossary_tooltip term_id="part" text="part" >}}. |
-| [`MarkPartAsMain`](/dev/reference/apis/fleet/#markpartasmain) | Mark a machine part as the _main_ part of a machine. |
-| [`MarkPartForRestart`](/dev/reference/apis/fleet/#markpartforrestart) | Mark a specified machine part for restart. |
-| [`CreateRobotPartSecret`](/dev/reference/apis/fleet/#createrobotpartsecret) | Create a machine {{< glossary_tooltip term_id="part" text="part" >}} secret. |
-| [`DeleteRobotPartSecret`](/dev/reference/apis/fleet/#deleterobotpartsecret) | Delete a machine part secret. |
-| [`ListRobots`](/dev/reference/apis/fleet/#listrobots) | Get a list of all machines in a specified location. |
-| [`NewRobot`](/dev/reference/apis/fleet/#newrobot) | Create a new {{< glossary_tooltip term_id="machine" text="machine" >}}. |
-| [`UpdateRobot`](/dev/reference/apis/fleet/#updaterobot) | Update an existing machine's name and/or location. |
-| [`DeleteRobot`](/dev/reference/apis/fleet/#deleterobot) | Delete a specified machine. |
-| [`GetRobotMetadata`](/dev/reference/apis/fleet/#getrobotmetadata) | Gets the user-defined metadata for a machine. |
-| [`GetRobotPartMetadata`](/dev/reference/apis/fleet/#getrobotpartmetadata) | Gets the user-defined metadata for a machine part. |
-| [`UpdateRobotMetadata`](/dev/reference/apis/fleet/#updaterobotmetadata) | Updates the user-defined metadata for a machine. |
-| [`UpdateRobotPartMetadata`](/dev/reference/apis/fleet/#updaterobotpartmetadata) | Updates the user-defined metadata for a machine part. |
-| [`ListFragments`](/dev/reference/apis/fleet/#listfragments) | Get a list of {{< glossary_tooltip term_id="fragment" text="fragments" >}} in the organization you are currently authenticated to. |
-| [`ListMachineFragments`](/dev/reference/apis/fleet/#listmachinefragments) | Get a list of top level and nested {{< glossary_tooltip term_id="fragment" text="fragments" >}} for a machine, as well as additionally specified fragment IDs. |
-| [`ListMachineSummaries`](/dev/reference/apis/fleet/#listmachinesummaries) | Lists machine summaries for an organization, optionally filtered by fragment IDs, location IDs, and limit. |
-| [`GetFragment`](/dev/reference/apis/fleet/#getfragment) | Get a {{< glossary_tooltip term_id="fragment" text="fragment" >}} by ID. |
-| [`CreateFragment`](/dev/reference/apis/fleet/#createfragment) | Create a new private {{< glossary_tooltip term_id="fragment" text="fragment" >}}. |
-| [`UpdateFragment`](/dev/reference/apis/fleet/#updatefragment) | Update a {{< glossary_tooltip term_id="fragment" text="fragment" >}} name and its config and/or visibility. |
-| [`DeleteFragment`](/dev/reference/apis/fleet/#deletefragment) | Delete a {{< glossary_tooltip term_id="fragment" text="fragment" >}}. |
-| [`GetFragmentHistory`](/dev/reference/apis/fleet/#getfragmenthistory) | Get fragment history. |
-| [`AddRole`](/dev/reference/apis/fleet/#addrole) | Add a role under the organization you are currently authenticated to. |
-| [`RemoveRole`](/dev/reference/apis/fleet/#removerole) | Remove a role under the organization you are currently authenticated to. |
-| [`ChangeRole`](/dev/reference/apis/fleet/#changerole) | Changes an existing role to a new role. |
-| [`ListAuthorizations`](/dev/reference/apis/fleet/#listauthorizations) | List all authorizations (owners and operators) of a specific resource (or resources) within the organization you are currently authenticated to. |
-| [`CheckPermissions`](/dev/reference/apis/fleet/#checkpermissions) | Check if the organization, location, or robot your `ViamClient` is authenticated to is permitted to perform some action or set of actions on the resource you pass to the method. |
-| [`GetRegistryItem`](/dev/reference/apis/fleet/#getregistryitem) | Get metadata about a registry item (a module, training script, or ML model) by registry item ID. |
-| [`CreateRegistryItem`](/dev/reference/apis/fleet/#createregistryitem) | Create a registry item. |
-| [`UpdateRegistryItem`](/dev/reference/apis/fleet/#updateregistryitem) | Update a registry item. |
-| [`ListRegistryItems`](/dev/reference/apis/fleet/#listregistryitems) | List the registry items in an organization. |
-| [`DeleteRegistryItem`](/dev/reference/apis/fleet/#deleteregistryitem) | Delete a registry item. |
-| [`CreateModule`](/dev/reference/apis/fleet/#createmodule) | Create a {{< glossary_tooltip term_id="module" text="module" >}} under the organization you are currently authenticated to. |
-| [`UpdateModule`](/dev/reference/apis/fleet/#updatemodule) | Update the documentation URL, description, models, entrypoint, and/or the visibility of a {{< glossary_tooltip term_id="module" text="module" >}}. |
-| [`UploadModuleFile`](/dev/reference/apis/fleet/#uploadmodulefile) | Upload a {{< glossary_tooltip term_id="module" text="module" >}} file. |
-| [`GetModule`](/dev/reference/apis/fleet/#getmodule) | Get a {{< glossary_tooltip term_id="module" text="module" >}} by its ID. |
-| [`ListModules`](/dev/reference/apis/fleet/#listmodules) | List the {{< glossary_tooltip term_id="module" text="modules" >}} under the organization you are currently authenticated to. |
-| [`CreateKey`](/dev/reference/apis/fleet/#createkey) | Create a new API key. |
-| [`DeleteKey`](/dev/reference/apis/fleet/#deletekey) | Delete an API key. |
-| [`RotateKey`](/dev/reference/apis/fleet/#rotatekey) | Rotate an API key. |
-| [`ListKeys`](/dev/reference/apis/fleet/#listkeys) | List all keys for the {{< glossary_tooltip term_id="organization" text="organization" >}} that you are currently authenticated to. |
-| [`RenameKey`](/dev/reference/apis/fleet/#renamekey) | RenameKey renames an API key and returns its ID and name. |
-| [`CreateKeyFromExistingKeyAuthorizations`](/dev/reference/apis/fleet/#createkeyfromexistingkeyauthorizations) | Create a new API key with an existing key’s authorizations. |
-| [`GetAppContent`](/dev/reference/apis/fleet/#getappcontent) | Retrieve the app content for an organization. |
-| [`GetAppBranding`](/dev/reference/apis/fleet/#getappbranding) | Retrieves the app branding for an organization or app. |
+| [`GetUserIDByEmail`](/reference/apis/fleet/#getuseridbyemail) | Get the ID of a user by email. |
+| [`CreateOrganization`](/reference/apis/fleet/#createorganization) | Create an organization. |
+| [`ListOrganizations`](/reference/apis/fleet/#listorganizations) | List the {{< glossary_tooltip term_id="organization" text="organizations" >}} the user is an authorized user of. |
+| [`GetOrganizationsWithAccessToLocation`](/reference/apis/fleet/#getorganizationswithaccesstolocation) | Get all organizations that have access to a location. |
+| [`ListOrganizationsByUser`](/reference/apis/fleet/#listorganizationsbyuser) | List the organizations a user belongs to. |
+| [`GetOrganization`](/reference/apis/fleet/#getorganization) | Retrieve the organization object for the requested organization containing the organization's ID, name, public namespace, and more. |
+| [`GetOrganizationNamespaceAvailability`](/reference/apis/fleet/#getorganizationnamespaceavailability) | Check the availability of an {{< glossary_tooltip term_id="organization" text="organization" >}} namespace. |
+| [`UpdateOrganization`](/reference/apis/fleet/#updateorganization) | Updates organization details. |
+| [`DeleteOrganization`](/reference/apis/fleet/#deleteorganization) | Delete an organization. |
+| [`ListOrganizationMembers`](/reference/apis/fleet/#listorganizationmembers) | List the members and invites of the {{< glossary_tooltip term_id="organization" text="organization" >}} that you are currently authenticated to. |
+| [`CreateOrganizationInvite`](/reference/apis/fleet/#createorganizationinvite) | Create an {{< glossary_tooltip term_id="organization" text="organization" >}} invite and send it by email. |
+| [`UpdateOrganizationInviteAuthorizations`](/reference/apis/fleet/#updateorganizationinviteauthorizations) | Update (add or remove) the authorizations attached to an organization invite that has already been created. |
+| [`DeleteOrganizationMember`](/reference/apis/fleet/#deleteorganizationmember) | Remove a member from the {{< glossary_tooltip term_id="organization" text="organization" >}} you are currently authenticated to. |
+| [`DeleteOrganizationInvite`](/reference/apis/fleet/#deleteorganizationinvite) | Delete a pending organization invite to the organization you are currently authenticated to. |
+| [`ResendOrganizationInvite`](/reference/apis/fleet/#resendorganizationinvite) | Resend a pending organization invite email. |
+| [`GetOrganizationMetadata`](/reference/apis/fleet/#getorganizationmetadata) | Gets the user-defined metadata for an organization. |
+| [`UpdateOrganizationMetadata`](/reference/apis/fleet/#updateorganizationmetadata) | Updates the user-defined metadata for an organization. |
+| [`CreateLocation`](/reference/apis/fleet/#createlocation) | Create and name a {{< glossary_tooltip term_id="location" text="location" >}} under the organization you are currently authenticated to. |
+| [`GetLocation`](/reference/apis/fleet/#getlocation) | Get a {{< glossary_tooltip term_id="location" text="location" >}} by its location ID. |
+| [`UpdateLocation`](/reference/apis/fleet/#updatelocation) | Change the name of a {{< glossary_tooltip term_id="location" text="location" >}} and/or assign a parent location to a location. |
+| [`DeleteLocation`](/reference/apis/fleet/#deletelocation) | Delete a {{< glossary_tooltip term_id="location" text="location" >}}. |
+| [`ListLocations`](/reference/apis/fleet/#listlocations) | Get a list of all {{< glossary_tooltip term_id="location" text="locations" >}} under the organization you are currently authenticated to. |
+| [`ShareLocation`](/reference/apis/fleet/#sharelocation) | Share a location with an organization. |
+| [`UnshareLocation`](/reference/apis/fleet/#unsharelocation) | Stop sharing a location with an organization. |
+| [`LocationAuth`](/reference/apis/fleet/#locationauth) | Get a location’s `LocationAuth` (location secret or secrets). |
+| [`CreateLocationSecret`](/reference/apis/fleet/#createlocationsecret) | Create a new location secret. |
+| [`DeleteLocationSecret`](/reference/apis/fleet/#deletelocationsecret) | Delete a location secret. |
+| [`GetLocationMetadata`](/reference/apis/fleet/#getlocationmetadata) | Get the user-defined metadata for a location. |
+| [`UpdateLocationMetadata`](/reference/apis/fleet/#updatelocationmetadata) | Update the user-defined metadata for a location. |
+| [`GetRobot`](/reference/apis/fleet/#getrobot) | Get a {{< glossary_tooltip term_id="machine" text="machine" >}} by its ID. |
+| [`GetRobotAPIKeys`](/reference/apis/fleet/#getrobotapikeys) | Gets the API keys for the machine. |
+| [`GetRobotParts`](/reference/apis/fleet/#getrobotparts) | Get a list of all the {{< glossary_tooltip term_id="part" text="parts" >}} under a specific {{< glossary_tooltip term_id="machine" text="machine" >}}. |
+| [`GetRobotPart`](/reference/apis/fleet/#getrobotpart) | Get a specific machine {{< glossary_tooltip term_id="part" text="part" >}} including its part config, part address, and other information. |
+| [`GetRobotPartLogs`](/reference/apis/fleet/#getrobotpartlogs) | Get the logs associated with a specific machine {{< glossary_tooltip term_id="part" text="part" >}}. |
+| [`GetRobotPartByNameAndLocation`](/reference/apis/fleet/#getrobotpartbynameandlocation) | Query a specific robot part by name and location id. |
+| [`TailRobotPartLogs`](/reference/apis/fleet/#tailrobotpartlogs) | Get an asynchronous iterator that receives live machine part logs. |
+| [`GetRobotPartHistory`](/reference/apis/fleet/#getrobotparthistory) | Get a list containing the history of a machine {{< glossary_tooltip term_id="part" text="part" >}}. |
+| [`UpdateRobotPart`](/reference/apis/fleet/#updaterobotpart) | Change the name of and assign an optional new configuration to a machine {{< glossary_tooltip term_id="part" text="part" >}}. |
+| [`NewRobotPart`](/reference/apis/fleet/#newrobotpart) | Create a new machine {{< glossary_tooltip term_id="part" text="part" >}}. |
+| [`DeleteRobotPart`](/reference/apis/fleet/#deleterobotpart) | Delete the specified machine {{< glossary_tooltip term_id="part" text="part" >}}. |
+| [`MarkPartAsMain`](/reference/apis/fleet/#markpartasmain) | Mark a machine part as the _main_ part of a machine. |
+| [`MarkPartForRestart`](/reference/apis/fleet/#markpartforrestart) | Mark a specified machine part for restart. |
+| [`CreateRobotPartSecret`](/reference/apis/fleet/#createrobotpartsecret) | Create a machine {{< glossary_tooltip term_id="part" text="part" >}} secret. |
+| [`DeleteRobotPartSecret`](/reference/apis/fleet/#deleterobotpartsecret) | Delete a machine part secret. |
+| [`ListRobots`](/reference/apis/fleet/#listrobots) | Get a list of all machines in a specified location. |
+| [`NewRobot`](/reference/apis/fleet/#newrobot) | Create a new {{< glossary_tooltip term_id="machine" text="machine" >}}. |
+| [`UpdateRobot`](/reference/apis/fleet/#updaterobot) | Update an existing machine's name and/or location. |
+| [`DeleteRobot`](/reference/apis/fleet/#deleterobot) | Delete a specified machine. |
+| [`GetRobotMetadata`](/reference/apis/fleet/#getrobotmetadata) | Gets the user-defined metadata for a machine. |
+| [`GetRobotPartMetadata`](/reference/apis/fleet/#getrobotpartmetadata) | Gets the user-defined metadata for a machine part. |
+| [`UpdateRobotMetadata`](/reference/apis/fleet/#updaterobotmetadata) | Updates the user-defined metadata for a machine. |
+| [`UpdateRobotPartMetadata`](/reference/apis/fleet/#updaterobotpartmetadata) | Updates the user-defined metadata for a machine part. |
+| [`ListFragments`](/reference/apis/fleet/#listfragments) | Get a list of {{< glossary_tooltip term_id="fragment" text="fragments" >}} in the organization you are currently authenticated to. |
+| [`ListMachineFragments`](/reference/apis/fleet/#listmachinefragments) | Get a list of top level and nested {{< glossary_tooltip term_id="fragment" text="fragments" >}} for a machine, as well as additionally specified fragment IDs. |
+| [`ListMachineSummaries`](/reference/apis/fleet/#listmachinesummaries) | Lists machine summaries for an organization, optionally filtered by fragment IDs, location IDs, and limit. |
+| [`GetFragment`](/reference/apis/fleet/#getfragment) | Get a {{< glossary_tooltip term_id="fragment" text="fragment" >}} by ID. |
+| [`CreateFragment`](/reference/apis/fleet/#createfragment) | Create a new private {{< glossary_tooltip term_id="fragment" text="fragment" >}}. |
+| [`UpdateFragment`](/reference/apis/fleet/#updatefragment) | Update a {{< glossary_tooltip term_id="fragment" text="fragment" >}} name and its config and/or visibility. |
+| [`DeleteFragment`](/reference/apis/fleet/#deletefragment) | Delete a {{< glossary_tooltip term_id="fragment" text="fragment" >}}. |
+| [`GetFragmentHistory`](/reference/apis/fleet/#getfragmenthistory) | Get fragment history. |
+| [`AddRole`](/reference/apis/fleet/#addrole) | Add a role under the organization you are currently authenticated to. |
+| [`RemoveRole`](/reference/apis/fleet/#removerole) | Remove a role under the organization you are currently authenticated to. |
+| [`ChangeRole`](/reference/apis/fleet/#changerole) | Changes an existing role to a new role. |
+| [`ListAuthorizations`](/reference/apis/fleet/#listauthorizations) | List all authorizations (owners and operators) of a specific resource (or resources) within the organization you are currently authenticated to. |
+| [`CheckPermissions`](/reference/apis/fleet/#checkpermissions) | Check if the organization, location, or robot your `ViamClient` is authenticated to is permitted to perform some action or set of actions on the resource you pass to the method. |
+| [`GetRegistryItem`](/reference/apis/fleet/#getregistryitem) | Get metadata about a registry item (a module, training script, or ML model) by registry item ID. |
+| [`CreateRegistryItem`](/reference/apis/fleet/#createregistryitem) | Create a registry item. |
+| [`UpdateRegistryItem`](/reference/apis/fleet/#updateregistryitem) | Update a registry item. |
+| [`ListRegistryItems`](/reference/apis/fleet/#listregistryitems) | List the registry items in an organization. |
+| [`DeleteRegistryItem`](/reference/apis/fleet/#deleteregistryitem) | Delete a registry item. |
+| [`CreateModule`](/reference/apis/fleet/#createmodule) | Create a {{< glossary_tooltip term_id="module" text="module" >}} under the organization you are currently authenticated to. |
+| [`UpdateModule`](/reference/apis/fleet/#updatemodule) | Update the documentation URL, description, models, entrypoint, and/or the visibility of a {{< glossary_tooltip term_id="module" text="module" >}}. |
+| [`UploadModuleFile`](/reference/apis/fleet/#uploadmodulefile) | Upload a {{< glossary_tooltip term_id="module" text="module" >}} file. |
+| [`GetModule`](/reference/apis/fleet/#getmodule) | Get a {{< glossary_tooltip term_id="module" text="module" >}} by its ID. |
+| [`ListModules`](/reference/apis/fleet/#listmodules) | List the {{< glossary_tooltip term_id="module" text="modules" >}} under the organization you are currently authenticated to. |
+| [`CreateKey`](/reference/apis/fleet/#createkey) | Create a new API key. |
+| [`DeleteKey`](/reference/apis/fleet/#deletekey) | Delete an API key. |
+| [`RotateKey`](/reference/apis/fleet/#rotatekey) | Rotate an API key. |
+| [`ListKeys`](/reference/apis/fleet/#listkeys) | List all keys for the {{< glossary_tooltip term_id="organization" text="organization" >}} that you are currently authenticated to. |
+| [`RenameKey`](/reference/apis/fleet/#renamekey) | RenameKey renames an API key and returns its ID and name. |
+| [`CreateKeyFromExistingKeyAuthorizations`](/reference/apis/fleet/#createkeyfromexistingkeyauthorizations) | Create a new API key with an existing key’s authorizations. |
+| [`GetAppContent`](/reference/apis/fleet/#getappcontent) | Retrieve the app content for an organization. |
+| [`GetAppBranding`](/reference/apis/fleet/#getappbranding) | Retrieves the app branding for an organization or app. |
diff --git a/static/include/app/apis/generated/app.md b/static/include/app/apis/generated/app.md
index a02030e398..fddfaaf28a 100644
--- a/static/include/app/apis/generated/app.md
+++ b/static/include/app/apis/generated/app.md
@@ -11,7 +11,7 @@ Get the ID of a user by email.
 
 **Returns:**
 
-- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): The ID of the user.
+- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): :   The ID of the user.
 
 **Example:**
 
@@ -80,7 +80,7 @@ Create an organization.
 
 **Returns:**
 
-- ([viam.proto.app.Organization](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Organization)): The created organization.
+- ([viam.proto.app.Organization](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Organization)): :   The created organization.
 
 **Example:**
 
@@ -140,7 +140,7 @@ List the {{< glossary_tooltip term_id="organization" text="organizations" >}} th
 
 **Returns:**
 
-- ([List[viam.proto.app.Organization]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Organization)): The list of organizations.
+- ([List[viam.proto.app.Organization]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Organization)): :   The list of organizations.
 
 **Example:**
 
@@ -205,7 +205,7 @@ Get all organizations that have access to a location.
 
 **Returns:**
 
-- ([List[viam.proto.app.OrganizationIdentity]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.OrganizationIdentity)): The list of organizations.
+- ([List[viam.proto.app.OrganizationIdentity]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.OrganizationIdentity)): :   The list of organizations.
 
 **Example:**
 
@@ -253,7 +253,7 @@ List the organizations a user belongs to.
 
 **Returns:**
 
-- ([List[viam.proto.app.OrgDetails]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.OrgDetails)): The list of organizations.
+- ([List[viam.proto.app.OrgDetails]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.OrgDetails)): :   The list of organizations.
 
 **Example:**
 
@@ -313,7 +313,7 @@ Retrieve the organization object for the requested organization containing the o
 
 **Returns:**
 
-- ([viam.proto.app.Organization](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Organization)): The requested organization.
+- ([viam.proto.app.Organization](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Organization)): :   The requested organization.
 
 **Raises:**
 
@@ -385,7 +385,7 @@ Check the availability of an {{< glossary_tooltip term_id="organization" text="o
 
 **Returns:**
 
-- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): True if the provided namespace is available.
+- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): :   True if the provided namespace is available.
 
 **Raises:**
 
@@ -458,10 +458,11 @@ Updates organization details.
 - `public_namespace` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): If provided, sets the org’s namespace if it hasn’t already been set.
 - `region` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): If provided, updates the org’s region.
 - `cid` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): If provided, update’s the org’s CRM ID.
+- `default_fragments` ([List[viam.proto.app.FragmentImport]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.FragmentImport)) (optional)
 
 **Returns:**
 
-- ([viam.proto.app.Organization](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Organization)): The updated organization.
+- ([viam.proto.app.Organization](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Organization)): :   The updated organization.
 
 **Raises:**
 
@@ -517,6 +518,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/a
 - `publicNamespace` (string) (optional): Optional namespace to update the organization with.
 - `region` (string) (optional): Optional region to update the organization with.
 - `cid` (string) (optional): Optional CRM ID to update the organization with.
+- `defaultFragments` ([FragmentImportList](https://ts.viam.dev/classes/appApi.FragmentImportList.html)) (optional): Optional default fragments to set for the
+  organization.
 
 **Returns:**
 
@@ -613,8 +616,8 @@ List the members and invites of the {{< glossary_tooltip term_id="organization"
 
 **Returns:**
 
-- (Tuple[List[[app.OrganizationMember](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.OrganizationMember)], List[[app.OrganizationInvite](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.OrganizationInvite)]]): A tuple containing two lists; the first
-\[0] of organization members, and the second \[1] of organization invites.
+- (Tuple[List[[app.OrganizationMember](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.OrganizationMember)], List[[app.OrganizationInvite](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.OrganizationInvite)]]): :   A tuple containing two lists; the first
+    [0] of organization members, and the second [1] of organization invites.
 
 **Example:**
 
@@ -687,7 +690,7 @@ Create an {{< glossary_tooltip term_id="organization" text="organization" >}} in
 
 **Returns:**
 
-- ([app.OrganizationInvite](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.OrganizationInvite)): The organization invite.
+- ([app.OrganizationInvite](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.OrganizationInvite)): :   The organization invite.
 
 **Raises:**
 
@@ -794,7 +797,7 @@ If an invitation has only one authorization and you want to remove it, delete th
 
 **Returns:**
 
-- ([app.OrganizationInvite](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.OrganizationInvite)): The updated invite.
+- ([app.OrganizationInvite](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.OrganizationInvite)): :   The updated invite.
 
 **Raises:**
 
@@ -1069,7 +1072,7 @@ Resend a pending organization invite email.
 
 **Returns:**
 
-- ([app.OrganizationInvite](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.OrganizationInvite)): The organization invite sent.
+- ([app.OrganizationInvite](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.OrganizationInvite)): :   The organization invite sent.
 
 **Raises:**
 
@@ -1144,7 +1147,7 @@ Gets the user-defined metadata for an organization.
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]): The user\-defined metadata converted from JSON to a Python dictionary.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]): :   The user-defined metadata converted from JSON to a Python dictionary.
 
 **Example:**
 
@@ -1296,7 +1299,7 @@ Optionally, put the new location under a specified parent location.
 
 **Returns:**
 
-- ([viam.proto.app.Location](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Location)): The newly created location.
+- ([viam.proto.app.Location](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Location)): :   The newly created location.
 
 **Raises:**
 
@@ -1382,7 +1385,7 @@ Get a {{< glossary_tooltip term_id="location" text="location" >}} by its locatio
 
 **Returns:**
 
-- ([viam.proto.app.Location](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Location)): The location.
+- ([viam.proto.app.Location](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Location)): :   The location.
 
 **Raises:**
 
@@ -1454,7 +1457,7 @@ Change the name of a {{< glossary_tooltip term_id="location" text="location" >}}
 
 **Returns:**
 
-- ([viam.proto.app.Location](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Location)): The newly updated location.
+- ([viam.proto.app.Location](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Location)): :   The newly updated location.
 
 **Raises:**
 
@@ -1628,7 +1631,7 @@ Get a list of all {{< glossary_tooltip term_id="location" text="locations" >}} u
 
 **Returns:**
 
-- ([List[viam.proto.app.Location]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Location)): The list of locations.
+- ([List[viam.proto.app.Location]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Location)): :   The list of locations.
 
 **Example:**
 
@@ -1838,7 +1841,7 @@ Get a location’s `LocationAuth` (location secret or secrets).
 
 **Returns:**
 
-- ([viam.proto.app.LocationAuth](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.LocationAuth)): The LocationAuth containing location secrets.
+- ([viam.proto.app.LocationAuth](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.LocationAuth)): :   The LocationAuth containing location secrets.
 
 **Raises:**
 
@@ -1910,7 +1913,7 @@ Create a new location secret.
 
 **Returns:**
 
-- ([viam.proto.app.LocationAuth](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.LocationAuth)): The specified location’s LocationAuth containing the newly created secret.
+- ([viam.proto.app.LocationAuth](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.LocationAuth)): :   The specified location’s LocationAuth containing the newly created secret.
 
 **Raises:**
 
@@ -2064,7 +2067,7 @@ Get the user-defined metadata for a location.
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]): The user\-defined metadata converted from JSON to a Python dictionary.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]): :   The user-defined metadata converted from JSON to a Python dictionary.
 
 **Example:**
 
@@ -2210,7 +2213,7 @@ Get a {{< glossary_tooltip term_id="machine" text="machine" >}} by its ID.
 
 **Returns:**
 
-- ([viam.proto.app.Robot](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Robot)): The machine.
+- ([viam.proto.app.Robot](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Robot)): :   The machine.
 
 **Raises:**
 
@@ -2280,7 +2283,7 @@ Gets the [API keys](/operate/control/api-keys/) for the machine.
 
 **Returns:**
 
-- ([List[viam.proto.app.APIKeyWithAuthorizations]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.APIKeyWithAuthorizations)): The list of API keys.
+- ([List[viam.proto.app.APIKeyWithAuthorizations]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.APIKeyWithAuthorizations)): :   The list of API keys.
 
 **Example:**
 
@@ -2347,7 +2350,7 @@ Get a list of all the {{< glossary_tooltip term_id="part" text="parts" >}} under
 
 **Returns:**
 
-- ([List[RobotPart]](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.RobotPart)): The list of machine parts.
+- ([List[RobotPart]](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.RobotPart)): :   The list of machine parts.
 
 **Raises:**
 
@@ -2421,7 +2424,7 @@ Get a specific machine {{< glossary_tooltip term_id="part" text="part" >}} inclu
 
 **Returns:**
 
-- ([RobotPart](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.RobotPart)): The machine part.
+- ([RobotPart](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.RobotPart)): :   The machine part.
 
 **Raises:**
 
@@ -2438,7 +2441,7 @@ machine_part_config = my_robot_part.robot_config
 # Get the part's address
 address = my_robot_part.fqdn
 # Check if machine is live (last access time less than 10 sec ago)
-if (time.time() - my_robot_part.last_access.timestamp()) <= 10000:
+if (time.time() - my_robot_part.last_access.timestamp()) <= 10:
     print("Machine is live.")
 ```
 
@@ -2514,10 +2517,12 @@ Get the logs associated with a specific machine {{< glossary_tooltip term_id="pa
 - `dest` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): Optional filepath to write the log entries to.
 - `log_levels` (List[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]) (required): List of log levels for which entries should be returned. Defaults to empty list, which returns all logs.
 - `num_log_entries` ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (required): Number of log entries to return. Passing 0 returns all logs. Defaults to 100. All logs or the first num_log_entries logs will be returned, whichever comes first.
+- `start` ([datetime.datetime](https://docs.python.org/3/library/datetime.html)) (optional): Optional start time for log retrieval. Only logs created after this time will be returned.
+- `end` ([datetime.datetime](https://docs.python.org/3/library/datetime.html)) (optional): Optional end time for log retrieval. Only logs created before this time will be returned.
 
 **Returns:**
 
-- ([List[LogEntry]](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.LogEntry)): The list of log entries.
+- ([List[LogEntry]](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.LogEntry)): :   The list of log entries.
 
 **Raises:**
 
@@ -2584,6 +2589,10 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/a
 - `filter` (string) (optional): Optional string to filter logs on.
 - `levels` (string) (optional): Optional array of log levels to return. Defaults to returning
   all log levels.
+- `start` (Date) (optional): Optional start time for log retrieval. Only logs created after
+  this time will be returned.
+- `end` (Date) (optional): Optional end time for log retrieval. Only logs created before
+  this time will be returned.
 - `pageToken` (string) (optional): Optional string indicating which page of logs to query.
   Defaults to the most recent.
 
@@ -2650,7 +2659,7 @@ Get an asynchronous iterator that receives live machine part logs.
 
 **Returns:**
 
-- ([viam.app._logs._LogsStream[List[LogEntry]]](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.LogEntry)): The asynchronous iterator receiving live machine part logs.
+- ([viam.app._logs._LogsStream[List[LogEntry]]](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.LogEntry)): :   The asynchronous iterator receiving live machine part logs.
 
 **Example:**
 
@@ -2701,7 +2710,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/a
 - `id` (string) (required): The ID of the requested robot part.
 - `queue` ([LogEntry](https://ts.viam.dev/classes/commonApi.LogEntry.html)) (required): A queue to put the log entries into.
 - `filter` (string) (optional): Optional string to filter logs on.
-- `errorsOnly` (boolean) (optional): Optional bool to indicate whether or not only error\-level
+- `errorsOnly` (boolean) (optional): Optional bool to indicate whether or not only error-level
   logs should be returned. Defaults to true.
 
 **Returns:**
@@ -2734,7 +2743,7 @@ Get a list containing the history of a machine {{< glossary_tooltip term_id="par
 
 **Returns:**
 
-- ([List[RobotPartHistoryEntry]](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.RobotPartHistoryEntry)): The list of the machine part’s history.
+- ([List[RobotPartHistoryEntry]](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.RobotPartHistoryEntry)): :   The list of the machine part’s history.
 
 **Raises:**
 
@@ -2811,10 +2820,11 @@ You can only change the name and configuration of the machine part, not the loca
 - `name` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): New name to be updated on the robot part.
 - `robot_config` (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]) (optional): Optional new config represented as a dictionary to be updated on the machine part. The machine part’s config will remain as is (no change) if one isn’t passed.
 - `last_known_update` ([datetime.datetime](https://docs.python.org/3/library/datetime.html)) (optional): Optional time of the last known update to this part’s config. If provided, this will result in a GRPCError if the upstream config has changed since this time, indicating that the local config is out of date. Omitting this parameter will result in an overwrite of the upstream config.
+- `robot_config_json` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): Optional raw JSON string of the robot config, preserving user-defined key order. When set, this takes precedence over robot_config for storage purposes.
 
 **Returns:**
 
-- ([RobotPart](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.RobotPart)): The newly updated robot part.
+- ([RobotPart](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.RobotPart)): :   The newly updated robot part.
 
 **Raises:**
 
@@ -2912,7 +2922,7 @@ Create a new machine {{< glossary_tooltip term_id="part" text="part" >}}.
 
 **Returns:**
 
-- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): The new machine part’s ID.
+- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): :   The new machine part’s ID.
 
 **Raises:**
 
@@ -2963,7 +2973,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/a
 
 **Returns:**
 
-- (Promise<string>): The ID of the newly\-created robot part.
+- (Promise<string>): The ID of the newly-created robot part.
 
 **Example:**
 
@@ -3203,7 +3213,7 @@ Create a machine {{< glossary_tooltip term_id="part" text="part" >}} secret.
 
 **Returns:**
 
-- ([RobotPart](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.RobotPart)): The machine part the new secret was generated for.
+- ([RobotPart](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.RobotPart)): :   The machine part the new secret was generated for.
 
 **Raises:**
 
@@ -3358,7 +3368,7 @@ Get a list of all machines in a specified location.
 
 **Returns:**
 
-- ([List[viam.proto.app.Robot]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Robot)): The list of robots.
+- ([List[viam.proto.app.Robot]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Robot)): :   The list of robots.
 
 **Raises:**
 
@@ -3429,7 +3439,7 @@ Create a new {{< glossary_tooltip term_id="machine" text="machine" >}}.
 
 **Returns:**
 
-- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): The new robot’s ID.
+- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): :   The new robot’s ID.
 
 **Raises:**
 
@@ -3526,7 +3536,7 @@ Moving a machine has several important implications:
 
 **Returns:**
 
-- ([viam.proto.app.Robot](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Robot)): The newly updated machine.
+- ([viam.proto.app.Robot](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Robot)): :   The newly updated machine.
 
 **Raises:**
 
@@ -3578,7 +3588,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/a
 
 **Returns:**
 
-- (Promise<undefined | [appApi](https://ts.viam.dev/modules/appApi.html).[Robot](https://ts.viam.dev/classes/appApi.Robot.html)>): The newly\-modified robot object.
+- (Promise<undefined | [appApi](https://ts.viam.dev/modules/appApi.html).[Robot](https://ts.viam.dev/classes/appApi.Robot.html)>): The newly-modified robot object.
 
 **Example:**
 
@@ -3677,7 +3687,7 @@ Gets the user-defined metadata for a machine.
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]): The user\-defined metadata converted from JSON to a Python dictionary.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]): :   The user-defined metadata converted from JSON to a Python dictionary.
 
 **Example:**
 
@@ -3745,7 +3755,7 @@ Gets the user-defined metadata for a machine part.
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]): The user\-defined metadata converted from JSON to a Python dictionary.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]): :   The user-defined metadata converted from JSON to a Python dictionary.
 
 **Example:**
 
@@ -3975,7 +3985,7 @@ Get a list of {{< glossary_tooltip term_id="fragment" text="fragments" >}} in th
 
 **Returns:**
 
-- ([List[Fragment]](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.Fragment)): The list of fragments.
+- ([List[Fragment]](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.Fragment)): :   The list of fragments.
 
 **Example:**
 
@@ -4145,7 +4155,7 @@ Get a {{< glossary_tooltip term_id="fragment" text="fragment" >}} by ID.
 
 **Returns:**
 
-- ([Fragment](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.Fragment)): The fragment.
+- ([Fragment](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.Fragment)): :   The fragment.
 
 **Raises:**
 
@@ -4223,7 +4233,7 @@ Create a new private {{< glossary_tooltip term_id="fragment" text="fragment" >}}
 
 **Returns:**
 
-- ([Fragment](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.Fragment)): The newly created fragment.
+- ([Fragment](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.Fragment)): :   The newly created fragment.
 
 **Raises:**
 
@@ -4324,7 +4334,7 @@ Update a {{< glossary_tooltip term_id="fragment" text="fragment" >}} name and it
 
 **Returns:**
 
-- ([Fragment](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.Fragment)): The newly updated fragment.
+- ([Fragment](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.Fragment)): :   The newly updated fragment.
 
 **Raises:**
 
@@ -4499,7 +4509,7 @@ Get fragment history.
 
 **Returns:**
 
-- ([List[FragmentHistoryEntry]](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.FragmentHistoryEntry)): A list of documents with the fragment history.
+- ([List[FragmentHistoryEntry]](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.FragmentHistoryEntry)): :   A list of documents with the fragment history.
 
 **Raises:**
 
@@ -4839,7 +4849,7 @@ If no resource IDs are provided, all resource authorizations within the organiza
 
 **Returns:**
 
-- ([List[viam.proto.app.Authorization]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Authorization)): The list of authorizations.
+- ([List[viam.proto.app.Authorization]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Authorization)): :   The list of authorizations.
 
 **Raises:**
 
@@ -4912,7 +4922,7 @@ Check if the organization, location, or robot your `ViamClient` is authenticated
 
 **Returns:**
 
-- ([List[viam.proto.app.AuthorizedPermissions]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.AuthorizedPermissions)): The permissions argument, with invalid permissions filtered out.
+- ([List[viam.proto.app.AuthorizedPermissions]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.AuthorizedPermissions)): :   The permissions argument, with invalid permissions filtered out.
 
 **Raises:**
 
@@ -4989,7 +4999,7 @@ Valid arguments for permissions are as follows:
 
 {{% /expand %}}
 
-For more information about managing permissions, see [Role-Based Access Control](/manage/manage/rbac/).
+For more information about managing permissions, see [Role-Based Access Control](/organization/rbac/).
 
 For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/app/app_client/index.html#viam.app.app_client.AppClient.check_permissions).
 
@@ -5053,7 +5063,7 @@ Get metadata about a registry item (a module, training script, or ML model) by r
 
 **Returns:**
 
-- ([viam.proto.app.RegistryItem](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.RegistryItem)): The registry item.
+- ([viam.proto.app.RegistryItem](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.RegistryItem)): :   The registry item.
 
 **Example:**
 
@@ -5305,7 +5315,7 @@ List the registry items in an organization.
 
 **Returns:**
 
-- ([List[viam.proto.app.RegistryItem]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.RegistryItem)): The list of registry items.
+- ([List[viam.proto.app.RegistryItem]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.RegistryItem)): :   The list of registry items.
 
 **Example:**
 
@@ -5494,7 +5504,7 @@ Create a {{< glossary_tooltip term_id="module" text="module" >}} under the organ
 
 **Returns:**
 
-- (Tuple[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), [str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]): A tuple containing the ID \[0] of the new module and its URL \[1].
+- (Tuple[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), [str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]): :   A tuple containing the ID [0] of the new module and its URL [1].
 
 **Raises:**
 
@@ -5580,7 +5590,7 @@ Update the documentation URL, description, models, entrypoint, and/or the visibi
 
 **Returns:**
 
-- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): The URL of the newly updated module.
+- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): :   The URL of the newly updated module.
 
 **Raises:**
 
@@ -5698,12 +5708,12 @@ Upload a {{< glossary_tooltip term_id="module" text="module" >}} file.
 
 **Parameters:**
 
-- `module_file_info` ([viam.proto.app.ModuleFileInfo](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.ModuleFileInfo)) (optional): Relevant metadata.
+- `module_file_info` ([viam.proto.app.ModuleFileInfo](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.ModuleFileInfo)) (required): Relevant metadata.
 - `file` ([bytes](https://docs.python.org/3/library/stdtypes.html#bytes-objects)) (required): Bytes of file to upload.
 
 **Returns:**
 
-- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): URL of uploaded file.
+- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): :   URL of uploaded file.
 
 **Example:**
 
@@ -5767,7 +5777,7 @@ Get a {{< glossary_tooltip term_id="module" text="module" >}} by its ID.
 
 **Returns:**
 
-- ([viam.proto.app.Module](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Module)): The module.
+- ([viam.proto.app.Module](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Module)): :   The module.
 
 **Raises:**
 
@@ -5837,7 +5847,7 @@ List the {{< glossary_tooltip term_id="module" text="modules" >}} under the orga
 
 **Returns:**
 
-- ([List[viam.proto.app.Module]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Module)): The list of modules.
+- ([List[viam.proto.app.Module]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.Module)): :   The list of modules.
 
 **Example:**
 
@@ -5906,7 +5916,7 @@ Create a new [API key](/operate/control/api-keys/).
 
 **Returns:**
 
-- (Tuple[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), [str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]): The api key and api key ID.
+- (Tuple[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), [str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]): :   The api key and api key ID.
 
 **Raises:**
 
@@ -6046,7 +6056,7 @@ Rotate an [API key](/operate/control/api-keys/#rotate-an-api-key).
 
 **Returns:**
 
-- (Tuple[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), [str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]): The API key and API key id.
+- (Tuple[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), [str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]): :   The API key and API key id.
 
 **Example:**
 
@@ -6113,7 +6123,7 @@ List all keys for the {{< glossary_tooltip term_id="organization" text="organiza
 
 **Returns:**
 
-- ([List[viam.proto.app.APIKeyWithAuthorizations]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.APIKeyWithAuthorizations)): The existing API keys and authorizations.
+- ([List[viam.proto.app.APIKeyWithAuthorizations]](https://python.viam.dev/autoapi/viam/proto/app/index.html#viam.proto.app.APIKeyWithAuthorizations)): :   The existing API keys and authorizations.
 
 **Example:**
 
@@ -6209,7 +6219,7 @@ Create a new API key with an existing key’s authorizations.
 
 **Returns:**
 
-- (Tuple[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), [str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]): The API key and API key id.
+- (Tuple[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), [str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]): :   The API key and API key id.
 
 **Example:**
 
diff --git a/static/include/app/apis/generated/billing-table.md b/static/include/app/apis/generated/billing-table.md
index 36482a4699..f86fe73301 100644
--- a/static/include/app/apis/generated/billing-table.md
+++ b/static/include/app/apis/generated/billing-table.md
@@ -1,8 +1,9 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`GetCurrentMonthUsage`](/dev/reference/apis/billing-client/#getcurrentmonthusage) | Access data usage information for the current billing period for a given organization. |
-| [`GetOrgBillingInformation`](/dev/reference/apis/billing-client/#getorgbillinginformation) | Access billing information (payment method, billing tier, etc.) for a given org. |
-| [`GetInvoicesSummary`](/dev/reference/apis/billing-client/#getinvoicessummary) | Access total outstanding balance plus invoice summaries for a given organization. |
-| [`GetInvoicePDF`](/dev/reference/apis/billing-client/#getinvoicepdf) | Access invoice PDF data and optionally save it to a provided file path. |
-| [`CreateInvoiceAndChargeImmediately`](/dev/reference/apis/billing-client/#createinvoiceandchargeimmediately) | Create a flat fee invoice and charge the organization immediately. The caller must be an owner of the organization being charged. This function blocks until payment is confirmed, but will time out after 2 minutes if there is no confirmation. |
+| [`GetCurrentMonthUsage`](/reference/apis/billing-client/#getcurrentmonthusage) | Access data usage information for the current billing period for a given organization. |
+| [`GetOrgBillingInformation`](/reference/apis/billing-client/#getorgbillinginformation) | Access billing information (payment method, billing tier, etc.) for a given org. |
+| [`GetInvoicesSummary`](/reference/apis/billing-client/#getinvoicessummary) | Access total outstanding balance plus invoice summaries for a given organization. |
+| [`GetInvoicePDF`](/reference/apis/billing-client/#getinvoicepdf) | Access invoice PDF data and optionally save it to a provided file path. |
+| [`CreateInvoiceAndChargeImmediately`](/reference/apis/billing-client/#createinvoiceandchargeimmediately) | Create a flat fee invoice and charge the organization immediately. The caller must be an owner of the organization being charged. This function blocks until payment is confirmed, but will time out after 2 minutes if there is no confirmation. |
+| [`ChargeOrganization`](/reference/apis/billing-client/#chargeorganization) | Charge an organization for usage. |
diff --git a/static/include/app/apis/generated/billing.md b/static/include/app/apis/generated/billing.md
index fead9c81ca..d5efbc9ab0 100644
--- a/static/include/app/apis/generated/billing.md
+++ b/static/include/app/apis/generated/billing.md
@@ -2,7 +2,7 @@
 
 Access data usage information for the current billing period for a given organization.
 This method only returns usage for organizations with monthly billing at the end of the month (`"in_arrears": true`).
-You can also find your usage data on the [**Payment and billing** page](/manage/reference/billing/).
+You can also find your usage data on the [**Payment and billing** page](/organization/billing/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -14,12 +14,12 @@ You can also find your usage data on the [**Payment and billing** page](/manage/
 
 **Returns:**
 
-- ([viam.proto.app.billing.GetCurrentMonthUsageResponse](https://python.viam.dev/autoapi/viam/proto/app/billing/index.html#viam.proto.app.billing.GetCurrentMonthUsageResponse)): the current month usage information.
+- ([viam.proto.app.billing.GetCurrentMonthUsageResponse](https://python.viam.dev/autoapi/viam/proto/app/billing/index.html#viam.proto.app.billing.GetCurrentMonthUsageResponse)): :   the current month usage information.
 
 **Example:**
 
 ```python {class="line-numbers linkable-line-numbers"}
-usage = await billing_client.get_current_month_usage("<ORG-ID>")
+usage = await billing_client.get_current_month_usage(<ORG-ID>)
 ```
 
 For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/app/billing_client/index.html#viam.app.billing_client.BillingClient.get_current_month_usage).
@@ -64,19 +64,19 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 ### GetOrgBillingInformation
 
 Access billing information (payment method, billing tier, etc.) for a given org.
-You can also find this information on the [**Payment and billing** page](/manage/reference/billing/).
+You can also find this information on the [**Payment and billing** page](/organization/billing/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
 
 **Parameters:**
 
-- `org_id` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): the ID of the org to request data for.
+- `org_id` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): the ID of the organization to request data for.
 - `timeout` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (optional): An option to set how long to wait (in seconds) before calling a time-out and closing the underlying RPC call.
 
 **Returns:**
 
-- ([viam.proto.app.billing.GetOrgBillingInformationResponse](https://python.viam.dev/autoapi/viam/proto/app/billing/index.html#viam.proto.app.billing.GetOrgBillingInformationResponse)): the org billing information.
+- ([viam.proto.app.billing.GetOrgBillingInformationResponse](https://python.viam.dev/autoapi/viam/proto/app/billing/index.html#viam.proto.app.billing.GetOrgBillingInformationResponse)): :   the organization billing information.
 
 **Example:**
 
@@ -135,17 +135,17 @@ This includes both monthly and annual invoices depending on the organization's b
 
 **Parameters:**
 
-- `org_id` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): the ID of the org to request data for.
+- `org_id` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): the ID of the organization to request data for.
 - `timeout` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (optional): An option to set how long to wait (in seconds) before calling a time-out and closing the underlying RPC call.
 
 **Returns:**
 
-- ([viam.proto.app.billing.GetInvoicesSummaryResponse](https://python.viam.dev/autoapi/viam/proto/app/billing/index.html#viam.proto.app.billing.GetInvoicesSummaryResponse)): the summaries of all org invoices.
+- ([viam.proto.app.billing.GetInvoicesSummaryResponse](https://python.viam.dev/autoapi/viam/proto/app/billing/index.html#viam.proto.app.billing.GetInvoicesSummaryResponse)): :   the summaries of all organization invoices.
 
 **Example:**
 
 ```python {class="line-numbers linkable-line-numbers"}
-summary = await billing_client.get_invoices_summary("<ORG-ID>")
+summary = await billing_client.get_invoices_summary(<ORG-ID>)
 ```
 
 For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/app/billing_client/index.html#viam.app.billing_client.BillingClient.get_invoices_summary).
@@ -193,7 +193,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 ### GetInvoicePDF
 
 Access invoice PDF data and optionally save it to a provided file path.
-You can also find your invoices on the [**Payment and billing** page](/manage/reference/billing/).
+You can also find your invoices on the [**Payment and billing** page](/organization/billing/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -201,7 +201,7 @@ You can also find your invoices on the [**Payment and billing** page](/manage/re
 **Parameters:**
 
 - `invoice_id` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): the ID of the invoice being requested.
-- `org_id` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): the ID of the org to request data from.
+- `org_id` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): the ID of the organization to request data from.
 - `dest` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): the filepath to save the invoice to.
 - `timeout` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (optional): An option to set how long to wait (in seconds) before calling a time-out and closing the underlying RPC call.
 
@@ -212,7 +212,7 @@ You can also find your invoices on the [**Payment and billing** page](/manage/re
 **Example:**
 
 ```python {class="line-numbers linkable-line-numbers"}
-await billing_client.get_invoice_pdf("<INVOICE-ID>", "<ORG-ID>", "invoice.pdf")
+await billing_client.get_invoice_pdf(<INVOICE-ID>, <ORG-ID>, "invoice.pdf")
 ```
 
 For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/app/billing_client/index.html#viam.app.billing_client.BillingClient.get_invoice_pdf).
@@ -268,29 +268,54 @@ Create a flat fee invoice and charge the organization immediately. The caller mu
 
 **Parameters:**
 
+- `org_id_to_charge` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required)
+- `amount` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (required)
+- `description` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional)
+- `org_id_for_branding` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional)
+- `disable_email` ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)) (required)
+
+**Returns:**
+
+- ([viam.proto.app.billing.CreateInvoiceAndChargeImmediatelyResponse](https://python.viam.dev/autoapi/viam/proto/app/billing/index.html#viam.proto.app.billing.CreateInvoiceAndChargeImmediatelyResponse))
+
+For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/app/billing_client/index.html#viam.app.billing_client.BillingClient.create_invoice_and_charge_immediately).
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### ChargeOrganization
+
+Charge an organization for usage.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+**Parameters:**
+
 - `org_id_to_charge` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): the organization to charge.
-- `amount` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (required): the amount to charge in dollars.
-- `description` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): a short description of the charge to display on the invoice PDF (must be 100 characters or less).
-- `org_id_for_branding` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): the organization whose branding to use in the invoice confirmation email.
-- `disable_email` ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)) (required): whether or not to disable sending an email confirmation for the invoice.
+- `subtotal` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (required): the subtotal amount in dollars.
+- `tax` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (required): the tax amount in dollars to add to the subtotal.
+- `description` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): a short description of the charge to display on the invoice PDF (must be 1000 characters or less).
+- `org_id_for_branding` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): the organization whose branding to use in the invoice PDF and confirmation email.
+- `disable_confirmation_email` ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)) (required): whether or not to disable sending an email confirmation for the invoice.
 
 **Returns:**
 
-- ([viam.proto.app.billing.CreateInvoiceAndChargeImmediatelyResponse](https://python.viam.dev/autoapi/viam/proto/app/billing/index.html#viam.proto.app.billing.CreateInvoiceAndChargeImmediatelyResponse)): the invoice id.
+- ([viam.proto.app.billing.ChargeOrganizationResponse](https://python.viam.dev/autoapi/viam/proto/app/billing/index.html#viam.proto.app.billing.ChargeOrganizationResponse)): :   the invoice id.
 
 **Example:**
 
 ```python {class="line-numbers linkable-line-numbers"}
-invoice_id = await billing_client.create_invoice_and_charge_immediately(
-    "<ORG-ID-TO-CHARGE>",
-    <AMOUNT>,
-    <DESCRIPTION>,
-    "<ORG-ID-FOR-BRANDING>",
-    False,
+invoice_id = await billing_client.charge_organization(
+    <ORG-ID-TO-CHARGE>,
+    9.99,
+    0.70,
+    "A charge with tax.",
+    <ORG-ID-FOR-BRANDING>,
+    True,
 )
 ```
 
-For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/app/billing_client/index.html#viam.app.billing_client.BillingClient.create_invoice_and_charge_immediately).
+For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/app/billing_client/index.html#viam.app.billing_client.BillingClient.charge_organization).
 
 {{% /tab %}}
 {{< /tabs >}}
diff --git a/static/include/app/apis/generated/data-table.md b/static/include/app/apis/generated/data-table.md
index b329d4ee91..f001aba0d2 100644
--- a/static/include/app/apis/generated/data-table.md
+++ b/static/include/app/apis/generated/data-table.md
@@ -1,29 +1,36 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`GetLatestTabularData`](/dev/reference/apis/data-client/#getlatesttabulardata) | Gets the most recent tabular data captured from the specified data source, as long as it was synced within the last year. |
-| [`ExportTabularData`](/dev/reference/apis/data-client/#exporttabulardata) | Obtain unified tabular data and metadata from the specified data source. |
-| [`TabularDataByFilter`](/dev/reference/apis/data-client/#tabulardatabyfilter) | Retrieve optionally filtered tabular data from Viam. |
-| [`TabularDataBySQL`](/dev/reference/apis/data-client/#tabulardatabysql) | Obtain unified tabular data and metadata, queried with SQL. Make sure your API key has permissions at the organization level in order to use this. |
-| [`TabularDataByMQL`](/dev/reference/apis/data-client/#tabulardatabymql) | Obtain unified tabular data and metadata, queried with MQL. |
-| [`BinaryDataByFilter`](/dev/reference/apis/data-client/#binarydatabyfilter) | Retrieve optionally filtered binary data from Viam. |
-| [`BinaryDataByIDs`](/dev/reference/apis/data-client/#binarydatabyids) | Retrieve binary data from Viam by `BinaryID`. |
-| [`DeleteTabularData`](/dev/reference/apis/data-client/#deletetabulardata) | Delete tabular data older than a specified number of days. |
-| [`DeleteBinaryDataByFilter`](/dev/reference/apis/data-client/#deletebinarydatabyfilter) | Filter and delete binary data. |
-| [`DeleteBinaryDataByIDs`](/dev/reference/apis/data-client/#deletebinarydatabyids) | Filter and delete binary data by ids. |
-| [`AddTagsToBinaryDataByIDs`](/dev/reference/apis/data-client/#addtagstobinarydatabyids) | Add tags to binary data by ids. |
-| [`RemoveTagsFromBinaryDataByIDs`](/dev/reference/apis/data-client/#removetagsfrombinarydatabyids) | Remove tags from binary by ids. |
-| [`TagsByFilter`](/dev/reference/apis/data-client/#tagsbyfilter) | Get a list of tags using a filter. |
-| [`AddBoundingBoxToImageByID`](/dev/reference/apis/data-client/#addboundingboxtoimagebyid) | Add a bounding box to an image specified by its BinaryID. |
-| [`RemoveBoundingBoxFromImageByID`](/dev/reference/apis/data-client/#removeboundingboxfromimagebyid) | Removes a bounding box from an image specified by its BinaryID. |
-| [`BoundingBoxLabelsByFilter`](/dev/reference/apis/data-client/#boundingboxlabelsbyfilter) | Get a list of bounding box labels using a Filter. |
-| [`GetDatabaseConnection`](/dev/reference/apis/data-client/#getdatabaseconnection) | Get a connection to access a MongoDB Atlas Data federation instance. |
-| [`ConfigureDatabaseUser`](/dev/reference/apis/data-client/#configuredatabaseuser) | Configure a database user for the Viam organization’s MongoDB Atlas Data Federation instance. |
-| [`AddBinaryDataToDatasetByIDs`](/dev/reference/apis/data-client/#addbinarydatatodatasetbyids) | Add the `BinaryData` to the provided dataset. |
-| [`RemoveBinaryDataFromDatasetByIDs`](/dev/reference/apis/data-client/#removebinarydatafromdatasetbyids) | Remove the BinaryData from the provided dataset. |
-| [`GetDataPipeline`](/dev/reference/apis/data-client/#getdatapipeline) | Get the configuration for a data pipeline. |
-| [`ListDataPipelines`](/dev/reference/apis/data-client/#listdatapipelines) | List all of the data pipelines in an organization. |
-| [`CreateDataPipeline`](/dev/reference/apis/data-client/#createdatapipeline) | Create a data pipeline. |
-| [`DeleteDataPipeline`](/dev/reference/apis/data-client/#deletedatapipeline) | Delete a data pipeline, its execution history, and all of its output data. |
-| [`ListDataPipelineRuns`](/dev/reference/apis/data-client/#listdatapipelineruns) | Get information about individual executions of a data pipeline. |
-| [`RenameDataPipeline`](/dev/reference/apis/data-client/#renamedatapipeline) | Rename a data pipeline. |
+| [`GetLatestTabularData`](/reference/apis/data-client/#getlatesttabulardata) | Gets the most recent tabular data captured from the specified data source, as long as it was synced within the last year. |
+| [`ExportTabularData`](/reference/apis/data-client/#exporttabulardata) | Obtain unified tabular data and metadata from the specified data source. |
+| [`TabularDataByFilter`](/reference/apis/data-client/#tabulardatabyfilter) | Retrieve optionally filtered tabular data from Viam. |
+| [`TabularDataBySQL`](/reference/apis/data-client/#tabulardatabysql) | Obtain unified tabular data and metadata, queried with SQL. Make sure your API key has permissions at the organization level in order to use this. |
+| [`TabularDataByMQL`](/reference/apis/data-client/#tabulardatabymql) | Obtain unified tabular data and metadata, queried with MQL. |
+| [`BinaryDataByFilter`](/reference/apis/data-client/#binarydatabyfilter) | Retrieve optionally filtered binary data from Viam. |
+| [`BinaryDataByIDs`](/reference/apis/data-client/#binarydatabyids) | Retrieve binary data from Viam by `BinaryID`. |
+| [`DeleteTabularData`](/reference/apis/data-client/#deletetabulardata) | Delete tabular data older than a specified number of days. |
+| [`DeleteBinaryDataByFilter`](/reference/apis/data-client/#deletebinarydatabyfilter) | Filter and delete binary data. |
+| [`DeleteBinaryDataByIDs`](/reference/apis/data-client/#deletebinarydatabyids) | Filter and delete binary data by ids. |
+| [`AddTagsToBinaryDataByIDs`](/reference/apis/data-client/#addtagstobinarydatabyids) | Add tags to binary data by ids. |
+| [`RemoveTagsFromBinaryDataByIDs`](/reference/apis/data-client/#removetagsfrombinarydatabyids) | Remove tags from binary by ids. |
+| [`TagsByFilter`](/reference/apis/data-client/#tagsbyfilter) | Get a list of tags using a filter. |
+| [`AddBoundingBoxToImageByID`](/reference/apis/data-client/#addboundingboxtoimagebyid) | Add a bounding box to an image specified by its BinaryID. |
+| [`RemoveBoundingBoxFromImageByID`](/reference/apis/data-client/#removeboundingboxfromimagebyid) | Removes a bounding box from an image specified by its BinaryID. |
+| [`BoundingBoxLabelsByFilter`](/reference/apis/data-client/#boundingboxlabelsbyfilter) | Get a list of bounding box labels using a Filter. |
+| [`GetDatabaseConnection`](/reference/apis/data-client/#getdatabaseconnection) | Get a connection to access a MongoDB Atlas Data federation instance. |
+| [`ConfigureDatabaseUser`](/reference/apis/data-client/#configuredatabaseuser) | Configure a database user for the Viam organization’s MongoDB Atlas Data Federation instance. |
+| [`AddBinaryDataToDatasetByIDs`](/reference/apis/data-client/#addbinarydatatodatasetbyids) | Add the `BinaryData` to the provided dataset. |
+| [`RemoveBinaryDataFromDatasetByIDs`](/reference/apis/data-client/#removebinarydatafromdatasetbyids) | Remove the BinaryData from the provided dataset. |
+| [`GetDataPipeline`](/reference/apis/data-client/#getdatapipeline) | Get the configuration for a data pipeline. |
+| [`ListDataPipelines`](/reference/apis/data-client/#listdatapipelines) | List all of the data pipelines in an organization. |
+| [`CreateDataPipeline`](/reference/apis/data-client/#createdatapipeline) | Create a data pipeline. |
+| [`DeleteDataPipeline`](/reference/apis/data-client/#deletedatapipeline) | Delete a data pipeline, its execution history, and all of its output data. |
+| [`ListDataPipelineRuns`](/reference/apis/data-client/#listdatapipelineruns) | Get information about individual executions of a data pipeline. |
+| [`RenameDataPipeline`](/reference/apis/data-client/#renamedatapipeline) | Rename a data pipeline. |
+| [`AddTagsToBinaryDataByFilter`](/reference/apis/data-client/#addtagstobinarydatabyfilter) | Add tags to binary data by filter. |
+| [`CreateBinaryDataSignedURL`](/reference/apis/data-client/#createbinarydatasignedurl) | Create a signed URL for accessing binary data without authentication. The URL expires after the specified duration. |
+| [`CreateIndex`](/reference/apis/data-client/#createindex) | Create a custom index on your data to speed up queries. You specify the organization, the collection type (tabular or binary), and the fields to index. |
+| [`DeleteIndex`](/reference/apis/data-client/#deleteindex) | Delete a custom index from your data. |
+| [`ListIndexes`](/reference/apis/data-client/#listindexes) | List all custom indexes for an organization. |
+| [`RemoveTagsFromBinaryDataByFilter`](/reference/apis/data-client/#removetagsfrombinarydatabyfilter) | Remove tags from binary data by filter. |
+| [`UpdateBoundingBox`](/reference/apis/data-client/#updateboundingbox) | Update an existing bounding box on an image. You can change the label, position, or dimensions of the bounding box. |
diff --git a/static/include/app/apis/generated/data.md b/static/include/app/apis/generated/data.md
index 2ccc189f3d..a9a6497c90 100644
--- a/static/include/app/apis/generated/data.md
+++ b/static/include/app/apis/generated/data.md
@@ -15,13 +15,12 @@ Gets the most recent tabular data captured from the specified data source, as lo
 
 **Returns:**
 
-- (Tuple[[datetime.datetime](https://docs.python.org/3/library/datetime.html), [datetime.datetime](https://docs.python.org/3/library/datetime.html), Dict[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]] | None): A return value of `None` means that this data source
-has not synced data in the last year. Otherwise, the data source has synced some data in the last year, so the returned
-tuple contains the following:
-
-    * `time_captured` (*datetime*): The time captured.
-    * `time_synced` (*datetime*): The time synced.
-    * `payload` (*Dict\[str, ValueTypes]*): The latest tabular data captured from the specified data source.
+- (Tuple[[datetime.datetime](https://docs.python.org/3/library/datetime.html), [datetime.datetime](https://docs.python.org/3/library/datetime.html), Dict[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]] | None): :   A return value of `None` means that this data source
+    has not synced data in the last year. Otherwise, the data source has synced some data in the last year, so the returned
+    tuple contains the following:
+        * `time_captured` (*datetime*): The time captured.
+        * `time_synced` (*datetime*): The time synced.
+        * `payload` (*Dict[str, ValueTypes]*): The latest tabular data captured from the specified data source.
 
 **Example:**
 
@@ -71,7 +70,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/a
 
 - `partId` (string) (required): The ID of the part that owns the data.
 - `resourceName` (string) (required): The name of the requested resource that captured the
-  data. Ex: "my\-sensor".
+  data. Ex: "my-sensor".
 - `resourceSubtype` (string) (required): The subtype of the requested resource that captured
   the data. Ex: "rdk:component:sensor".
 - `methodName` (string) (required): The data capture method name. Ex: "Readings".
@@ -79,7 +78,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/a
 
 **Returns:**
 
-- (Promise<null | [Date, Date, Record<string, [JsonValue](https://ts.viam.dev/types/JsonValue.html)>]>): A tuple containing \[timeCaptured, timeSynced, payload] or null if
+- (Promise<null | [Date, Date, Record<string, [JsonValue](https://ts.viam.dev/types/JsonValue.html)>]>): A tuple containing [timeCaptured, timeSynced, payload] or null if
 no data has been synced for the specified resource OR the most recently
 captured data was over a year ago.
 
@@ -105,11 +104,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 - `resourceName` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
 - `resourceSubtype` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
 - `methodName` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
-- `additionalParams` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (required)
+- `additionalParams` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<({[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> payload, [DateTime](https://api.flutter.dev/flutter/dart-core/DateTime-class.html) timeCaptured, [DateTime](https://api.flutter.dev/flutter/dart-core/DateTime-class.html) timeSynced})?\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<({[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> payload, [DateTime](https://api.flutter.dev/flutter/dart-core/DateTime-class.html) timeCaptured, [DateTime](https://api.flutter.dev/flutter/dart-core/DateTime-class.html) timeSynced})?>
 
 **Example:**
 
@@ -158,7 +157,7 @@ Obtain unified tabular data and metadata from the specified data source.
 
 **Returns:**
 
-- ([List[TabularDataPoint]](https://python.viam.dev/autoapi/viam/app/data_client/index.html#viam.app.data_client.DataClient.TabularDataPoint)): The unified tabular data and metadata.
+- ([List[TabularDataPoint]](https://python.viam.dev/autoapi/viam/app/data_client/index.html#viam.app.data_client.DataClient.TabularDataPoint)): :   The unified tabular data and metadata.
 
 **Example:**
 
@@ -245,11 +244,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 - `methodName` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
 - `startTime` [DateTime](https://api.flutter.dev/flutter/dart-core/DateTime-class.html)? (required)
 - `endTime` [DateTime](https://api.flutter.dev/flutter/dart-core/DateTime-class.html)? (required)
-- `additionalParams` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (required)
+- `additionalParams` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[TabularDataPoint](https://flutter.viam.dev/viam_sdk/TabularDataPoint-class.html)\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[TabularDataPoint](https://flutter.viam.dev/viam_sdk/TabularDataPoint-class.html)>\>
 
 **Example:**
 
@@ -311,11 +310,10 @@ You can also find your tabular data under the **Sensors** subtab of the [**Data*
 
 **Returns:**
 
-- (Tuple[List[TabularData], [int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex), [str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]): A tuple containing the following:
-
-    * `tabular_data` (*List\[TabularData]*): The tabular data.
-    * `count` (*int*): The count (number of entries).
-    * `last` (*str*): The last\-returned page ID.
+- (Tuple[List[TabularData], [int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex), [str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]): :   A tuple containing the following:
+        * `tabular_data` (*List[TabularData]*): The tabular data.
+        * `count` (*int*): The count (number of entries).
+        * `last` (*str*): The last-returned page ID.
 
 **Example:**
 
@@ -361,18 +359,18 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/a
 - `limit` (number) (optional): The maximum number of entries to include in a page. Defaults
   to 50 if unspecfied.
 - `sortOrder` ([Order](https://ts.viam.dev/enums/dataApi.Order.html)) (optional): The desired sort order of the data.
-- `last` (string) (optional): Optional string indicating the ID of the last\-returned data. If
+- `last` (string) (optional): Optional string indicating the ID of the last-returned data. If
   provided, the server will return the next data entries after the `last`
   ID.
 - `countOnly` (boolean) (optional): Whether to return only the total count of entries.
 - `includeInternalData` (boolean) (optional): Whether to retun internal data. Internal data is
-  used for Viam\-specific data ingestion, like cloud SLAM. Defaults to
+  used for Viam-specific data ingestion, like cloud SLAM. Defaults to
   `false`.
 
 **Returns:**
 
 - (Promise<{ count: bigint; data: TabularData[]; last: string }>): An array of data objects, the count (number of entries), and the
-last\-returned page ID.
+last-returned page ID.
 
 **Example:**
 
@@ -401,7 +399,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[TabularDataByFilterResponse](https://flutter.viam.dev/viam_protos.app.data/TabularDataByFilterResponse-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[TabularDataByFilterResponse](https://flutter.viam.dev/viam_protos.app.data/TabularDataByFilterResponse-class.html)>
 
 **Example:**
 
@@ -456,7 +454,7 @@ Obtain unified tabular data and metadata, queried with SQL. Make sure your API k
 
 **Returns:**
 
-- (List[Dict[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes | [datetime.datetime](https://docs.python.org/3/library/datetime.html)]]): An array of decoded BSON data objects.
+- (List[Dict[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes | [datetime.datetime](https://docs.python.org/3/library/datetime.html)]]): :   An array of decoded BSON data objects.
 
 **Example:**
 
@@ -518,7 +516,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>>
 
 **Example:**
 
@@ -563,7 +561,7 @@ Obtain unified tabular data and metadata, queried with MQL.
 
 **Returns:**
 
-- (List[Dict[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes | [datetime.datetime](https://docs.python.org/3/library/datetime.html)]]): An array of decoded BSON data objects.
+- (List[Dict[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes | [datetime.datetime](https://docs.python.org/3/library/datetime.html)]]): :   An array of decoded BSON data objects.
 
 **Example:**
 
@@ -605,7 +603,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/a
 - `organizationId` (string) (required): The ID of the organization that owns the data.
 - `query` (Uint8Array) (required): The MQL query to run as a list of BSON documents.
 - `useRecentData` (boolean) (optional): Whether to query blob storage or your recent data
-  store. Defaults to false. Deprecated \- use dataSource instead.
+  store. Defaults to false. Deprecated - use dataSource instead.
 - `tabularDataSource` ([TabularDataSource](https://ts.viam.dev/classes/dataApi.TabularDataSource.html)) (optional)
 - `queryPrefixName` (string) (optional): Optional name of the query prefix.
 
@@ -648,7 +646,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>>
 
 **Example:**
 
@@ -708,11 +706,10 @@ You can also find your binary data under the **Images**, **Point clouds**, or **
 
 **Returns:**
 
-- (Tuple[List[viam.proto.app.data.BinaryData], [int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex), [str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]): A tuple containing the following:
-
-    * `data` (*List\[* [`BinaryData`](https://python.viam.dev/autoapi/viam/proto/app/data/index.html#viam.proto.app.data.BinaryData "viam.proto.app.data.BinaryData") *]*): The binary data.
-    * `count` (*int*): The count (number of entries).
-    * `last` (*str*): The last\-returned page ID.
+- (Tuple[List[viam.proto.app.data.BinaryData], [int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex), [str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]): :   A tuple containing the following:
+        * `data` (*List[* [`BinaryData`](https://python.viam.dev/autoapi/viam/proto/app/data/index.html#viam.proto.app.data.BinaryData "viam.proto.app.data.BinaryData") *]*): The binary data.
+        * `count` (*int*): The count (number of entries).
+        * `last` (*str*): The last-returned page ID.
 
 **Example:**
 
@@ -780,20 +777,20 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/a
 - `limit` (number) (optional): The maximum number of entries to include in a page. Defaults
   to 50 if unspecfied.
 - `sortOrder` ([Order](https://ts.viam.dev/enums/dataApi.Order.html)) (optional): The desired sort order of the data.
-- `last` (string) (optional): Optional string indicating the ID of the last\-returned data. If
+- `last` (string) (optional): Optional string indicating the ID of the last-returned data. If
   provided, the server will return the next data entries after the `last`
   ID.
 - `includeBinary` (boolean) (optional): Whether to include binary file data with each
   retrieved file.
 - `countOnly` (boolean) (optional): Whether to return only the total count of entries.
 - `includeInternalData` (boolean) (optional): Whether to retun internal data. Internal data is
-  used for Viam\-specific data ingestion, like cloud SLAM. Defaults to
+  used for Viam-specific data ingestion, like cloud SLAM. Defaults to
   `false`.
 
 **Returns:**
 
 - (Promise<{ count: bigint; data: [BinaryData](https://ts.viam.dev/classes/dataApi.BinaryData.html)[]; last: string }>): An array of data objects, the count (number of entries), and the
-last\-returned page ID.
+last-returned page ID.
 
 **Example:**
 
@@ -823,7 +820,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[BinaryDataByFilterResponse](https://flutter.viam.dev/viam_protos.app.data/BinaryDataByFilterResponse-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[BinaryDataByFilterResponse](https://flutter.viam.dev/viam_protos.app.data/BinaryDataByFilterResponse-class.html)>
 
 **Example:**
 
@@ -871,11 +868,12 @@ You can also find your binary data under the **Images**, **Point clouds**, or **
 **Parameters:**
 
 - `binary_ids` ([List[viam.proto.app.data.BinaryID] | List[str]](https://python.viam.dev/autoapi/viam/proto/app/data/index.html#viam.proto.app.data.BinaryID)) (required): Binary data ID strings specifying the desired data or BinaryID objects. Must be non-empty. DEPRECATED: BinaryID is deprecated and will be removed in a future release. Instead, pass binary data IDs as a list of strings.
+- `include_binary_data` ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)) (required): Boolean specifying whether to actually include the binary file data with each retrieved file. Defaults to true (that is, both the files’ data and metadata are returned).
 - `dest` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): Optional filepath for writing retrieved data.
 
 **Returns:**
 
-- ([List[viam.proto.app.data.BinaryData]](https://python.viam.dev/autoapi/viam/proto/app/data/index.html#viam.proto.app.data.BinaryData)): The binary data.
+- ([List[viam.proto.app.data.BinaryData]](https://python.viam.dev/autoapi/viam/proto/app/data/index.html#viam.proto.app.data.BinaryData)): :   The binary data.
 
 **Raises:**
 
@@ -905,6 +903,7 @@ For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/
 
 - `ctx` [(Context)](https://pkg.go.dev/context#Context): A Context carries a deadline, a cancellation signal, and other values across API boundaries.
 - `binaryDataIDs` [([]string)](https://pkg.go.dev/builtin#string)
+- `opts` [(...*BinaryDataByIDsOptions)](https://pkg.go.dev/go.viam.com/rdk/app#BinaryDataByIDsOptions)
 
 **Returns:**
 
@@ -919,6 +918,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/a
 **Parameters:**
 
 - `ids` (string) (required): The IDs of the requested binary data.
+- `includeBinary` (boolean) (optional): Whether to include binary file data with each
+  retrieved file.
 
 **Returns:**
 
@@ -939,12 +940,12 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `binaryIds` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[BinaryID](https://flutter.viam.dev/viam_protos.app.data/BinaryID-class.html)\> (required)
+- `binaryIds` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[BinaryID](https://flutter.viam.dev/viam_protos.app.data/BinaryID-class.html)> (required)
 - `includeBinary` [bool](https://api.flutter.dev/flutter/dart-core/bool-class.html) (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[BinaryDataByIDsResponse](https://flutter.viam.dev/viam_protos.app.data/BinaryDataByIDsResponse-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[BinaryDataByIDsResponse](https://flutter.viam.dev/viam_protos.app.data/BinaryDataByIDsResponse-class.html)>
 
 **Example:**
 
@@ -985,6 +986,7 @@ For more information, see the [Flutter SDK Docs](https://flutter.viam.dev/viam_s
 ### DeleteTabularData
 
 Delete tabular data older than a specified number of days.
+If the organization has a [hot data store](/data/hot-data-store/), matching data is deleted from that store as well.
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -992,11 +994,12 @@ Delete tabular data older than a specified number of days.
 **Parameters:**
 
 - `organization_id` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): The ID of the organization to delete the data from. To find your organization ID, visit the organization settings page.
-- `delete_older_than_days` ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (required): Delete data that was captured up to this many days ago. For example, a value of 10 deletes any data that was captured up to 10 days ago. A value of 0 deletes all existing data.
+- `delete_older_than_days` ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (required): Delete data that was captured more than this many days ago. For example, a value of 10 deletes any data that was captured more than 10 days ago. A value of 0 deletes all existing data.
+- `filter` ([viam.proto.app.data.DeleteTabularFilter](https://python.viam.dev/autoapi/viam/proto/app/data/index.html#viam.proto.app.data.DeleteTabularFilter)) (optional): Optional filter to further constrain which data is deleted. If provided, only data matching the filter will be deleted. If omitted, data is deleted based on organization_id and delete_older_than_days.
 
 **Returns:**
 
-- ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): The number of items deleted.
+- ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): :   The number of items deleted.
 
 **Example:**
 
@@ -1005,6 +1008,17 @@ tabular_data = await data_client.delete_tabular_data(
     organization_id="<YOUR-ORG-ID>",
     delete_older_than_days=150
 )
+
+# Delete with additional filter constraints
+from viam.proto.app.data import DeleteTabularFilter
+tabular_data = await data_client.delete_tabular_data(
+    organization_id="<YOUR-ORG-ID>",
+    delete_older_than_days=150,
+    filter=DeleteTabularFilter(
+        location_ids=["location-id"],
+        component_name="camera"
+    )
+)
 ```
 
 For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/app/data_client/index.html#viam.app.data_client.DataClient.delete_tabular_data).
@@ -1017,6 +1031,7 @@ For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/
 - `ctx` [(Context)](https://pkg.go.dev/context#Context): A Context carries a deadline, a cancellation signal, and other values across API boundaries.
 - `organizationID` [(string)](https://pkg.go.dev/builtin#string)
 - `deleteOlderThanDays` [(int)](https://pkg.go.dev/builtin#int)
+- `filter` [(*pb.DeleteTabularFilter)](https://pkg.go.dev/go.viam.com/api/app/data/v1#DeleteTabularFilter)
 
 **Returns:**
 
@@ -1032,9 +1047,11 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/a
 
 - `organizationId` (string) (required): The ID of organization to delete data from.
 - `deleteOlderThanDays` (number) (required): Delete data that was captured more than this
-  many days ago. For example if `deleteOlderThanDays` is 10, this deletes
-  any data that was captured more than 10 days ago. If it is 0, all
-  existing data is deleted.
+  many days ago. For example, a value of 10 deletes any data that was
+  captured more than 10 days ago. A value of 0 deletes all existing data.
+- `filter` (PartialMessage) (optional): Optional filter to further constrain which data is deleted.
+  If provided, only data matching the filter will be deleted. If omitted,
+  data is deleted based on organization\_id and delete\_older\_than\_days.
 
 **Returns:**
 
@@ -1047,6 +1064,16 @@ const data = await dataClient.deleteTabularData(
   '123abc45-1234-5678-90ab-cdef12345678',
   10
 );
+
+// Delete with additional filter constraints
+const data = await dataClient.deleteTabularData(
+  '123abc45-1234-5678-90ab-cdef12345678',
+  10,
+  {
+    locationIds: ['location-id'],
+    componentName: 'camera',
+  }
+);
 ```
 
 For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/DataClient.html#deletetabulardata).
@@ -1058,10 +1085,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 - `organizationId` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
 - `olderThanDays` [int](https://api.flutter.dev/flutter/dart-core/int-class.html) (required)
+- `filter` [DeleteTabularFilter](https://flutter.viam.dev/viam_protos.app.data/DeleteTabularFilter-class.html)? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[int](https://api.flutter.dev/flutter/dart-core/int-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[int](https://api.flutter.dev/flutter/dart-core/int-class.html)>
 
 **Example:**
 
@@ -1073,8 +1101,13 @@ _viam = await Viam.withApiKey(
 final dataClient = _viam.dataClient;
 
 try {
+  // Delete all data older than 5 days
   dataClient.deleteTabularData("<YOUR-ORG-ID>", 5);
 
+  // Delete data older than 5 days, filtered by location
+  final filter = DeleteTabularFilter(locationIds: ["<YOUR-LOCATION-ID>"]);
+  dataClient.deleteTabularData("<YOUR-ORG-ID>", 5, filter: filter);
+
  print('Successfully deleted tabular data');
 } catch (e) {
  print('Error deleting tabular data: $e');
@@ -1099,7 +1132,7 @@ Filter and delete binary data.
 
 **Returns:**
 
-- ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): The number of items deleted.
+- ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): :   The number of items deleted.
 
 **Example:**
 
@@ -1166,7 +1199,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[int](https://api.flutter.dev/flutter/dart-core/int-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[int](https://api.flutter.dev/flutter/dart-core/int-class.html)>
 
 **Example:**
 
@@ -1210,7 +1243,7 @@ Filter and delete binary data by ids.
 
 **Returns:**
 
-- ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): The number of items deleted.
+- ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): :   The number of items deleted.
 
 **Raises:**
 
@@ -1261,7 +1294,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/a
 
 **Parameters:**
 
-- `ids` (string) (required): The IDs of the data to be deleted. Must be non\-empty.
+- `ids` (string) (required): The IDs of the data to be deleted. Must be non-empty.
 
 **Returns:**
 
@@ -1282,11 +1315,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `binaryDataIds` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\> (required)
+- `binaryDataIds` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[int](https://api.flutter.dev/flutter/dart-core/int-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[int](https://api.flutter.dev/flutter/dart-core/int-class.html)>
 
 **Example:**
 
@@ -1384,8 +1417,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/a
 **Parameters:**
 
 - `tags` (string) (required): The list of tags to add to specified binary data. Must be
-  non\-empty.
-- `ids` (string) (required): The IDs of the data to be tagged. Must be non\-empty.
+  non-empty.
+- `ids` (string) (required): The IDs of the data to be tagged. Must be non-empty.
 
 **Returns:**
 
@@ -1409,12 +1442,12 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `tags` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\> (required)
-- `binaryDataIds` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\> (required)
+- `tags` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)> (required)
+- `binaryDataIds` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -1462,7 +1495,7 @@ Remove tags from binary by ids.
 
 **Returns:**
 
-- ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): The number of tags removed.
+- ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): :   The number of tags removed.
 
 **Raises:**
 
@@ -1518,8 +1551,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/a
 **Parameters:**
 
 - `tags` (string) (required): List of tags to remove from specified binary data. Must be
-  non\-empty.
-- `ids` (string) (required): The IDs of the data to be edited. Must be non\-empty.
+  non-empty.
+- `ids` (string) (required): The IDs of the data to be edited. Must be non-empty.
 
 **Returns:**
 
@@ -1543,12 +1576,12 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `tags` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\> (required)
-- `binaryDataIds` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\> (required)
+- `tags` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)> (required)
+- `binaryDataIds` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[int](https://api.flutter.dev/flutter/dart-core/int-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[int](https://api.flutter.dev/flutter/dart-core/int-class.html)>
 
 **Example:**
 
@@ -1595,7 +1628,7 @@ Get a list of tags using a filter.
 
 **Returns:**
 
-- (List[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]): The list of tags.
+- (List[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]): :   The list of tags.
 
 **Example:**
 
@@ -1639,7 +1672,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)>\>
 
 **Example:**
 
@@ -1685,10 +1718,11 @@ Add a bounding box to an image specified by its BinaryID.
 - `y_min_normalized` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (required): Min Y value of the bounding box normalized from 0 to 1.
 - `x_max_normalized` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (required): Max X value of the bounding box normalized from 0 to 1.
 - `y_max_normalized` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (required): Max Y value of the bounding box normalized from 0 to 1.
+- `confidence_score` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (optional): Confidence level of the bounding box being correct.
 
 **Returns:**
 
-- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): The bounding box ID.
+- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): :   The bounding box ID.
 
 **Raises:**
 
@@ -1703,7 +1737,8 @@ bbox_id = await data_client.add_bounding_box_to_image_by_id(
     x_min_normalized=0,
     y_min_normalized=.1,
     x_max_normalized=.2,
-    y_max_normalized=.3
+    y_max_normalized=.3,
+    confidence_score=.95
 )
 
 print(bbox_id)
@@ -1736,16 +1771,19 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/a
 
 **Parameters:**
 
-- `binaryId` (string) (required): The ID of the image to add the bounding box to.
+- `binaryId` (string) (required): The ID of the image to add the bounding
+  box to.
 - `label` (string) (required): A label for the bounding box.
-- `xMinNormalized` (number) (required): The min X value of the bounding box normalized from 0
-  to 1.
-- `yMinNormalized` (number) (required): The min Y value of the bounding box normalized from 0
-  to 1.
-- `xMaxNormalized` (number) (required): The max X value of the bounding box normalized from 0
-  to 1.
-- `yMaxNormalized` (number) (required): The max Y value of the bounding box normalized from 0
-  to 1.
+- `xMinNormalized` (number) (required): The min X value of the bounding box
+  normalized from 0 to 1.
+- `yMinNormalized` (number) (required): The min Y value of the bounding box
+  normalized from 0 to 1.
+- `xMaxNormalized` (number) (required): The max X value of the bounding box
+  normalized from 0 to 1.
+- `yMaxNormalized` (number) (required): The max Y value of the bounding box
+  normalized from 0 to 1.
+- `confidence` (number) (optional): Model's confidence in a predicted bounding box
+  expressed as a normalized value from 0 to 1.
 
 **Returns:**
 
@@ -1760,7 +1798,8 @@ const bboxId = await dataClient.addBoundingBoxToImageById(
   0.3,
   0.3,
   0.6,
-  0.6
+  0.6,
+  0.4
 );
 ```
 
@@ -1780,7 +1819,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)>
 
 **Example:**
 
@@ -1889,7 +1928,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -1935,7 +1974,7 @@ Get a list of bounding box labels using a Filter.
 
 **Returns:**
 
-- (List[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]): The list of bounding box labels.
+- (List[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]): :   The list of bounding box labels.
 
 **Example:**
 
@@ -1997,7 +2036,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)>\>
 
 **Example:**
 
@@ -2041,7 +2080,7 @@ Get a connection to access a MongoDB Atlas Data federation instance.
 
 **Returns:**
 
-- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): The hostname of the federated database.
+- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): :   The hostname of the federated database.
 
 **Example:**
 
@@ -2096,7 +2135,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[DatabaseConnection](https://flutter.viam.dev/viam_sdk/DatabaseConnection.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[DatabaseConnection](https://flutter.viam.dev/viam_sdk/DatabaseConnection.html)>
 
 **Example:**
 
@@ -2202,7 +2241,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -2314,12 +2353,12 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `binaryDataIds` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\> (required)
+- `binaryDataIds` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)> (required)
 - `datasetId` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -2440,12 +2479,12 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `binaryDataIds` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\> (required)
+- `binaryDataIds` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)> (required)
 - `datasetId` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -2484,7 +2523,7 @@ For more information, see the [Flutter SDK Docs](https://flutter.viam.dev/viam_s
 
 ### GetDataPipeline
 
-Get the configuration for a [data pipeline](/data-ai/data/data-pipelines/).
+Get the configuration for a [data pipeline](/data/pipelines/create-a-pipeline/).
 {{< tabs >}}
 {{% tab name="Python" %}}
 
@@ -2494,7 +2533,7 @@ Get the configuration for a [data pipeline](/data-ai/data/data-pipelines/).
 
 **Returns:**
 
-- ([DataPipeline](https://python.viam.dev/autoapi/viam/app/data_client/index.html#viam.app.data_client.DataClient.DataPipeline)): The data pipeline with the given ID.
+- ([DataPipeline](https://python.viam.dev/autoapi/viam/app/data_client/index.html#viam.app.data_client.DataClient.DataPipeline)): :   The data pipeline with the given ID.
 
 **Example:**
 
@@ -2545,7 +2584,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 ### ListDataPipelines
 
-List all of the [data pipelines](/data-ai/data/data-pipelines/) in an organization.
+List all of the [data pipelines](/data/pipelines/create-a-pipeline/) in an organization.
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -2556,7 +2595,7 @@ List all of the [data pipelines](/data-ai/data/data-pipelines/) in an organizati
 
 **Returns:**
 
-- ([List[DataPipeline]](https://python.viam.dev/autoapi/viam/app/data_client/index.html#viam.app.data_client.DataClient.DataPipeline)): A list of all of the data pipelines for the given organization.
+- ([List[DataPipeline]](https://python.viam.dev/autoapi/viam/app/data_client/index.html#viam.app.data_client.DataClient.DataPipeline)): :   A list of all of the data pipelines for the given organization.
 
 **Example:**
 
@@ -2607,7 +2646,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 ### CreateDataPipeline
 
-Create a [data pipeline](/data-ai/data/data-pipelines/).
+Create a [data pipeline](/data/pipelines/create-a-pipeline/).
 {{< tabs >}}
 {{% tab name="Python" %}}
 
@@ -2622,7 +2661,7 @@ Create a [data pipeline](/data-ai/data/data-pipelines/).
 
 **Returns:**
 
-- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): The ID of the newly created pipeline.
+- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): :   The ID of the newly created pipeline.
 
 **Example:**
 
@@ -2707,7 +2746,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 ### DeleteDataPipeline
 
-Delete a [data pipeline](/data-ai/data/data-pipelines/), its execution history, and all of its output data.
+Delete a [data pipeline](/data/pipelines/create-a-pipeline/), its execution history, and all of its output data.
 {{< tabs >}}
 {{% tab name="Python" %}}
 
@@ -2767,7 +2806,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 ### ListDataPipelineRuns
 
-Get information about individual executions of a [data pipeline](/data-ai/data/data-pipelines/).
+Get information about individual executions of a [data pipeline](/data/pipelines/create-a-pipeline/).
 {{< tabs >}}
 {{% tab name="Python" %}}
 
@@ -2778,7 +2817,7 @@ Get information about individual executions of a [data pipeline](/data-ai/data/d
 
 **Returns:**
 
-- ([DataPipelineRunsPage](https://python.viam.dev/autoapi/viam/app/data_client/index.html#viam.app.data_client.DataClient.DataPipelineRunsPage)): A page of data pipeline runs with pagination support.
+- ([DataPipelineRunsPage](https://python.viam.dev/autoapi/viam/app/data_client/index.html#viam.app.data_client.DataClient.DataPipelineRunsPage)): :   A page of data pipeline runs with pagination support.
 
 **Example:**
 
@@ -2840,7 +2879,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 ### RenameDataPipeline
 
-Rename a [data pipeline](/data-ai/data/data-pipelines/).
+Rename a [data pipeline](/data/pipelines/create-a-pipeline/).
 
 {{< tabs >}}
 {{% tab name="Go" %}}
@@ -2859,3 +2898,217 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/a
 
 {{% /tab %}}
 {{< /tabs >}}
+
+### AddTagsToBinaryDataByFilter
+
+Add tags to binary data by filter.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+**Parameters:**
+
+- `tags` (List[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]) (required): List of tags to add to specified binary data. Must be non-empty.
+- `filter` ([viam.proto.app.data.Filter](https://python.viam.dev/autoapi/viam/proto/app/data/index.html#viam.proto.app.data.Filter)) (optional): Specifies binary data to tag. If none is provided, tags all data.
+
+**Returns:**
+
+- None.
+
+**Raises:**
+
+- (GRPCError): If no tags are provided.
+
+**Example:**
+
+```python {class="line-numbers linkable-line-numbers"}
+from viam.utils import create_filter
+
+my_filter = create_filter(component_name="my_camera")
+tags = ["tag1", "tag2"]
+await data_client.add_tags_to_binary_data_by_filter(tags, my_filter)
+```
+
+For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/app/data_client/index.html#viam.app.data_client.DataClient.add_tags_to_binary_data_by_filter).
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### CreateBinaryDataSignedURL
+
+Create a signed URL for accessing binary data without authentication. The URL expires after the specified duration.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+**Parameters:**
+
+- `binary_data_id` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): The binary data ID of the file to create a signed URL for.
+- `expiration_minutes` ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (optional): Expiration time in minutes. Defaults to 15 minutes if not specified. Maximum allowed is 10080 minutes (7 days).
+
+**Returns:**
+
+- (Tuple[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), [datetime.datetime](https://docs.python.org/3/library/datetime.html)]): :   A tuple containing:
+    :   * `signed_url` (*str*): The signed URL for the binary data file.
+        * `expires_at` (*datetime*): The expiration time of the signed URL token.
+
+**Example:**
+
+```python {class="line-numbers linkable-line-numbers"}
+signed_url, expires_at = await data_client.create_binary_data_signed_url(
+    binary_data_id="<YOUR-BINARY-DATA-ID>",
+    expiration_minutes=60
+)
+
+print(f"Signed URL: {signed_url}")
+print(f"Expires at: {expires_at}")
+```
+
+For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/app/data_client/index.html#viam.app.data_client.DataClient.create_binary_data_signed_url).
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### CreateIndex
+
+Create a custom index on your data to speed up queries. You specify the organization, the collection type (tabular or binary), and the fields to index.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+**Parameters:**
+
+- `organization_id` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): The ID of the organization that owns the data. To find your organization ID, visit the organization settings page.
+- `collection_type` (viam.proto.app.data.IndexableCollection.ValueType) (required): The type of collection the index is on.
+- `index_spec` (Dict[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]) (required): The MongoDB index specification defined in JSON format.
+- `pipeline_name` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): The name of the pipeline if the collection type is PIPELINE_SINK.
+
+**Returns:**
+
+- None.
+
+For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/app/data_client/index.html#viam.app.data_client.DataClient.create_index).
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### DeleteIndex
+
+Delete a custom index from your data.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+**Parameters:**
+
+- `organization_id` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): The ID of the organization that owns the data. To find your organization ID, visit the organization settings page.
+- `collection_type` (viam.proto.app.data.IndexableCollection.ValueType) (required): The type of collection the index is on.
+- `index_name` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): The name of the index to delete.
+- `pipeline_name` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): The name of the pipeline if the collection type is PIPELINE_SINK.
+
+**Returns:**
+
+- None.
+
+For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/app/data_client/index.html#viam.app.data_client.DataClient.delete_index).
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### ListIndexes
+
+List all custom indexes for an organization.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+**Parameters:**
+
+- `organization_id` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): The ID of the organization that owns the data. To find your organization ID, visit the organization settings page.
+- `collection_type` (viam.proto.app.data.IndexableCollection.ValueType) (required): The type of collection the index is on.
+- `pipeline_name` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): The name of the pipeline if the collection type is PIPELINE_SINK.
+
+**Returns:**
+
+- ([Sequence[viam.proto.app.data.Index]](https://python.viam.dev/autoapi/viam/proto/app/data/index.html#viam.proto.app.data.Index)): :   A list of indexes.
+
+For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/app/data_client/index.html#viam.app.data_client.DataClient.list_indexes).
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### RemoveTagsFromBinaryDataByFilter
+
+Remove tags from binary data by filter.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+**Parameters:**
+
+- `tags` (List[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]) (required): List of tags to remove from specified binary data.
+- `filter` ([viam.proto.app.data.Filter](https://python.viam.dev/autoapi/viam/proto/app/data/index.html#viam.proto.app.data.Filter)) (optional): Specifies binary data to untag. If none is provided, removes tags from all data.
+
+**Returns:**
+
+- ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): :   The number of tags removed.
+
+**Raises:**
+
+- (GRPCError): If no tags are provided.
+
+**Example:**
+
+```python {class="line-numbers linkable-line-numbers"}
+from viam.utils import create_filter
+
+my_filter = create_filter(component_name="my_camera")
+tags = ["tag1", "tag2"]
+res = await data_client.remove_tags_from_binary_data_by_filter(tags, my_filter)
+```
+
+For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/app/data_client/index.html#viam.app.data_client.DataClient.remove_tags_from_binary_data_by_filter).
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### UpdateBoundingBox
+
+Update an existing bounding box on an image. You can change the label, position, or dimensions of the bounding box.
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+**Parameters:**
+
+- `binary_id` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): The binary data ID of the image to add the bounding box to.
+- `bbox_id` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): The ID of the bounding box to be updated.
+- `label` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (required): A label for the bounding box.
+- `x_min_normalized` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (required): Min X value of the bounding box normalized from 0 to 1.
+- `y_min_normalized` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (required): Min Y value of the bounding box normalized from 0 to 1.
+- `x_max_normalized` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (required): Max X value of the bounding box normalized from 0 to 1.
+- `y_max_normalized` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (required): Max Y value of the bounding box normalized from 0 to 1.
+- `confidence_score` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (optional): Confidence level of the bounding box being correct.
+
+**Returns:**
+
+- None.
+
+**Raises:**
+
+- (GRPCError): If the X or Y values are outside of the [0, 1] range.
+
+**Example:**
+
+```python {class="line-numbers linkable-line-numbers"}
+await data_client.update_bounding_box(
+    binary_id="<YOUR-BINARY-DATA-ID>",
+    bbox_id="2",
+    label="label",
+    x_min_normalized=0,
+    y_min_normalized=0.1,
+    x_max_normalized=0.2,
+    y_max_normalized=0.3,
+    confidence_score=0.95
+)
+```
+
+For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/app/data_client/index.html#viam.app.data_client.DataClient.update_bounding_box).
+
+{{% /tab %}}
+{{< /tabs >}}
diff --git a/static/include/app/apis/generated/data_sync-table.md b/static/include/app/apis/generated/data_sync-table.md
index 166264d308..386656c38e 100644
--- a/static/include/app/apis/generated/data_sync-table.md
+++ b/static/include/app/apis/generated/data_sync-table.md
@@ -1,8 +1,8 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`BinaryDataCaptureUpload`](/dev/reference/apis/data-client/#binarydatacaptureupload) | Upload binary data collected on your machine through a specific component and the relevant metadata to Viam. |
-| [`TabularDataCaptureUpload`](/dev/reference/apis/data-client/#tabulardatacaptureupload) | Upload tabular data collected on your machine through a specific {{< glossary_tooltip term_id="component" text="component" >}} to Viam. |
-| [`FileUpload`](/dev/reference/apis/data-client/#fileupload) | Upload arbitrary files stored on your machine to Viam by file name. |
-| [`FileUploadFromPath`](/dev/reference/apis/data-client/#fileuploadfrompath) | Upload files stored on your machine to Viam by filepath. |
-| [`StreamingDataCaptureUpload`](/dev/reference/apis/data-client/#streamingdatacaptureupload) | Upload the contents of streaming binary data and the relevant metadata to Viam. |
+| [`BinaryDataCaptureUpload`](/reference/apis/data-client/#binarydatacaptureupload) | Upload binary data collected on your machine through a specific component and the relevant metadata to Viam. |
+| [`TabularDataCaptureUpload`](/reference/apis/data-client/#tabulardatacaptureupload) | Upload tabular data collected on your machine through a specific {{< glossary_tooltip term_id="component" text="component" >}} to Viam. |
+| [`FileUpload`](/reference/apis/data-client/#fileupload) | Upload arbitrary files stored on your machine to Viam by file name. |
+| [`FileUploadFromPath`](/reference/apis/data-client/#fileuploadfrompath) | Upload files stored on your machine to Viam by filepath. |
+| [`StreamingDataCaptureUpload`](/reference/apis/data-client/#streamingdatacaptureupload) | Upload the contents of streaming binary data and the relevant metadata to Viam. |
diff --git a/static/include/app/apis/generated/data_sync.md b/static/include/app/apis/generated/data_sync.md
index ebe6035640..f946fb0658 100644
--- a/static/include/app/apis/generated/data_sync.md
+++ b/static/include/app/apis/generated/data_sync.md
@@ -17,10 +17,11 @@ Uploaded binary data can be found under the **Images**, **Point clouds**, or **F
 - `tags` (List[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]) (optional): Optional list of tags to allow for tag-based data filtering when retrieving data.
 - `dataset_ids` (List[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]) (optional): Optional list of datasets to add the data to.
 - `data_request_times` (Tuple[[datetime.datetime](https://docs.python.org/3/library/datetime.html), [datetime.datetime](https://docs.python.org/3/library/datetime.html)]) (optional): Optional tuple containing datetime objects denoting the times this data was requested [0] by the robot and received [1] from the appropriate sensor.
+- `mime_type` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): Optional mime type of the data.
 
 **Returns:**
 
-- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): The binary data ID of the uploaded data.
+- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): :   The binary data ID of the uploaded data.
 
 **Raises:**
 
@@ -60,15 +61,10 @@ For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/
 - `componentName` (string) (required): The name of the component used to capture the data.
 - `methodName` (string) (required): The name of the method used to capture the data.
 - `dataRequestTimes` (Date) (required): Tuple containing `Date` objects denoting the times
-  this data was requested\[0] by the robot and received\[1] from the
+  this data was requested[0] by the robot and received[1] from the
   appropriate sensor.
-- `options` (BinaryDataCaptureUploadOptions) (optional): Optional parameters including:
-  - `mimeType` (string) (optional): The MIME type of the data.
-  - `fileExtension` (string) (optional): The file extension of binary data including the
-    period, for example .jpg, .png, or .pcd.
-  - `tags` (string\[\]) (optional): The list of tags to allow for tag\-based filtering when
-    retrieving data.
-  - `datasetIds` (string\[\]) (optional): Dataset IDs to add the data to.
+- `options` ([BinaryDataCaptureUploadOptions](https://ts.viam.dev/interfaces/BinaryDataCaptureUploadOptions.html)) (optional): Optional parameters including `mimeType`, `fileExtension`,
+  `tags`, and `datasetIds`.
 
 **Returns:**
 
@@ -82,7 +78,7 @@ const binaryDataId = await dataClient.binaryDataCaptureUpload(
   '123abc45-1234-5678-90ab-cdef12345678',
   'rdk:component:camera',
   'my-camera',
-  'GetImages',
+  'ReadImage',
   [new Date('2025-03-19'), new Date('2025-03-19')],
   { mimeType: 'image/jpeg' }
 );
@@ -95,20 +91,20 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `binaryData` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[int](https://api.flutter.dev/flutter/dart-core/int-class.html)\> (required)
+- `binaryData` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[int](https://api.flutter.dev/flutter/dart-core/int-class.html)> (required)
 - `partId` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
 - `fileExtension` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
 - `componentType` [String](https://api.flutter.dev/flutter/dart-core/String-class.html)? (optional)
 - `componentName` [String](https://api.flutter.dev/flutter/dart-core/String-class.html)? (optional)
 - `methodName` [String](https://api.flutter.dev/flutter/dart-core/String-class.html)? (optional)
-- `methodParameters` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), Any\>? (optional)
+- `methodParameters` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), Any>? (optional)
 - `dataRequestTimes` ([DateTime](https://api.flutter.dev/flutter/dart-core/DateTime-class.html), [DateTime](https://api.flutter.dev/flutter/dart-core/DateTime-class.html))? (optional)
-- `datasetIds` [Iterable](https://api.flutter.dev/flutter/dart-core/Iterable-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\> (optional)
-- `tags` [Iterable](https://api.flutter.dev/flutter/dart-core/Iterable-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\> (optional)
+- `datasetIds` [Iterable](https://api.flutter.dev/flutter/dart-core/Iterable-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)> (optional)
+- `tags` [Iterable](https://api.flutter.dev/flutter/dart-core/Iterable-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)> (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)>
 
 **Example:**
 
@@ -133,7 +129,7 @@ _viam = await Viam.withApiKey(
      ".png",
      componentType: "rdk:component:camera",
      componentName: "camera-1",
-     methodName: "GetImages",
+     methodName: "ReadImage",
      dataRequestTimes: dataRequestTimes);
 
    print('Successfully uploaded binary data with binaryDataId: $binaryDataId');
@@ -171,7 +167,7 @@ Viam enforces a maximum size of 4MB for any single reading for tabular data.
 
 **Returns:**
 
-- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): The file ID of the uploaded data.
+- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): :   The file ID of the uploaded data.
 
 **Raises:**
 
@@ -216,11 +212,11 @@ For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/
 - `componentName` (string) (required): The name of the component used to capture the data.
 - `methodName` (string) (required): The name of the method used to capture the data.
 - `dataRequestTimes` (Date) (required): Array of Date tuples, each containing two `Date`
-  objects denoting the times this data was requested\[0] by the robot and
-  received\[1] from the appropriate sensor. Passing a list of tabular data
-  and Timestamps with length n \> 1 will result in n datapoints being
+  objects denoting the times this data was requested[0] by the robot and
+  received[1] from the appropriate sensor. Passing a list of tabular data
+  and Timestamps with length n > 1 will result in n datapoints being
   uploaded, all tied to the same metadata.
-- `tags` (string) (optional): The list of tags to allow for tag\-based filtering when
+- `tags` (string) (optional): The list of tags to allow for tag-based filtering when
   retrieving data.
 
 **Returns:**
@@ -259,18 +255,18 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `tabularData` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\> (required)
+- `tabularData` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>> (required)
 - `partId` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
 - `componentType` [String](https://api.flutter.dev/flutter/dart-core/String-class.html)? (optional)
 - `componentName` [String](https://api.flutter.dev/flutter/dart-core/String-class.html)? (optional)
 - `methodName` [String](https://api.flutter.dev/flutter/dart-core/String-class.html)? (optional)
-- `methodParameters` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), Any\>? (optional)
-- `dataRequestTimes` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<([DateTime](https://api.flutter.dev/flutter/dart-core/DateTime-class.html), [DateTime](https://api.flutter.dev/flutter/dart-core/DateTime-class.html))\>? (optional)
-- `tags` [Iterable](https://api.flutter.dev/flutter/dart-core/Iterable-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\> (optional)
+- `methodParameters` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), Any>? (optional)
+- `dataRequestTimes` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)<([DateTime](https://api.flutter.dev/flutter/dart-core/DateTime-class.html), [DateTime](https://api.flutter.dev/flutter/dart-core/DateTime-class.html))>? (optional)
+- `tags` [Iterable](https://api.flutter.dev/flutter/dart-core/Iterable-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)> (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)>
 
 **Example:**
 
@@ -284,13 +280,11 @@ _viam = await Viam.withApiKey(
    // Define tabular data
    final List<Map<String, dynamic>> tabularData;
    tabularData = [{
-     'readings': {
-       "altitude_m": 50.2,
-       "coordinate": {
-         "latitude": 40.5,
-         "longitude": -72.98
-      }
-     }
+     "altitude_m": 50.2,
+     "coordinate": {
+       "latitude": 40.5,
+       "longitude": -72.98
+     },
    }];
 
   // Define date request times
@@ -339,10 +333,11 @@ All other types of uploaded files can be found under the **Files** subtab of the
 - `file_extension` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): Optional file extension. The empty string "" will be assigned as the file extension if one isn’t provided. Files with a .jpeg, .jpg, or .png extension will be saved to the Images tab.
 - `tags` (List[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]) (optional): Optional list of tags to allow for tag-based filtering when retrieving data.
 - `dataset_ids` (List[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]) (optional): Optional list of datasets to add the data to.
+- `mime_type` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): Optional mime type of the data.
 
 **Returns:**
 
-- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): Binary data ID of the new file.
+- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): :   Binary data ID of the new file.
 
 **Raises:**
 
@@ -374,13 +369,13 @@ For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/
 - `componentType` [String](https://api.flutter.dev/flutter/dart-core/String-class.html)? (optional)
 - `componentName` [String](https://api.flutter.dev/flutter/dart-core/String-class.html)? (optional)
 - `methodName` [String](https://api.flutter.dev/flutter/dart-core/String-class.html)? (optional)
-- `methodParameters` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), Any\>? (optional)
-- `datasetIds` [Iterable](https://api.flutter.dev/flutter/dart-core/Iterable-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\> (optional)
-- `tags` [Iterable](https://api.flutter.dev/flutter/dart-core/Iterable-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\> (optional)
+- `methodParameters` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), Any>? (optional)
+- `datasetIds` [Iterable](https://api.flutter.dev/flutter/dart-core/Iterable-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)> (optional)
+- `tags` [Iterable](https://api.flutter.dev/flutter/dart-core/Iterable-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)> (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)>
 
 **Example:**
 
@@ -452,10 +447,11 @@ Uploaded files can be found under the **Files** subtab of the [**Data** tab](htt
 - `method_parameters` (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]) (optional): Optional dictionary of the method parameters. No longer in active use.
 - `tags` (List[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]) (optional): Optional list of tags to allow for tag-based filtering when retrieving data.
 - `dataset_ids` (List[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]) (optional): Optional list of datasets to add the data to.
+- `mime_type` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): Optional mime type of the data.
 
 **Returns:**
 
-- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): Binary data ID of the new file.
+- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): :   Binary data ID of the new file.
 
 **Raises:**
 
@@ -498,10 +494,11 @@ Uploaded streaming data can be found under the [**Data** tab](https://app.viam.c
 - `data_request_times` (Tuple[[datetime.datetime](https://docs.python.org/3/library/datetime.html), [datetime.datetime](https://docs.python.org/3/library/datetime.html)]) (optional): Optional tuple containing datetime objects denoting the times this data was requested [0] by the robot and received [1] from the appropriate sensor.
 - `tags` (List[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]) (optional): Optional list of tags to allow for tag-based filtering when retrieving data.
 - `dataset_ids` (List[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]) (optional): Optional list of datasets to add the data to.
+- `mime_type` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): Optional mime type of the data.
 
 **Returns:**
 
-- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): The binary data ID of the uploaded data.
+- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): :   The binary data ID of the uploaded data.
 
 **Raises:**
 
@@ -533,20 +530,20 @@ For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/
 
 **Parameters:**
 
-- `bytes` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[int](https://api.flutter.dev/flutter/dart-core/int-class.html)\> (required)
+- `bytes` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[int](https://api.flutter.dev/flutter/dart-core/int-class.html)> (required)
 - `partId` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
 - `fileExtension` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
 - `componentType` [String](https://api.flutter.dev/flutter/dart-core/String-class.html)? (optional)
 - `componentName` [String](https://api.flutter.dev/flutter/dart-core/String-class.html)? (optional)
 - `methodName` [String](https://api.flutter.dev/flutter/dart-core/String-class.html)? (optional)
-- `methodParameters` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), Any\>? (optional)
+- `methodParameters` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), Any>? (optional)
 - `dataRequestTimes` ([DateTime](https://api.flutter.dev/flutter/dart-core/DateTime-class.html), [DateTime](https://api.flutter.dev/flutter/dart-core/DateTime-class.html))? (optional)
-- `datasetIds` [Iterable](https://api.flutter.dev/flutter/dart-core/Iterable-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\> (optional)
-- `tags` [Iterable](https://api.flutter.dev/flutter/dart-core/Iterable-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\> (optional)
+- `datasetIds` [Iterable](https://api.flutter.dev/flutter/dart-core/Iterable-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)> (optional)
+- `tags` [Iterable](https://api.flutter.dev/flutter/dart-core/Iterable-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)> (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)>
 
 **Example:**
 
diff --git a/static/include/app/apis/generated/dataset-table.md b/static/include/app/apis/generated/dataset-table.md
index b8312be669..e04b7e12cb 100644
--- a/static/include/app/apis/generated/dataset-table.md
+++ b/static/include/app/apis/generated/dataset-table.md
@@ -1,8 +1,8 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`CreateDataset`](/dev/reference/apis/data-client/#createdataset) | Create a new dataset. |
-| [`DeleteDataset`](/dev/reference/apis/data-client/#deletedataset) | Delete a dataset. |
-| [`RenameDataset`](/dev/reference/apis/data-client/#renamedataset) | Rename a dataset specified by the dataset ID. |
-| [`ListDatasetsByOrganizationID`](/dev/reference/apis/data-client/#listdatasetsbyorganizationid) | Get the datasets in an organization. |
-| [`ListDatasetsByIDs`](/dev/reference/apis/data-client/#listdatasetsbyids) | Get a list of datasets using their IDs. |
+| [`CreateDataset`](/reference/apis/data-client/#createdataset) | Create a new dataset. |
+| [`DeleteDataset`](/reference/apis/data-client/#deletedataset) | Delete a dataset. |
+| [`RenameDataset`](/reference/apis/data-client/#renamedataset) | Rename a dataset specified by the dataset ID. |
+| [`ListDatasetsByOrganizationID`](/reference/apis/data-client/#listdatasetsbyorganizationid) | Get the datasets in an organization. |
+| [`ListDatasetsByIDs`](/reference/apis/data-client/#listdatasetsbyids) | Get a list of datasets using their IDs. |
diff --git a/static/include/app/apis/generated/dataset.md b/static/include/app/apis/generated/dataset.md
index ec3b89a3c8..97c8cf48ed 100644
--- a/static/include/app/apis/generated/dataset.md
+++ b/static/include/app/apis/generated/dataset.md
@@ -12,7 +12,7 @@ Create a new dataset.
 
 **Returns:**
 
-- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): The dataset ID of the created dataset.
+- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): :   The dataset ID of the created dataset.
 
 **Example:**
 
@@ -76,7 +76,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)>
 
 **Example:**
 
@@ -171,7 +171,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -274,7 +274,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -315,7 +315,7 @@ Get the datasets in an organization.
 
 **Returns:**
 
-- ([Sequence[viam.proto.app.dataset.Dataset]](https://python.viam.dev/autoapi/viam/proto/app/dataset/index.html#viam.proto.app.dataset.Dataset)): The list of datasets in the organization.
+- ([Sequence[viam.proto.app.dataset.Dataset]](https://python.viam.dev/autoapi/viam/proto/app/dataset/index.html#viam.proto.app.dataset.Dataset)): :   The list of datasets in the organization.
 
 **Example:**
 
@@ -373,7 +373,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[Dataset](https://flutter.viam.dev/viam_protos.app.dataset/Dataset-class.html)\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[Dataset](https://flutter.viam.dev/viam_protos.app.dataset/Dataset-class.html)>\>
 
 **Example:**
 
@@ -414,7 +414,7 @@ Get a list of datasets using their IDs.
 
 **Returns:**
 
-- ([Sequence[viam.proto.app.dataset.Dataset]](https://python.viam.dev/autoapi/viam/proto/app/dataset/index.html#viam.proto.app.dataset.Dataset)): The list of datasets.
+- ([Sequence[viam.proto.app.dataset.Dataset]](https://python.viam.dev/autoapi/viam/proto/app/dataset/index.html#viam.proto.app.dataset.Dataset)): :   The list of datasets.
 
 **Example:**
 
@@ -468,11 +468,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `ids` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\> (required)
+- `ids` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[Dataset](https://flutter.viam.dev/viam_protos.app.dataset/Dataset-class.html)\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[Dataset](https://flutter.viam.dev/viam_protos.app.dataset/Dataset-class.html)>\>
 
 **Example:**
 
diff --git a/static/include/app/apis/generated/mltraining-table.md b/static/include/app/apis/generated/mltraining-table.md
index fa1d13227b..ec94caa9b8 100644
--- a/static/include/app/apis/generated/mltraining-table.md
+++ b/static/include/app/apis/generated/mltraining-table.md
@@ -1,9 +1,9 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`SubmitTrainingJob`](/dev/reference/apis/ml-training-client/#submittrainingjob) | Submit a training job. |
-| [`SubmitCustomTrainingJob`](/dev/reference/apis/ml-training-client/#submitcustomtrainingjob) | Submit a training job from a custom training script. |
-| [`GetTrainingJob`](/dev/reference/apis/ml-training-client/#gettrainingjob) | Get training job metadata. |
-| [`ListTrainingJobs`](/dev/reference/apis/ml-training-client/#listtrainingjobs) | Get training job metadata for all jobs within an organization. |
-| [`CancelTrainingJob`](/dev/reference/apis/ml-training-client/#canceltrainingjob) | Cancel the specified training job. |
-| [`DeleteCompletedTrainingJob`](/dev/reference/apis/ml-training-client/#deletecompletedtrainingjob) | Delete a completed training job from the database, whether the job succeeded or failed. |
+| [`SubmitTrainingJob`](/reference/apis/ml-training-client/#submittrainingjob) | Submit a training job. |
+| [`SubmitCustomTrainingJob`](/reference/apis/ml-training-client/#submitcustomtrainingjob) | Submit a training job from a custom training script. |
+| [`GetTrainingJob`](/reference/apis/ml-training-client/#gettrainingjob) | Get training job metadata. |
+| [`ListTrainingJobs`](/reference/apis/ml-training-client/#listtrainingjobs) | Get training job metadata for all jobs within an organization. |
+| [`CancelTrainingJob`](/reference/apis/ml-training-client/#canceltrainingjob) | Cancel the specified training job. |
+| [`DeleteCompletedTrainingJob`](/reference/apis/ml-training-client/#deletecompletedtrainingjob) | Delete a completed training job from the database, whether the job succeeded or failed. |
diff --git a/static/include/app/apis/generated/mltraining.md b/static/include/app/apis/generated/mltraining.md
index 4265b04cd4..2b1af53fb3 100644
--- a/static/include/app/apis/generated/mltraining.md
+++ b/static/include/app/apis/generated/mltraining.md
@@ -16,7 +16,7 @@ Submit a training job.
 
 **Returns:**
 
-- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): the ID of the training job.
+- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): :   the ID of the training job.
 
 **Example:**
 
@@ -89,7 +89,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 ### SubmitCustomTrainingJob
 
 Submit a training job from a custom training script.
-Follow the guide to [Train a Model with a Custom Python Training Script](/data-ai/train/train/).
+Follow the guide to [Train a Model with a Custom Python Training Script](/train/custom-training-scripts/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -105,7 +105,7 @@ Follow the guide to [Train a Model with a Custom Python Training Script](/data-a
 
 **Returns:**
 
-- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): the ID of the training job.
+- ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)): :   the ID of the training job.
 
 **Example:**
 
@@ -187,7 +187,7 @@ Get training job metadata.
 
 **Returns:**
 
-- ([viam.proto.app.mltraining.TrainingJobMetadata](https://python.viam.dev/autoapi/viam/proto/app/mltraining/index.html#viam.proto.app.mltraining.TrainingJobMetadata)): the training job data.
+- ([viam.proto.app.mltraining.TrainingJobMetadata](https://python.viam.dev/autoapi/viam/proto/app/mltraining/index.html#viam.proto.app.mltraining.TrainingJobMetadata)): :   the training job data.
 
 **Example:**
 
@@ -249,7 +249,7 @@ Get training job metadata for all jobs within an organization.
 
 **Returns:**
 
-- ([List[viam.proto.app.mltraining.TrainingJobMetadata]](https://python.viam.dev/autoapi/viam/proto/app/mltraining/index.html#viam.proto.app.mltraining.TrainingJobMetadata)): the list of training job data.
+- ([List[viam.proto.app.mltraining.TrainingJobMetadata]](https://python.viam.dev/autoapi/viam/proto/app/mltraining/index.html#viam.proto.app.mltraining.TrainingJobMetadata)): :   the list of training job data.
 
 **Example:**
 
diff --git a/static/include/app/apis/overrides/methods/python.app.check_permissions.after.md b/static/include/app/apis/overrides/methods/python.app.check_permissions.after.md
index 6ad55ef0a0..04859288eb 100644
--- a/static/include/app/apis/overrides/methods/python.app.check_permissions.after.md
+++ b/static/include/app/apis/overrides/methods/python.app.check_permissions.after.md
@@ -54,4 +54,4 @@ Valid arguments for permissions are as follows:
 
 {{% /expand %}}
 
-For more information about managing permissions, see [Role-Based Access Control](/manage/manage/rbac/).
+For more information about managing permissions, see [Role-Based Access Control](/organization/rbac/).
diff --git a/static/include/app/apis/overrides/protos/billing.ChargeOrganization.md b/static/include/app/apis/overrides/protos/billing.ChargeOrganization.md
new file mode 100644
index 0000000000..75fd78b125
--- /dev/null
+++ b/static/include/app/apis/overrides/protos/billing.ChargeOrganization.md
@@ -0,0 +1 @@
+Charge an organization for usage.
\ No newline at end of file
diff --git a/static/include/app/apis/overrides/protos/billing.GetCurrentMonthUsage.md b/static/include/app/apis/overrides/protos/billing.GetCurrentMonthUsage.md
index b48c94f790..92de541e02 100644
--- a/static/include/app/apis/overrides/protos/billing.GetCurrentMonthUsage.md
+++ b/static/include/app/apis/overrides/protos/billing.GetCurrentMonthUsage.md
@@ -1,3 +1,3 @@
 Access data usage information for the current billing period for a given organization.
 This method only returns usage for organizations with monthly billing at the end of the month (`"in_arrears": true`).
-You can also find your usage data on the [**Payment and billing** page](/manage/reference/billing/).
+You can also find your usage data on the [**Payment and billing** page](/organization/billing/).
diff --git a/static/include/app/apis/overrides/protos/billing.GetInvoicePDF.md b/static/include/app/apis/overrides/protos/billing.GetInvoicePDF.md
index a43312ce47..66afe6ecdc 100644
--- a/static/include/app/apis/overrides/protos/billing.GetInvoicePDF.md
+++ b/static/include/app/apis/overrides/protos/billing.GetInvoicePDF.md
@@ -1,2 +1,2 @@
 Access invoice PDF data and optionally save it to a provided file path.
-You can also find your invoices on the [**Payment and billing** page](/manage/reference/billing/).
+You can also find your invoices on the [**Payment and billing** page](/organization/billing/).
diff --git a/static/include/app/apis/overrides/protos/billing.GetOrgBillingInformation.md b/static/include/app/apis/overrides/protos/billing.GetOrgBillingInformation.md
index affe92d7b9..9fe1292d79 100644
--- a/static/include/app/apis/overrides/protos/billing.GetOrgBillingInformation.md
+++ b/static/include/app/apis/overrides/protos/billing.GetOrgBillingInformation.md
@@ -1,2 +1,2 @@
 Access billing information (payment method, billing tier, etc.) for a given org.
-You can also find this information on the [**Payment and billing** page](/manage/reference/billing/).
+You can also find this information on the [**Payment and billing** page](/organization/billing/).
diff --git a/static/include/app/apis/overrides/protos/data.CreateBinaryDataSignedURL.md b/static/include/app/apis/overrides/protos/data.CreateBinaryDataSignedURL.md
new file mode 100644
index 0000000000..f254b6b1b4
--- /dev/null
+++ b/static/include/app/apis/overrides/protos/data.CreateBinaryDataSignedURL.md
@@ -0,0 +1 @@
+Create a signed URL for accessing binary data without authentication. The URL expires after the specified duration.
\ No newline at end of file
diff --git a/static/include/app/apis/overrides/protos/data.CreateDataPipeline.md b/static/include/app/apis/overrides/protos/data.CreateDataPipeline.md
index 8e6afef5f1..d4df9037be 100644
--- a/static/include/app/apis/overrides/protos/data.CreateDataPipeline.md
+++ b/static/include/app/apis/overrides/protos/data.CreateDataPipeline.md
@@ -1 +1 @@
-Create a [data pipeline](/data-ai/data/data-pipelines/).
\ No newline at end of file
+Create a [data pipeline](/data/pipelines/create-a-pipeline/).
\ No newline at end of file
diff --git a/static/include/app/apis/overrides/protos/data.CreateIndex.md b/static/include/app/apis/overrides/protos/data.CreateIndex.md
new file mode 100644
index 0000000000..6b1dd27bf7
--- /dev/null
+++ b/static/include/app/apis/overrides/protos/data.CreateIndex.md
@@ -0,0 +1 @@
+Create a custom index on your data to speed up queries. You specify the organization, the collection type (tabular or binary), and the fields to index.
\ No newline at end of file
diff --git a/static/include/app/apis/overrides/protos/data.DeleteDataPipeline.md b/static/include/app/apis/overrides/protos/data.DeleteDataPipeline.md
index 254dbb4546..36c3496b75 100644
--- a/static/include/app/apis/overrides/protos/data.DeleteDataPipeline.md
+++ b/static/include/app/apis/overrides/protos/data.DeleteDataPipeline.md
@@ -1 +1 @@
-Delete a [data pipeline](/data-ai/data/data-pipelines/), its execution history, and all of its output data.
\ No newline at end of file
+Delete a [data pipeline](/data/pipelines/create-a-pipeline/), its execution history, and all of its output data.
\ No newline at end of file
diff --git a/static/include/app/apis/overrides/protos/data.DeleteIndex.md b/static/include/app/apis/overrides/protos/data.DeleteIndex.md
new file mode 100644
index 0000000000..3fc64039c3
--- /dev/null
+++ b/static/include/app/apis/overrides/protos/data.DeleteIndex.md
@@ -0,0 +1 @@
+Delete a custom index from your data.
\ No newline at end of file
diff --git a/static/include/app/apis/overrides/protos/data.DeleteTabularData.md b/static/include/app/apis/overrides/protos/data.DeleteTabularData.md
index b36d8283fd..9c154ef212 100644
--- a/static/include/app/apis/overrides/protos/data.DeleteTabularData.md
+++ b/static/include/app/apis/overrides/protos/data.DeleteTabularData.md
@@ -1 +1,2 @@
 Delete tabular data older than a specified number of days.
+If the organization has a [hot data store](/data/hot-data-store/), matching data is deleted from that store as well.
diff --git a/static/include/app/apis/overrides/protos/data.GetDataPipeline.md b/static/include/app/apis/overrides/protos/data.GetDataPipeline.md
index 3f1b49378f..54b1fa0115 100644
--- a/static/include/app/apis/overrides/protos/data.GetDataPipeline.md
+++ b/static/include/app/apis/overrides/protos/data.GetDataPipeline.md
@@ -1 +1 @@
-Get the configuration for a [data pipeline](/data-ai/data/data-pipelines/).
\ No newline at end of file
+Get the configuration for a [data pipeline](/data/pipelines/create-a-pipeline/).
\ No newline at end of file
diff --git a/static/include/app/apis/overrides/protos/data.ListDataPipelineRuns.md b/static/include/app/apis/overrides/protos/data.ListDataPipelineRuns.md
index a2135efe16..be7453d1da 100644
--- a/static/include/app/apis/overrides/protos/data.ListDataPipelineRuns.md
+++ b/static/include/app/apis/overrides/protos/data.ListDataPipelineRuns.md
@@ -1 +1 @@
-Get information about individual executions of a [data pipeline](/data-ai/data/data-pipelines/).
\ No newline at end of file
+Get information about individual executions of a [data pipeline](/data/pipelines/create-a-pipeline/).
\ No newline at end of file
diff --git a/static/include/app/apis/overrides/protos/data.ListDataPipelines.md b/static/include/app/apis/overrides/protos/data.ListDataPipelines.md
index f47e7c8259..5a85e55b61 100644
--- a/static/include/app/apis/overrides/protos/data.ListDataPipelines.md
+++ b/static/include/app/apis/overrides/protos/data.ListDataPipelines.md
@@ -1 +1 @@
-List all of the [data pipelines](/data-ai/data/data-pipelines/) in an organization.
+List all of the [data pipelines](/data/pipelines/create-a-pipeline/) in an organization.
diff --git a/static/include/app/apis/overrides/protos/data.ListIndexes.md b/static/include/app/apis/overrides/protos/data.ListIndexes.md
new file mode 100644
index 0000000000..48636e8118
--- /dev/null
+++ b/static/include/app/apis/overrides/protos/data.ListIndexes.md
@@ -0,0 +1 @@
+List all custom indexes for an organization.
\ No newline at end of file
diff --git a/static/include/app/apis/overrides/protos/data.RenameDataPipeline.md b/static/include/app/apis/overrides/protos/data.RenameDataPipeline.md
index 37a7087cf1..7fc877ec6c 100644
--- a/static/include/app/apis/overrides/protos/data.RenameDataPipeline.md
+++ b/static/include/app/apis/overrides/protos/data.RenameDataPipeline.md
@@ -1 +1 @@
-Rename a [data pipeline](/data-ai/data/data-pipelines/).
+Rename a [data pipeline](/data/pipelines/create-a-pipeline/).
diff --git a/static/include/app/apis/overrides/protos/data.UpdateBoundingBox.md b/static/include/app/apis/overrides/protos/data.UpdateBoundingBox.md
new file mode 100644
index 0000000000..c3eb0c761b
--- /dev/null
+++ b/static/include/app/apis/overrides/protos/data.UpdateBoundingBox.md
@@ -0,0 +1 @@
+Update an existing bounding box on an image. You can change the label, position, or dimensions of the bounding box.
\ No newline at end of file
diff --git a/static/include/app/apis/overrides/protos/mltraining.SubmitCustomTrainingJob.md b/static/include/app/apis/overrides/protos/mltraining.SubmitCustomTrainingJob.md
index c7f237fea0..f50cca35d7 100644
--- a/static/include/app/apis/overrides/protos/mltraining.SubmitCustomTrainingJob.md
+++ b/static/include/app/apis/overrides/protos/mltraining.SubmitCustomTrainingJob.md
@@ -1,2 +1,2 @@
 Submit a training job from a custom training script.
-Follow the guide to [Train a Model with a Custom Python Training Script](/data-ai/train/train/).
+Follow the guide to [Train a Model with a Custom Python Training Script](/train/custom-training-scripts/).
diff --git a/static/include/components/apis/component.md b/static/include/components/apis/component.md
index 70433a9418..97d48bc7e2 100644
--- a/static/include/components/apis/component.md
+++ b/static/include/components/apis/component.md
@@ -2,4 +2,4 @@
 | --------------------------------------------------------------- | ---------------------------------------- |
 | [`GetReadings`](#getreadings)                                   | Do the thing the method does.            |
 | [`MethodName2`](#methodname2)                                   | Do the thing this method does.           |
-| [`DoCommand`](/operate/reference/components/encoder/#docommand) | Send or receive model-specific commands. |
+| [`DoCommand`](/reference/apis/components/encoder/#docommand) | Send or receive model-specific commands. |
diff --git a/static/include/components/apis/generated/arm-table.md b/static/include/components/apis/generated/arm-table.md
index e32ae8169e..e04be683e2 100644
--- a/static/include/components/apis/generated/arm-table.md
+++ b/static/include/components/apis/generated/arm-table.md
@@ -1,17 +1,17 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`GetEndPosition`](/dev/reference/apis/components/arm/#getendposition) | Get the current position of the arm as a pose. |
-| [`MoveToPosition`](/dev/reference/apis/components/arm/#movetoposition) | Move the end of the arm in a straight line to the desired pose, relative to the base of the arm. |
-| [`MoveToJointPositions`](/dev/reference/apis/components/arm/#movetojointpositions) | Move each joint on the arm to the position specified in `positions`. |
-| [`MoveThroughJointPositions`](/dev/reference/apis/components/arm/#movethroughjointpositions) | Move the arm's joints through the given positions in the order they are specified. |
-| [`GetJointPositions`](/dev/reference/apis/components/arm/#getjointpositions) | Get the current position of each joint on the arm. |
-| [`Get3DModels`](/dev/reference/apis/components/arm/#get3dmodels) | Get the 3D models of the arm. |
-| [`GetKinematics`](/dev/reference/apis/components/arm/#getkinematics) | Get the kinematics information associated with the arm as the format and byte contents of the kinematics file. |
-| [`IsMoving`](/dev/reference/apis/components/arm/#ismoving) | Get if the arm is currently moving. |
-| [`Stop`](/dev/reference/apis/components/arm/#stop) | Stop all motion of the arm. |
-| [`GetGeometries`](/dev/reference/apis/components/arm/#getgeometries) | Get all the geometries associated with the arm in its current configuration, in the frame of the arm. |
-| [`Reconfigure`](/dev/reference/apis/components/arm/#reconfigure) | Reconfigure this resource. |
-| [`DoCommand`](/dev/reference/apis/components/arm/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
-| [`GetResourceName`](/dev/reference/apis/components/arm/#getresourcename) | Get the `ResourceName` for this arm. |
-| [`Close`](/dev/reference/apis/components/arm/#close) | Safely shut down the resource and prevent further use. |
+| [`GetEndPosition`](/reference/apis/components/arm/#getendposition) | Get the current position of the arm as a pose. |
+| [`MoveToPosition`](/reference/apis/components/arm/#movetoposition) | Move the end of the arm in a straight line to the desired pose, relative to the base of the arm. |
+| [`MoveToJointPositions`](/reference/apis/components/arm/#movetojointpositions) | Move each joint on the arm to the position specified in `positions`. |
+| [`MoveThroughJointPositions`](/reference/apis/components/arm/#movethroughjointpositions) | Move the arm's joints through the given positions in the order they are specified. |
+| [`GetJointPositions`](/reference/apis/components/arm/#getjointpositions) | Get the current position of each joint on the arm. |
+| [`Get3DModels`](/reference/apis/components/arm/#get3dmodels) | Get the 3D models of the arm. |
+| [`GetKinematics`](/reference/apis/components/arm/#getkinematics) | Get the kinematics information associated with the arm as the format and byte contents of the kinematics file. |
+| [`IsMoving`](/reference/apis/components/arm/#ismoving) | Get if the arm is currently moving. |
+| [`Stop`](/reference/apis/components/arm/#stop) | Stop all motion of the arm. |
+| [`GetGeometries`](/reference/apis/components/arm/#getgeometries) | Get all the geometries associated with the arm in its current configuration, in the frame of the arm. |
+| [`Reconfigure`](/reference/apis/components/arm/#reconfigure) | Reconfigure this resource. |
+| [`DoCommand`](/reference/apis/components/arm/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
+| [`GetResourceName`](/reference/apis/components/arm/#getresourcename) | Get the `ResourceName` for this arm. |
+| [`Close`](/reference/apis/components/arm/#close) | Safely shut down the resource and prevent further use. |
diff --git a/static/include/components/apis/generated/arm.md b/static/include/components/apis/generated/arm.md
index d6acb1edbd..211fb4274e 100644
--- a/static/include/components/apis/generated/arm.md
+++ b/static/include/components/apis/generated/arm.md
@@ -12,10 +12,10 @@ Get the current position of the arm as a [pose](/operate/mobility/orientation-ve
 
 **Returns:**
 
-- ([viam.components.arm.Pose](https://python.viam.dev/autoapi/viam/components/arm/index.html#viam.components.arm.Pose)): A representation of the arm’s current position as a 6 DOF (six degrees of freedom) pose.
-The `Pose` is composed of values for location and orientation with respect to the origin.
-Location is expressed as distance, which is represented by x, y, and z coordinate values.
-Orientation is expressed as an orientation vector, which is represented by o\_x, o\_y, o\_z, and theta values.
+- ([viam.components.arm.Pose](https://python.viam.dev/autoapi/viam/components/arm/index.html#viam.components.arm.Pose)): :   A representation of the arm’s current position as a 6 DOF (six degrees of freedom) pose.
+    The `Pose` is composed of values for location and orientation with respect to the origin.
+    Location is expressed as distance, which is represented by x, y, and z coordinate values.
+    Orientation is expressed as an orientation vector, which is represented by o\_x, o\_y, o\_z, and theta values.
 
 **Example:**
 
@@ -77,11 +77,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Pose](https://flutter.viam.dev/viam_sdk/Pose-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Pose](https://flutter.viam.dev/viam_sdk/Pose-class.html)>
 
 **Example:**
 
@@ -197,11 +197,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 **Parameters:**
 
 - `pose` [Pose](https://flutter.viam.dev/viam_sdk/Pose-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -291,7 +291,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/c
 
 **Parameters:**
 
-- `jointPositionsList` (number) (required): List of angles (0\-360\) to move each joint to.
+- `jointPositionsList` (number) (required): List of angles (0-360) to move each joint to.
 - `extra` (None) (optional)
 - `callOptions` (CallOptions) (optional)
 
@@ -315,12 +315,12 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `positions` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)\> (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `positions` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)> (required)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -390,9 +390,9 @@ Get the current position of each joint on the arm.
 
 **Returns:**
 
-- ([viam.proto.component.arm.JointPositions](https://python.viam.dev/autoapi/viam/proto/component/arm/index.html#viam.proto.component.arm.JointPositions)): The current `JointPositions` for the arm.
-`JointPositions` can have one attribute, `values`, a list of joint positions with rotational values (degrees)
-and translational values (mm).
+- ([viam.proto.component.arm.JointPositions](https://python.viam.dev/autoapi/viam/proto/component/arm/index.html#viam.proto.component.arm.JointPositions)): :   The current `JointPositions` for the arm.
+    `JointPositions` can have one attribute, `values`, a list of joint positions with rotational values (degrees)
+    and translational values (mm).
 
 **Example:**
 
@@ -455,11 +455,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)>\>
 
 **Example:**
 
@@ -518,11 +518,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), [Mesh](https://flutter.viam.dev/viam_protos.common.common/Mesh-class.html)\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), [Mesh](https://flutter.viam.dev/viam_protos.common.common/Mesh-class.html)>\>
 
 **Example:**
 
@@ -549,10 +549,11 @@ Get the kinematics information associated with the arm as the format and byte co
 
 **Returns:**
 
-- (Tuple[[KinematicsFileFormat.ValueType](https://python.viam.dev/autoapi/viam/components/arm/index.html#viam.components.arm.KinematicsFileFormat), [bytes](https://docs.python.org/3/library/stdtypes.html#bytes-objects)]): A tuple containing two values; the first \[0] value represents the format of the
-file, either in URDF format (`KinematicsFileFormat.KINEMATICS_FILE_FORMAT_URDF`) or
-Viam’s kinematic parameter format (spatial vector algebra) (`KinematicsFileFormat.KINEMATICS_FILE_FORMAT_SVA`),
-and the second \[1] value represents the byte contents of the file.
+- ([viam.components.KinematicsReturn](https://python.viam.dev/autoapi/viam/components/index.html#viam.components.KinematicsReturn)): :   A tuple containing two values; the first [0] value represents the format of the
+    file, either in URDF format (`KinematicsFileFormat.KINEMATICS_FILE_FORMAT_URDF`) or
+    Viam’s kinematic parameter format (spatial vector algebra) (`KinematicsFileFormat.KINEMATICS_FILE_FORMAT_SVA`),
+    and the second [1] value represents the byte contents of the file.
+    If available, a third [2] value provides meshes keyed by URDF filepath.
 
 **Example:**
 
@@ -596,7 +597,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Returns:**
 
-- (Promise< { joints: { axis: [PlainMessage](https://ts.viam.dev/types/PlainMessage.html); id: string; max: number; min: number; parent: string; type: string; }[]; kinematic_param_type: "SVA" | "URDF" | "UNSPECIFIED"; links: [Frame](https://ts.viam.dev/classes/appRobotApi.Frame.html)[]; name: string; },>)
+- (Promise<GetKinematicsResult>): The legacy kinematics data shape or the newer object containing
+kinematics data plus a map of URDF mesh file paths to mesh data.
 
 **Example:**
 
@@ -606,7 +608,7 @@ const kinematics = await arm.getKinematics();
 console.log(kinematics);
 
 For more information, see [Arm
-API](https://docs.viam.com/dev/reference/apis/components/arm/#getkinematics).
+API](https://docs.viam.com/reference/apis/components/arm/#getkinematics).
 ```
 
 For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/ArmClient.html#getkinematics).
@@ -627,7 +629,7 @@ Get if the arm is currently moving.
 
 **Returns:**
 
-- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): Whether the arm is moving.
+- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): :   Whether the arm is moving.
 
 **Example:**
 
@@ -701,7 +703,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[bool](https://api.flutter.dev/flutter/dart-core/bool-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[bool](https://api.flutter.dev/flutter/dart-core/bool-class.html)>
 
 **Example:**
 
@@ -791,11 +793,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -823,7 +825,7 @@ The [motion](/operate/reference/services/motion/) and [navigation](/operate/refe
 
 **Returns:**
 
-- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): The geometries associated with the Component.
+- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): :   The geometries associated with the Component.
 
 **Example:**
 
@@ -921,7 +923,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own arm and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own arm and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -933,7 +935,7 @@ If you are implementing your own arm and want to add features that have no corre
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Raises:**
 
@@ -978,7 +980,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -988,12 +991,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -1004,11 +1011,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> (required)
+- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -1036,7 +1043,7 @@ Get the `ResourceName` for this arm.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/components/apis/generated/audio_in-table.md b/static/include/components/apis/generated/audio_in-table.md
index 336e7d4a26..a93ed3cb94 100644
--- a/static/include/components/apis/generated/audio_in-table.md
+++ b/static/include/components/apis/generated/audio_in-table.md
@@ -1,10 +1,10 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`GetAudio`](/dev/reference/apis/components/audio-in/#getaudio) | Get a stream of audio from the device. |
-| [`GetProperties`](/dev/reference/apis/components/audio-in/#getproperties) | Get the audio device’s properties. |
-| [`GetGeometries`](/dev/reference/apis/components/audio-in/#getgeometries) | Get all the geometries associated with the audio in component in its current configuration, in the frame of the audio in component. |
-| [`Reconfigure`](/dev/reference/apis/components/audio-in/#reconfigure) | Reconfigure this resource. |
-| [`DoCommand`](/dev/reference/apis/components/audio-in/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
-| [`GetResourceName`](/dev/reference/apis/components/audio-in/#getresourcename) | Get the `ResourceName` for this audio in component. |
-| [`Close`](/dev/reference/apis/components/audio-in/#close) | Safely shut down the resource and prevent further use. |
+| [`GetAudio`](/reference/apis/components/audio-in/#getaudio) | Get a stream of audio from the device. |
+| [`GetProperties`](/reference/apis/components/audio-in/#getproperties) | Get the audio device’s properties. |
+| [`GetGeometries`](/reference/apis/components/audio-in/#getgeometries) | Get all the geometries associated with the audio in component in its current configuration, in the frame of the audio in component. |
+| [`Reconfigure`](/reference/apis/components/audio-in/#reconfigure) | Reconfigure this resource. |
+| [`DoCommand`](/reference/apis/components/audio-in/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
+| [`GetResourceName`](/reference/apis/components/audio-in/#getresourcename) | Get the `ResourceName` for this audio in component. |
+| [`Close`](/reference/apis/components/audio-in/#close) | Safely shut down the resource and prevent further use. |
diff --git a/static/include/components/apis/generated/audio_in.md b/static/include/components/apis/generated/audio_in.md
index f993707ee8..13fe65d73a 100644
--- a/static/include/components/apis/generated/audio_in.md
+++ b/static/include/components/apis/generated/audio_in.md
@@ -80,11 +80,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 - `codec` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (optional)
 - `durationSeconds` [double](https://api.flutter.dev/flutter/dart-core/double-class.html)? (optional)
 - `previousTimestampNanoseconds` [Int64](https://pub.dev/documentation/fixnum/1.1.1/fixnum/Int64-class.html)? (optional)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Stream](https://api.flutter.dev/flutter/dart-async/Stream-class.html)\<[GetAudioResponse](https://flutter.viam.dev/viam_protos.component.audioin/GetAudioResponse-class.html)\>
+- [Stream](https://api.flutter.dev/flutter/dart-async/Stream-class.html)<[GetAudioResponse](https://flutter.viam.dev/viam_protos.component.audioin/GetAudioResponse-class.html)>
 
 For more information, see the [Flutter SDK Docs](https://flutter.viam.dev/viam_sdk/AudioInClient/getAudio.html).
 
@@ -104,7 +104,7 @@ Get the audio device’s properties.
 
 **Returns:**
 
-- (viam.components.audio_in.audio_in.AudioIn.Properties): The properties of the audio in device.
+- ([viam.components.audio_in.audio_in.AudioIn.Properties](https://python.viam.dev/autoapi/viam/components/audio_in/audio_in/index.html#viam.components.audio_in.audio_in.AudioIn.Properties)): :   The properties of the audio in device.
 
 **Example:**
 
@@ -135,11 +135,12 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/c
 
 **Parameters:**
 
+- `extra` (None) (optional)
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
 
-- (Promise< { numChannels: number; sampleRateHz: number; supportedCodecs: string[] },>)
+- (Promise< { numChannels: number; sampleRateHz: number; supportedCodecs: string[] }, >)
 
 **Example:**
 
@@ -155,11 +156,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[GetPropertiesResponse](https://flutter.viam.dev/viam_protos.common.common/GetPropertiesResponse-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[GetPropertiesResponse](https://flutter.viam.dev/viam_protos.common.common/GetPropertiesResponse-class.html)>
 
 For more information, see the [Flutter SDK Docs](https://flutter.viam.dev/viam_sdk/AudioInClient/getProperties.html).
 
@@ -181,7 +182,7 @@ The [motion](/operate/reference/services/motion/) and [navigation](/operate/refe
 
 **Returns:**
 
-- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): The geometries associated with the Component.
+- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): :   The geometries associated with the Component.
 
 **Example:**
 
@@ -227,7 +228,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own arm and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own arm and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -239,7 +240,7 @@ If you are implementing your own arm and want to add features that have no corre
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Raises:**
 
@@ -284,7 +285,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -294,12 +296,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -310,11 +316,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> (required)
+- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -342,7 +348,7 @@ Get the `ResourceName` for this audio in component.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/components/apis/generated/audio_out-table.md b/static/include/components/apis/generated/audio_out-table.md
index bf62c25089..8528370478 100644
--- a/static/include/components/apis/generated/audio_out-table.md
+++ b/static/include/components/apis/generated/audio_out-table.md
@@ -1,10 +1,10 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`Play`](/dev/reference/apis/components/audio-out/#play) | Play the given audio data. |
-| [`GetProperties`](/dev/reference/apis/components/audio-out/#getproperties) | Get the audio device’s properties. |
-| [`GetGeometries`](/dev/reference/apis/components/audio-out/#getgeometries) | Get all the geometries associated with the audio out component in its current configuration, in the frame of the audio out component. |
-| [`Reconfigure`](/dev/reference/apis/components/audio-out/#reconfigure) | Reconfigure this resource. |
-| [`DoCommand`](/dev/reference/apis/components/audio-out/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
-| [`GetResourceName`](/dev/reference/apis/components/audio-out/#getresourcename) | Get the `ResourceName` for this audio out component. |
-| [`Close`](/dev/reference/apis/components/audio-out/#close) | Safely shut down the resource and prevent further use. |
+| [`Play`](/reference/apis/components/audio-out/#play) | Play the given audio data. |
+| [`GetProperties`](/reference/apis/components/audio-out/#getproperties) | Get the audio device’s properties. |
+| [`GetGeometries`](/reference/apis/components/audio-out/#getgeometries) | Get all the geometries associated with the audio out component in its current configuration, in the frame of the audio out component. |
+| [`Reconfigure`](/reference/apis/components/audio-out/#reconfigure) | Reconfigure this resource. |
+| [`DoCommand`](/reference/apis/components/audio-out/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
+| [`GetResourceName`](/reference/apis/components/audio-out/#getresourcename) | Get the `ResourceName` for this audio out component. |
+| [`Close`](/reference/apis/components/audio-out/#close) | Safely shut down the resource and prevent further use. |
diff --git a/static/include/components/apis/generated/audio_out.md b/static/include/components/apis/generated/audio_out.md
index 7ec10043c0..985b5ba377 100644
--- a/static/include/components/apis/generated/audio_out.md
+++ b/static/include/components/apis/generated/audio_out.md
@@ -80,11 +80,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 - `audioData` [Uint8List](https://api.flutter.dev/flutter/dart-typed_data/Uint8List-class.html) (optional)
 - `audioInfo` [AudioInfo](https://flutter.viam.dev/viam_protos.common.common/AudioInfo-class.html) (optional)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[PlayResponse](https://flutter.viam.dev/viam_protos.component.audioout/PlayResponse-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[PlayResponse](https://flutter.viam.dev/viam_protos.component.audioout/PlayResponse-class.html)>
 
 For more information, see the [Flutter SDK Docs](https://flutter.viam.dev/viam_sdk/AudioOutClient/play.html).
 
@@ -105,7 +105,7 @@ Get the audio device’s properties.
 
 **Returns:**
 
-- (viam.components.audio_out.audio_out.AudioOut.Properties): The properties of the audio output device.
+- ([viam.components.audio_out.audio_out.AudioOut.Properties](https://python.viam.dev/autoapi/viam/components/audio_out/audio_out/index.html#viam.components.audio_out.audio_out.AudioOut.Properties)): :   The properties of the audio output device.
 
 **Example:**
 
@@ -136,11 +136,12 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/c
 
 **Parameters:**
 
+- `extra` (None) (optional)
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
 
-- (Promise< { numChannels: number; sampleRateHz: number; supportedCodecs: string[] },>)
+- (Promise< { numChannels: number; sampleRateHz: number; supportedCodecs: string[] }, >)
 
 **Example:**
 
@@ -156,11 +157,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[GetPropertiesResponse](https://flutter.viam.dev/viam_protos.common.common/GetPropertiesResponse-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[GetPropertiesResponse](https://flutter.viam.dev/viam_protos.common.common/GetPropertiesResponse-class.html)>
 
 For more information, see the [Flutter SDK Docs](https://flutter.viam.dev/viam_sdk/AudioOutClient/getProperties.html).
 
@@ -182,7 +183,7 @@ The [motion](/operate/reference/services/motion/) and [navigation](/operate/refe
 
 **Returns:**
 
-- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): The geometries associated with the Component.
+- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): :   The geometries associated with the Component.
 
 **Example:**
 
@@ -228,7 +229,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own arm and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own arm and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -240,7 +241,7 @@ If you are implementing your own arm and want to add features that have no corre
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Raises:**
 
@@ -285,7 +286,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -295,12 +297,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -311,11 +317,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> (required)
+- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -343,7 +349,7 @@ Get the `ResourceName` for this audio out component.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/components/apis/generated/base-table.md b/static/include/components/apis/generated/base-table.md
index b01e16f042..3c6f63b566 100644
--- a/static/include/components/apis/generated/base-table.md
+++ b/static/include/components/apis/generated/base-table.md
@@ -1,15 +1,15 @@
 <!-- prettier-ignore -->
 | Method Name | Description | `viam-micro-server` Support |
 | ----------- | ----------- | --------------------------- |
-| [`MoveStraight`](/dev/reference/apis/components/base/#movestraight) | Move the base in a straight line across the given distance (mm) at the given velocity (mm/sec). |  |
-| [`Spin`](/dev/reference/apis/components/base/#spin) | Turn the base in place, rotating it to the given angle (degrees) at the given angular velocity (degrees/sec). |  |
-| [`SetPower`](/dev/reference/apis/components/base/#setpower) | Set the linear and angular power of the base, represented as a percentage of max power for each direction in the range of [-1.0 to 1.0]. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`SetVelocity`](/dev/reference/apis/components/base/#setvelocity) | Set the linear velocity (mm/sec) and angular velocity (degrees/sec) of the base. |  |
-| [`GetProperties`](/dev/reference/apis/components/base/#getproperties) | Get the width and turning radius of the {{< glossary_tooltip term_id="model" text="model" >}} of base in meters. |  |
-| [`IsMoving`](/dev/reference/apis/components/base/#ismoving) | Returns whether the base is actively moving (or attempting to move) under its own power. |  |
-| [`Stop`](/dev/reference/apis/components/base/#stop) | Stop the base from moving immediately. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetGeometries`](/dev/reference/apis/components/base/#getgeometries) | Get all the geometries associated with the base in its current configuration, in the frame of the base. |  |
-| [`Reconfigure`](/dev/reference/apis/components/base/#reconfigure) | Reconfigure this resource. |  |
-| [`DoCommand`](/dev/reference/apis/components/base/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetResourceName`](/dev/reference/apis/components/base/#getresourcename) | Get the `ResourceName` for this base. |  |
-| [`Close`](/dev/reference/apis/components/base/#close) | Safely shut down the resource and prevent further use. |  |
+| [`MoveStraight`](/reference/apis/components/base/#movestraight) | Move the base in a straight line across the given distance (mm) at the given velocity (mm/sec). |  |
+| [`Spin`](/reference/apis/components/base/#spin) | Turn the base in place, rotating it to the given angle (degrees) at the given angular velocity (degrees/sec). |  |
+| [`SetPower`](/reference/apis/components/base/#setpower) | Set the linear and angular power of the base, represented as a percentage of max power for each direction in the range of [-1.0 to 1.0]. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`SetVelocity`](/reference/apis/components/base/#setvelocity) | Set the linear velocity (mm/sec) and angular velocity (degrees/sec) of the base. |  |
+| [`GetProperties`](/reference/apis/components/base/#getproperties) | Get the width and turning radius of the {{< glossary_tooltip term_id="model" text="model" >}} of base in meters. |  |
+| [`IsMoving`](/reference/apis/components/base/#ismoving) | Returns whether the base is actively moving (or attempting to move) under its own power. |  |
+| [`Stop`](/reference/apis/components/base/#stop) | Stop the base from moving immediately. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetGeometries`](/reference/apis/components/base/#getgeometries) | Get all the geometries associated with the base in its current configuration, in the frame of the base. |  |
+| [`Reconfigure`](/reference/apis/components/base/#reconfigure) | Reconfigure this resource. |  |
+| [`DoCommand`](/reference/apis/components/base/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetResourceName`](/reference/apis/components/base/#getresourcename) | Get the `ResourceName` for this base. |  |
+| [`Close`](/reference/apis/components/base/#close) | Safely shut down the resource and prevent further use. |  |
diff --git a/static/include/components/apis/generated/base.md b/static/include/components/apis/generated/base.md
index 38a1e822c0..c55fd9e71c 100644
--- a/static/include/components/apis/generated/base.md
+++ b/static/include/components/apis/generated/base.md
@@ -92,11 +92,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 - `distance` [int](https://api.flutter.dev/flutter/dart-core/int-class.html) (required)
 - `velocity` [double](https://api.flutter.dev/flutter/dart-core/double-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -199,11 +199,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 - `angle` [double](https://api.flutter.dev/flutter/dart-core/double-class.html) (required)
 - `velocity` [double](https://api.flutter.dev/flutter/dart-core/double-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -311,8 +311,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/c
 
 **Parameters:**
 
-- `linear` ([PlainMessage](https://ts.viam.dev/types/PlainMessage.html)) (required): Desired linear power percentage from \-1 to 1\.
-- `angular` ([PlainMessage](https://ts.viam.dev/types/PlainMessage.html)) (required): Desired angular power percentage from \-1 to 1\.
+- `linear` ([PlainMessage](https://ts.viam.dev/types/PlainMessage.html)) (required): Desired linear power percentage from -1 to 1.
+- `angular` ([PlainMessage](https://ts.viam.dev/types/PlainMessage.html)) (required): Desired angular power percentage from -1 to 1.
 - `extra` (None) (optional)
 - `callOptions` (CallOptions) (optional)
 
@@ -359,11 +359,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 - `linear` [Vector3](https://flutter.viam.dev/viam_sdk/Vector3-class.html) (required)
 - `angular` [Vector3](https://flutter.viam.dev/viam_sdk/Vector3-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -477,11 +477,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 - `linear` [Vector3](https://flutter.viam.dev/viam_sdk/Vector3-class.html) (required)
 - `angular` [Vector3](https://flutter.viam.dev/viam_sdk/Vector3-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -511,7 +511,7 @@ Get the width and turning radius of the {{< glossary_tooltip term_id="model" tex
 
 **Returns:**
 
-- ([viam.components.base.Base.Properties](https://python.viam.dev/autoapi/viam/components/base/index.html#viam.components.base.Base.Properties)): The properties of the base.
+- ([viam.components.base.Base.Properties](https://python.viam.dev/autoapi/viam/components/base/index.html#viam.components.base.Base.Properties)): :   The properties of the base.
 
 **Example:**
 
@@ -592,11 +592,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[BaseProperties](https://flutter.viam.dev/viam_sdk/BaseProperties.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[BaseProperties](https://flutter.viam.dev/viam_sdk/BaseProperties.html)>
 
 **Example:**
 
@@ -622,7 +622,7 @@ Returns whether the base is actively moving (or attempting to move) under its ow
 
 **Returns:**
 
-- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): Whether the base is moving.
+- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): :   Whether the base is moving.
 
 **Example:**
 
@@ -693,7 +693,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[bool](https://api.flutter.dev/flutter/dart-core/bool-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[bool](https://api.flutter.dev/flutter/dart-core/bool-class.html)>
 
 **Example:**
 
@@ -787,11 +787,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -819,7 +819,7 @@ The [motion](/operate/reference/services/motion/) and [navigation](/operate/refe
 
 **Returns:**
 
-- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): The geometries associated with the Component.
+- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): :   The geometries associated with the Component.
 
 **Example:**
 
@@ -916,7 +916,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own base and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own base and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 Supported by `viam-micro-server`.
 
 {{< tabs >}}
@@ -929,7 +929,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Raises:**
 
@@ -974,7 +974,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -984,12 +985,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -1000,11 +1005,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> (required)
+- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -1032,7 +1037,7 @@ Get the `ResourceName` for this base.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/components/apis/generated/board-table.md b/static/include/components/apis/generated/board-table.md
index f085932fe1..064b370691 100644
--- a/static/include/components/apis/generated/board-table.md
+++ b/static/include/components/apis/generated/board-table.md
@@ -1,22 +1,22 @@
 <!-- prettier-ignore -->
 | Method Name | Description | `viam-micro-server` Support |
 | ----------- | ----------- | --------------------------- |
-| [`SetGPIO`](/dev/reference/apis/components/board/#setgpio) | Set the digital signal output of this pin to low (0V) or high (active, >0V). | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetGPIO`](/dev/reference/apis/components/board/#getgpio) | Get if the digital signal output of this pin is high (active, >0V). | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetPWM`](/dev/reference/apis/components/board/#getpwm) | Get the pin's pulse-width modulation (PWM) duty cycle: a float [`0.0`, `1.0`] representing the percentage of time the digital signal output by this pin is in the high state (active, >0V) relative to the interval period of the PWM signal (interval period being the mathematical inverse of the PWM frequency). | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`SetPWM`](/dev/reference/apis/components/board/#setpwm) | Set the pin's Pulse-width modulation (PWM) duty cycle: a float [`0.0`, `1.0`] indicating the percentage of time the digital signal output of this pin is in the high state (active, >0V) relative to the interval period of the PWM signal (interval period being the mathematical inverse of the PWM frequency). | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`PWMFrequency`](/dev/reference/apis/components/board/#pwmfrequency) | Get the PWM frequency of the GPIO pin. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`SetPWMFrequency`](/dev/reference/apis/components/board/#setpwmfrequency) | Set the pin to the given PWM `frequency` (in Hz). When `frequency` is 0, it will use the board’s default PWM frequency. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetDigitalInterruptValue`](/dev/reference/apis/components/board/#getdigitalinterruptvalue) | Get the current value of a configured digital interrupt. |  |
-| [`ReadAnalogReader`](/dev/reference/apis/components/board/#readanalogreader) | Read the current integer value of the digital signal output by the ADC. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`WriteAnalog`](/dev/reference/apis/components/board/#writeanalog) | Write an analog value to a pin on the board. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`StreamTicks`](/dev/reference/apis/components/board/#streamticks) | Start a stream of `DigitalInterrupt` ticks. |  |
-| [`SetPowerMode`](/dev/reference/apis/components/board/#setpowermode) | Set the board to the indicated `PowerMode`. |  |
-| [`AnalogByName`](/dev/reference/apis/components/board/#analogbyname) | Get a configured `Analog` by `name`. |  |
-| [`DigitalInterruptByName`](/dev/reference/apis/components/board/#digitalinterruptbyname) | Get a DigitalInterrupt by `name`. |  |
-| [`GPIOPinByName`](/dev/reference/apis/components/board/#gpiopinbyname) | Get a `GPIOPin` by {{< glossary_tooltip term_id="pin-number" text="pin number" >}}. |  |
-| [`GetGeometries`](/dev/reference/apis/components/board/#getgeometries) | Get all the geometries associated with the board in its current configuration, in the frame of the board. |  |
-| [`Reconfigure`](/dev/reference/apis/components/board/#reconfigure) | Reconfigure this resource. |  |
-| [`DoCommand`](/dev/reference/apis/components/board/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetResourceName`](/dev/reference/apis/components/board/#getresourcename) | Get the `ResourceName` for this board. |  |
-| [`Close`](/dev/reference/apis/components/board/#close) | Safely shut down the resource and prevent further use. |  |
+| [`SetGPIO`](/reference/apis/components/board/#setgpio) | Set the digital signal output of this pin to low (0V) or high (active, >0V). | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetGPIO`](/reference/apis/components/board/#getgpio) | Get if the digital signal output of this pin is high (active, >0V). | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetPWM`](/reference/apis/components/board/#getpwm) | Get the pin's pulse-width modulation (PWM) duty cycle: a float [`0.0`, `1.0`] representing the percentage of time the digital signal output by this pin is in the high state (active, >0V) relative to the interval period of the PWM signal (interval period being the mathematical inverse of the PWM frequency). | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`SetPWM`](/reference/apis/components/board/#setpwm) | Set the pin's Pulse-width modulation (PWM) duty cycle: a float [`0.0`, `1.0`] indicating the percentage of time the digital signal output of this pin is in the high state (active, >0V) relative to the interval period of the PWM signal (interval period being the mathematical inverse of the PWM frequency). | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`PWMFrequency`](/reference/apis/components/board/#pwmfrequency) | Get the PWM frequency of the GPIO pin. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`SetPWMFrequency`](/reference/apis/components/board/#setpwmfrequency) | Set the pin to the given PWM `frequency` (in Hz). When `frequency` is 0, it will use the board’s default PWM frequency. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetDigitalInterruptValue`](/reference/apis/components/board/#getdigitalinterruptvalue) | Get the current value of a configured digital interrupt. |  |
+| [`ReadAnalogReader`](/reference/apis/components/board/#readanalogreader) | Read the current integer value of the digital signal output by the ADC. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`WriteAnalog`](/reference/apis/components/board/#writeanalog) | Write an analog value to a pin on the board. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`StreamTicks`](/reference/apis/components/board/#streamticks) | Start a stream of `DigitalInterrupt` ticks. |  |
+| [`SetPowerMode`](/reference/apis/components/board/#setpowermode) | Set the board to the indicated `PowerMode`. |  |
+| [`AnalogByName`](/reference/apis/components/board/#analogbyname) | Get a configured `Analog` by `name`. |  |
+| [`DigitalInterruptByName`](/reference/apis/components/board/#digitalinterruptbyname) | Get a DigitalInterrupt by `name`. |  |
+| [`GPIOPinByName`](/reference/apis/components/board/#gpiopinbyname) | Get a `GPIOPin` by {{< glossary_tooltip term_id="pin-number" text="pin number" >}}. |  |
+| [`GetGeometries`](/reference/apis/components/board/#getgeometries) | Get all the geometries associated with the board in its current configuration, in the frame of the board. |  |
+| [`Reconfigure`](/reference/apis/components/board/#reconfigure) | Reconfigure this resource. |  |
+| [`DoCommand`](/reference/apis/components/board/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetResourceName`](/reference/apis/components/board/#getresourcename) | Get the `ResourceName` for this board. |  |
+| [`Close`](/reference/apis/components/board/#close) | Safely shut down the resource and prevent further use. |  |
diff --git a/static/include/components/apis/generated/board.md b/static/include/components/apis/generated/board.md
index 6b7327c626..05e1ff6d4e 100644
--- a/static/include/components/apis/generated/board.md
+++ b/static/include/components/apis/generated/board.md
@@ -90,11 +90,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 - `pin` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
 - `high` [bool](https://api.flutter.dev/flutter/dart-core/bool-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -123,7 +123,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): Indicates if the state of the pin is high.
+- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): :   Indicates if the state of the pin is high.
 
 **Example:**
 
@@ -196,11 +196,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 **Parameters:**
 
 - `pin` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[bool](https://api.flutter.dev/flutter/dart-core/bool-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[bool](https://api.flutter.dev/flutter/dart-core/bool-class.html)>
 
 **Example:**
 
@@ -237,7 +237,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): The duty cycle.
+- ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): :   The duty cycle.
 
 **Example:**
 
@@ -291,7 +291,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/c
 
 **Returns:**
 
-- (Promise<number>): The duty cycle, which is a value from 0 to 1\.
+- (Promise<number>): The duty cycle, which is a value from 0 to 1.
 
 **Example:**
 
@@ -310,11 +310,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 **Parameters:**
 
 - `pin` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)>
 
 **Example:**
 
@@ -421,11 +421,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 - `pin` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
 - `dutyCyclePct` [double](https://api.flutter.dev/flutter/dart-core/double-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -454,7 +454,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): The PWM frequency.
+- ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): :   The PWM frequency.
 
 **Example:**
 
@@ -527,11 +527,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 **Parameters:**
 
 - `pin` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[int](https://api.flutter.dev/flutter/dart-core/int-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[int](https://api.flutter.dev/flutter/dart-core/int-class.html)>
 
 **Example:**
 
@@ -642,11 +642,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 - `pin` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
 - `frequencyHz` [int](https://api.flutter.dev/flutter/dart-core/int-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -675,7 +675,7 @@ The value is the number of times the interrupt has been interrupted with a tick.
 
 **Returns:**
 
-- ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): The current value.
+- ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): :   The current value.
 
 **Example:**
 
@@ -752,11 +752,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 **Parameters:**
 
 - `digitalInterruptName` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[int](https://api.flutter.dev/flutter/dart-core/int-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[int](https://api.flutter.dev/flutter/dart-core/int-class.html)>
 
 **Example:**
 
@@ -785,7 +785,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- (viam.components.board.board.Board.Analog.Value): The current value, including the min, max, and step\_size of the reader.
+- ([viam.components.board.board.Board.Analog.Value](https://python.viam.dev/autoapi/viam/components/board/board/index.html#viam.components.board.board.Board.Analog.Value)): :   The current value, including the min, max, and step\_size of the reader.
 
 **Example:**
 
@@ -865,11 +865,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 **Parameters:**
 
 - `analogReaderName` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[AnalogValue](https://flutter.viam.dev/viam_sdk/AnalogValue.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[AnalogValue](https://flutter.viam.dev/viam_sdk/AnalogValue.html)>
 
 **Example:**
 
@@ -974,11 +974,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 - `pin` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
 - `value` [int](https://api.flutter.dev/flutter/dart-core/int-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -1006,7 +1006,7 @@ Start a stream of `DigitalInterrupt` ticks.
 
 **Returns:**
 
-- (viam.components.board.board.TickStream): stream of ticks.
+- ([viam.components.board.board.TickStream](https://python.viam.dev/autoapi/viam/components/board/board/index.html#viam.components.board.board.TickStream)): :   stream of ticks.
 
 **Example:**
 
@@ -1095,12 +1095,12 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `interrupts` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\> (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `interrupts` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)> (required)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Stream](https://api.flutter.dev/flutter/dart-async/Stream-class.html)\<[Tick](https://flutter.viam.dev/viam_sdk/Tick.html)\>
+- [Stream](https://api.flutter.dev/flutter/dart-async/Stream-class.html)<[Tick](https://flutter.viam.dev/viam_sdk/Tick.html)>
 
 **Example:**
 
@@ -1135,6 +1135,7 @@ This is expected: the board has been successfully powered down and can no longer
 
 - `mode` ([viam.proto.component.board.PowerMode.ValueType](https://python.viam.dev/autoapi/viam/gen/component/board/v1/board_pb2/index.html#viam.gen.component.board.v1.board_pb2.PowerMode)) (required): The desired power mode.
 - `duration` ([datetime.timedelta](https://docs.python.org/3/library/datetime.html#timedelta-objects)) (optional): Requested duration to stay in power mode.
+- `extra` (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]) (optional): Extra options to pass to the underlying RPC call.
 - `timeout` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (optional): An option to set how long to wait (in seconds) before calling a time-out and closing the underlying RPC call.
 
 **Returns:**
@@ -1160,6 +1161,7 @@ For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/
 - `ctx` [(Context)](https://pkg.go.dev/context#Context): A Context carries a deadline, a cancellation signal, and other values across API boundaries.
 - `mode` [(pb.PowerMode)](https://pkg.go.dev/go.viam.com/api/component/board/v1#PowerMode): Options to specify power usage of the board: `boardpb.PowerMode_POWER_MODE_UNSPECIFIED`, `boardpb.PowerMode_POWER_MODE_NORMAL`, and `boardpb.PowerMode_POWER_MODE_OFFLINE_DEEP`.
 - `duration` [(*time.Duration)](https://pkg.go.dev/time#Duration): If provided, the board will exit the given power mode after the specified duration.
+- `extra` [(map[string]interface{})](https://go.dev/blog/maps): Extra options to pass to the underlying RPC call.
 
 **Returns:**
 
@@ -1210,11 +1212,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 - `powerMode` [PowerMode](https://flutter.viam.dev/viam_protos.component.board/PowerMode-class.html) (required)
 - `seconds` [int](https://api.flutter.dev/flutter/dart-core/int-class.html) (required)
 - `nanos` [int](https://api.flutter.dev/flutter/dart-core/int-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -1243,7 +1245,7 @@ Get a configured `Analog` by `name`.
 
 **Returns:**
 
-- ([viam.components.board.board.Board.Analog](https://python.viam.dev/autoapi/viam/components/board/board/index.html#viam.components.board.board.Board.Analog)): The analog reader or writer.
+- ([viam.components.board.board.Board.Analog](https://python.viam.dev/autoapi/viam/components/board/board/index.html#viam.components.board.board.Board.Analog)): :   The analog reader or writer.
 
 **Example:**
 
@@ -1294,7 +1296,7 @@ Get a DigitalInterrupt by `name`.
 
 **Returns:**
 
-- ([viam.components.board.board.Board.DigitalInterrupt](https://python.viam.dev/autoapi/viam/components/board/board/index.html#viam.components.board.board.Board.DigitalInterrupt)): The digital interrupt.
+- ([viam.components.board.board.Board.DigitalInterrupt](https://python.viam.dev/autoapi/viam/components/board/board/index.html#viam.components.board.board.Board.DigitalInterrupt)): :   The digital interrupt.
 
 **Example:**
 
@@ -1347,7 +1349,7 @@ Get a `GPIOPin` by {{< glossary_tooltip term_id="pin-number" text="pin number" >
 
 **Returns:**
 
-- ([viam.components.board.board.Board.GPIOPin](https://python.viam.dev/autoapi/viam/components/board/board/index.html#viam.components.board.board.Board.GPIOPin)): The pin.
+- ([viam.components.board.board.Board.GPIOPin](https://python.viam.dev/autoapi/viam/components/board/board/index.html#viam.components.board.board.Board.GPIOPin)): :   The pin.
 
 **Example:**
 
@@ -1401,7 +1403,7 @@ The [motion](/operate/reference/services/motion/) and [navigation](/operate/refe
 
 **Returns:**
 
-- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): The geometries associated with the Component.
+- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): :   The geometries associated with the Component.
 
 **Example:**
 
@@ -1447,7 +1449,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own board and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own board and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 Supported by `viam-micro-server`.
 
 {{< tabs >}}
@@ -1460,7 +1462,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Raises:**
 
@@ -1505,7 +1507,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -1515,12 +1518,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -1531,11 +1538,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> (required)
+- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -1563,7 +1570,7 @@ Get the `ResourceName` for this board.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/components/apis/generated/button-table.md b/static/include/components/apis/generated/button-table.md
index ea935cacc1..4588bcfb61 100644
--- a/static/include/components/apis/generated/button-table.md
+++ b/static/include/components/apis/generated/button-table.md
@@ -1,8 +1,8 @@
 <!-- prettier-ignore -->
 | Method Name | Description | `viam-micro-server` Support |
 | ----------- | ----------- | --------------------------- |
-| [`Push`](/dev/reference/apis/components/button/#push) | Push the button. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`Reconfigure`](/dev/reference/apis/components/button/#reconfigure) | Reconfigure this resource. |  |
-| [`DoCommand`](/dev/reference/apis/components/button/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetResourceName`](/dev/reference/apis/components/button/#getresourcename) | Get the `ResourceName` for this button. |  |
-| [`Close`](/dev/reference/apis/components/button/#close) | Safely shut down the resource and prevent further use. |  |
+| [`Push`](/reference/apis/components/button/#push) | Push the button. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`Reconfigure`](/reference/apis/components/button/#reconfigure) | Reconfigure this resource. |  |
+| [`DoCommand`](/reference/apis/components/button/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetResourceName`](/reference/apis/components/button/#getresourcename) | Get the `ResourceName` for this button. |  |
+| [`Close`](/reference/apis/components/button/#close) | Safely shut down the resource and prevent further use. |  |
diff --git a/static/include/components/apis/generated/button.md b/static/include/components/apis/generated/button.md
index f6548253ff..76ab9f81bd 100644
--- a/static/include/components/apis/generated/button.md
+++ b/static/include/components/apis/generated/button.md
@@ -76,11 +76,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -121,7 +121,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own button and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own button and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 Supported by `viam-micro-server`.
 
 {{< tabs >}}
@@ -134,7 +134,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Raises:**
 
@@ -179,7 +179,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -189,12 +190,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -205,11 +210,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> (required)
+- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -237,7 +242,7 @@ Get the `ResourceName` for this button.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/components/apis/generated/camera-table.md b/static/include/components/apis/generated/camera-table.md
index dd5b3d9342..58c8ecc2f7 100644
--- a/static/include/components/apis/generated/camera-table.md
+++ b/static/include/components/apis/generated/camera-table.md
@@ -1,11 +1,10 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`GetImage`](/dev/reference/apis/components/camera/#getimage) | _Deprecated_. |
-| [`GetImages`](/dev/reference/apis/components/camera/#getimages) | Get simultaneous images from different imagers, along with associated metadata. |
-| [`GetPointCloud`](/dev/reference/apis/components/camera/#getpointcloud) | Get a point cloud from the camera as bytes with a MIME type describing the structure of the data. |
-| [`GetProperties`](/dev/reference/apis/components/camera/#getproperties) | Get the camera intrinsic parameters and camera distortion, as well as whether the camera supports returning point clouds. |
-| [`DoCommand`](/dev/reference/apis/components/camera/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
-| [`GetGeometries`](/dev/reference/apis/components/camera/#getgeometries) | Get all the geometries associated with the camera in its current configuration, in the frame of the camera. |
-| [`GetResourceName`](/dev/reference/apis/components/camera/#getresourcename) | Get the `ResourceName` for this camera. |
-| [`Close`](/dev/reference/apis/components/camera/#close) | Safely shut down the resource and prevent further use. |
+| [`GetImages`](/reference/apis/components/camera/#getimages) | `GetImages` is used for getting simultaneous images from different imagers from 3D cameras along with associated metadata, and single images from non-3D cameras, for example webcams, RTSP cameras, etc. in the image list in the response. |
+| [`GetPointCloud`](/reference/apis/components/camera/#getpointcloud) | Get a point cloud from the camera as bytes with a MIME type describing the structure of the data. |
+| [`GetProperties`](/reference/apis/components/camera/#getproperties) | Get the camera intrinsic parameters and camera distortion, as well as whether the camera supports returning point clouds. |
+| [`DoCommand`](/reference/apis/components/camera/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
+| [`GetGeometries`](/reference/apis/components/camera/#getgeometries) | Get all the geometries associated with the camera in its current configuration, in the frame of the camera. |
+| [`GetResourceName`](/reference/apis/components/camera/#getresourcename) | Get the `ResourceName` for this camera. |
+| [`Close`](/reference/apis/components/camera/#close) | Safely shut down the resource and prevent further use. |
diff --git a/static/include/components/apis/generated/camera.md b/static/include/components/apis/generated/camera.md
index d7e67c0ff7..d2ca68d4fd 100644
--- a/static/include/components/apis/generated/camera.md
+++ b/static/include/components/apis/generated/camera.md
@@ -1,189 +1,7 @@
-### GetImage
-
-_Deprecated. Use [`GetImages`](#getimages) instead._
-
-Return an image from the camera.
-You can request a specific MIME type but the returned MIME type is not guaranteed.
-If the server does not know how to return the specified MIME type, the server returns the image in another format instead.
-
-The available MIME types are:
-
-- `image/vnd.viam.rgba`
-- `image/vnd.viam.rgbalazy`
-- `image/jpeg`
-- `image/png`
-- `pointcloud/pcd`
-- `image/qoi`
-
-{{< tabs >}}
-{{% tab name="Python" %}}
-
-**Parameters:**
-
-- `mime_type` ([str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)) (optional): The desired mime type of the image. This does not guarantee output type.
-- `extra` (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]) (optional): Extra options to pass to the underlying RPC call.
-- `timeout` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (optional): An option to set how long to wait (in seconds) before calling a time-out and closing the underlying RPC call.
-
-**Returns:**
-
-- ([viam.media.video.ViamImage](https://python.viam.dev/autoapi/viam/media/video/index.html#viam.media.video.ViamImage)): The frame.
-
-**Example:**
-
-```python {class="line-numbers linkable-line-numbers"}
-my_camera = Camera.from_robot(machine, "my_camera")
-frame = await my_camera.get_image()
-print(f"Frame: {frame}")
-```
-
-If the `mime_type` of your image is `image/vnd.viam.dep`, pass the returned image data to the Viam Python SDK's [`ViamImage.bytes_to_depth_array()`](https://python.viam.dev/autoapi/viam/media/video/index.html#viam.media.video.ViamImage.bytes_to_depth_array) method to decode the raw image data to a standard 2D image representation.
-
-For example:
-
-```python {class="line-numbers linkable-line-numbers"}
-from viam.media.video import CameraMimeType
-
-my_camera = Camera.from_robot(robot=machine, name="my_camera")
-
-# Assume "frame" has a mime_type of "image/vnd.viam.dep"
-frame = await my_camera.get_image(mime_type = CameraMimeType.VIAM_RAW_DEPTH)
-
-# Convert "frame" to a standard 2D image representation.
-# Remove the 1st 3x8 bytes and reshape the raw bytes to List[List[Int]].
-standard_frame = frame.bytes_to_depth_array()
-```
-
-In addition, the Python SDK provides the helper functions `viam_to_pil_image` and `pil_to_viam_image` to decode the `ViamImage` into a [`PIL Image`](https://omz-software.com/pythonista/docs/ios/Image.html) and vice versa.
-
-For example:
-
-```python {class="line-numbers linkable-line-numbers"}
-from viam.media.utils.pil import pil_to_viam_image, viam_to_pil_image
-
-# Get the ViamImage from your camera.
-frame = await my_camera.get_image()
-
-# Convert "frame" to a PIL Image representation.
-pil_frame = viam_to_pil_image(frame)
-
-# Use methods from the PIL Image class to get size.
-x, y = pil_frame.size[0], pil_frame.size[1]
-# Crop image to get only the left two fifths of the original image.
-cropped_pil_frame = pil_frame.crop((0, 0, x / 2.5, y))
-
-# Convert back to ViamImage.
-cropped_frame = pil_to_viam_image(cropped_pil_frame, frame.mime_type)
-```
-
-For documentation on available MIME types, see [`CameraMimeType`](https://python.viam.dev/autoapi/viam/media/video/index.html#viam.media.video.CameraMimeType).
-For more information on working with `ViamImage`, see [`ViamImage`](https://python.viam.dev/autoapi/viam/media/video/index.html#viam.media.video.ViamImage).
-
-{{% alert title="Tip" color="tip" %}}
-
-Be sure to close the image when finished.
-
-{{% /alert %}}
-
-For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/components/camera/client/index.html#viam.components.camera.client.CameraClient.get_image).
-
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-**Parameters:**
-
-- `ctx` [(Context)](https://pkg.go.dev/context#Context): A Context carries a deadline, a cancellation signal, and other values across API boundaries.
-- `mimeType` [(string)](https://pkg.go.dev/builtin#string): The desired MIME type of the image. This does not guarantee output type.
-- `extra` [(map[string]interface{})](https://go.dev/blog/maps): Extra options to pass to the underlying RPC call.
-
-**Returns:**
-
-- [([]byte)](https://pkg.go.dev/builtin#byte): The frame as bytes.
-- [(ImageMetadata)](https://pkg.go.dev/go.viam.com/rdk/components/camera#ImageMetadata): The associated metadata, containing the image MIME type.
-- [(error)](https://pkg.go.dev/builtin#error): An error, if one occurred.
-
-**Example:**
-
-```go {class="line-numbers linkable-line-numbers"}
-myCamera, err := camera.FromProvider(machine, "my_camera")
-imageBytes, mimeType, err := myCamera.Image(context.Background(), utils.MimeTypeJPEG, nil)
-```
-
-You can also try to directly decode as an `Image.Image` with the camera's `DecodeImageFromCamera` function:
-
-```go {class="line-numbers linkable-line-numbers"}
-myCamera, err := camera.FromProvider(machine, "my_camera")
-img, err = camera.DecodeImageFromCamera(context.Background(), utils.MimeTypeJPEG, nil, myCamera)
-```
-
-To use either method, be sure to import `"go.viam.com/rdk/utils"` at the beginning of your file.
-
-For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/components/camera#Camera).
-
-{{% /tab %}}
-{{% tab name="TypeScript" %}}
-
-**Parameters:**
-
-- `mimeType` ([MimeType](https://ts.viam.dev/types/MimeType.html)) (optional): A specific MIME type to request. This is not necessarily
-  the same type that will be returned.
-- `extra` (None) (optional)
-- `callOptions` (CallOptions) (optional)
-
-**Returns:**
-
-- (Promise<Uint8Array>)
-
-**Example:**
-
-```ts {class="line-numbers linkable-line-numbers"}
-const camera = new VIAM.CameraClient(machine, 'my_camera');
-const image = await camera.getImage();
-
-// Convert Uint8Array to base64
-const base64Image = btoa(
-  Array.from(image)
-    .map((byte) => String.fromCharCode(byte))
-    .join('')
-);
-
-// Convert image to base64 and display it
-const imageElement = document.createElement('img');
-imageElement.src = `data:image/jpeg;base64,${base64Image}`;
-const imageContainer = document.getElementById('#imageContainer');
-if (imageContainer) {
-  imageContainer.innerHTML = '';
-  imageContainer.appendChild(imageElement);
-}
-```
-
-For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/CameraClient.html#getimage).
-
-{{% /tab %}}
-{{% tab name="Flutter" %}}
-
-**Parameters:**
-
-- `mimeType` [MimeType](https://flutter.viam.dev/viam_sdk/MimeType-class.html)? (optional)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
-
-**Returns:**
-
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[ViamImage](https://flutter.viam.dev/viam_sdk/ViamImage-class.html)\>
-
-**Example:**
-
-```dart {class="line-numbers linkable-line-numbers"}
-var nextImage = await myCamera.image();
-```
-
-For more information, see the [Flutter SDK Docs](https://flutter.viam.dev/viam_sdk/Camera/image.html).
-
-{{% /tab %}}
-{{< /tabs >}}
-
 ### GetImages
 
 {{% alert title="Usage" color="note" %}}
+
 You can use the [`rgb-d-overlay` module](https://app.viam.com/module/viam/rgb-d-overlay) to view and compare the camera streams returned by this method.
 See the [module readme](https://github.com/viam-labs/rgb-d-overlay) for further instructions.
 {{% /alert %}}
@@ -202,8 +20,8 @@ Multiple images returned from `GetImages()` do not represent a time series of im
 
 **Returns:**
 
-- (Tuple[Sequence[[video.NamedImage](https://python.viam.dev/autoapi/viam/media/video/index.html#viam.media.video.NamedImage)], [common.ResponseMetadata](https://python.viam.dev/autoapi/viam/gen/common/v1/common_pb2/index.html#viam.gen.common.v1.common_pb2.ResponseMetadata)]): A tuple containing two values; the first \[0] a list of images
-returned from the camera system, and the second \[1] the metadata associated with this response.
+- (Tuple[Sequence[[video.NamedImage](https://python.viam.dev/autoapi/viam/media/video/index.html#viam.media.video.NamedImage)], [common.ResponseMetadata](https://python.viam.dev/autoapi/viam/gen/common/v1/common_pb2/index.html#viam.gen.common.v1.common_pb2.ResponseMetadata)]): :   A tuple containing two values; the first [0] a list of images
+    returned from the camera system, and the second [1] the metadata associated with this response.
 
 **Example:**
 
@@ -254,7 +72,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/c
 
 **Returns:**
 
-- (Promise< { images: { image: Uint8Array; mimeType: string; sourceName: string }[]; metadata: ResponseMetadata; },>)
+- (Promise< { images: { image: Uint8Array; mimeType: string; sourceName: string }[]; metadata: ResponseMetadata; }, >)
 
 **Example:**
 
@@ -270,12 +88,12 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `filterSourceNames` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)\>? (optional)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `filterSourceNames` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html)>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[GetImagesResult](https://flutter.viam.dev/viam_sdk/GetImagesResult-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[GetImagesResult](https://flutter.viam.dev/viam_sdk/GetImagesResult-class.html)>
 
 **Example:**
 
@@ -304,8 +122,8 @@ The consumer of this call should decode the bytes into the format suggested by t
 
 **Returns:**
 
-- (Tuple[[bytes](https://docs.python.org/3/library/stdtypes.html#bytes-objects), [str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]): A tuple containing two values; the first \[0] the pointcloud data,
-and the second \[1] the mimetype of the pointcloud (for example, PCD).
+- (Tuple[[bytes](https://docs.python.org/3/library/stdtypes.html#bytes-objects), [str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]): :   A tuple containing two values; the first [0] the pointcloud data,
+    and the second [1] the mimetype of the pointcloud (for example, PCD).
 
 **Example:**
 
@@ -376,11 +194,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[ViamImage](https://flutter.viam.dev/viam_sdk/ViamImage-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[ViamImage](https://flutter.viam.dev/viam_sdk/ViamImage-class.html)>
 
 **Example:**
 
@@ -406,7 +224,8 @@ Get the camera intrinsic parameters and camera distortion, as well as whether th
 
 **Returns:**
 
-- (viam.components.camera.Camera.Properties): The properties of the camera.
+- ([viam.components.camera.Camera.Properties](https://python.viam.dev/autoapi/viam/components/camera/index.html#viam.components.camera.Camera.Properties)): :   The properties of the camera, including intrinsic parameters, distortion parameters,
+    supported mime types, and optionally extrinsic parameters (position relative to a reference frame).
 
 **Example:**
 
@@ -461,7 +280,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[CameraProperties](https://flutter.viam.dev/viam_sdk/CameraProperties.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[CameraProperties](https://flutter.viam.dev/viam_sdk/CameraProperties.html)>
 
 **Example:**
 
@@ -479,7 +298,7 @@ For more information, see the [Flutter SDK Docs](https://flutter.viam.dev/viam_s
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own camera and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own camera and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -491,7 +310,7 @@ If you are implementing your own camera and want to add features that have no co
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Raises:**
 
@@ -536,7 +355,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -546,12 +366,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -562,11 +386,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> (required)
+- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -596,7 +420,7 @@ The [motion](/operate/reference/services/motion/) and [navigation](/operate/refe
 
 **Returns:**
 
-- ([Sequence[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): The geometries associated with the Component.
+- ([Sequence[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): :   The geometries associated with the Component.
 
 **Example:**
 
@@ -671,7 +495,7 @@ Get the `ResourceName` for this camera.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/components/apis/generated/encoder-table.md b/static/include/components/apis/generated/encoder-table.md
index 343adc0a3a..f4aacec353 100644
--- a/static/include/components/apis/generated/encoder-table.md
+++ b/static/include/components/apis/generated/encoder-table.md
@@ -1,11 +1,11 @@
 <!-- prettier-ignore -->
 | Method Name | Description | `viam-micro-server` Support |
 | ----------- | ----------- | --------------------------- |
-| [`GetPosition`](/dev/reference/apis/components/encoder/#getposition) | Get the current position of the encoder in ticks or degrees. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`ResetPosition`](/dev/reference/apis/components/encoder/#resetposition) | Set the current position of the encoder to be the new zero position. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetProperties`](/dev/reference/apis/components/encoder/#getproperties) | Get a list of all the position types that are supported by a given encoder. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetGeometries`](/dev/reference/apis/components/encoder/#getgeometries) | Get all the geometries associated with the encoder in its current configuration, in the frame of the encoder. |  |
-| [`Reconfigure`](/dev/reference/apis/components/encoder/#reconfigure) | Reconfigure this resource. |  |
-| [`DoCommand`](/dev/reference/apis/components/encoder/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetResourceName`](/dev/reference/apis/components/encoder/#getresourcename) | Get the `ResourceName` for this encoder. |  |
-| [`Close`](/dev/reference/apis/components/encoder/#close) | Safely shut down the resource and prevent further use. |  |
+| [`GetPosition`](/reference/apis/components/encoder/#getposition) | Get the current position of the encoder in ticks or degrees. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`ResetPosition`](/reference/apis/components/encoder/#resetposition) | Set the current position of the encoder to be the new zero position. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetProperties`](/reference/apis/components/encoder/#getproperties) | Get a list of all the position types that are supported by a given encoder. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetGeometries`](/reference/apis/components/encoder/#getgeometries) | Get all the geometries associated with the encoder in its current configuration, in the frame of the encoder. |  |
+| [`Reconfigure`](/reference/apis/components/encoder/#reconfigure) | Reconfigure this resource. |  |
+| [`DoCommand`](/reference/apis/components/encoder/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetResourceName`](/reference/apis/components/encoder/#getresourcename) | Get the `ResourceName` for this encoder. |  |
+| [`Close`](/reference/apis/components/encoder/#close) | Safely shut down the resource and prevent further use. |  |
diff --git a/static/include/components/apis/generated/encoder.md b/static/include/components/apis/generated/encoder.md
index 6d08dd0fc1..5185826ec5 100644
--- a/static/include/components/apis/generated/encoder.md
+++ b/static/include/components/apis/generated/encoder.md
@@ -16,9 +16,9 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- (Tuple[[float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex), [PositionType.ValueType](https://python.viam.dev/autoapi/viam/gen/component/encoder/v1/encoder_pb2/index.html#viam.gen.component.encoder.v1.encoder_pb2.PositionType)]): A tuple containing two values; the first \[0] the position of the encoder which can either be
-ticks since last zeroing for a relative encoder or degrees for an absolute encoder, and the second \[1] the type of
-position the encoder returns (ticks or degrees).
+- (Tuple[[float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex), [PositionType.ValueType](https://python.viam.dev/autoapi/viam/gen/component/encoder/v1/encoder_pb2/index.html#viam.gen.component.encoder.v1.encoder_pb2.PositionType)]): :   A tuple containing two values; the first [0] the position of the encoder which can either be
+    ticks since last zeroing for a relative encoder or degrees for an absolute encoder, and the second [1] the type of
+    position the encoder returns (ticks or degrees).
 
 **Example:**
 
@@ -186,7 +186,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- ([viam.components.encoder.encoder.Encoder.Properties](https://python.viam.dev/autoapi/viam/components/encoder/encoder/index.html#viam.components.encoder.encoder.Encoder.Properties)): Map of position types to supported status.
+- ([viam.components.encoder.encoder.Encoder.Properties](https://python.viam.dev/autoapi/viam/components/encoder/encoder/index.html#viam.components.encoder.encoder.Encoder.Properties)): :   Map of position types to supported status.
 
 **Example:**
 
@@ -264,7 +264,7 @@ The [motion](/operate/reference/services/motion/) and [navigation](/operate/refe
 
 **Returns:**
 
-- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): The geometries associated with the Component.
+- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): :   The geometries associated with the Component.
 
 **Example:**
 
@@ -310,7 +310,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own encoder as a {{< glossary_tooltip term_id="modular-resource" text="modular resource" >}} and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own encoder as a {{< glossary_tooltip term_id="modular-resource" text="modular resource" >}} and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 Supported by `viam-micro-server`.
 
 {{< tabs >}}
@@ -323,7 +323,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Raises:**
 
@@ -368,7 +368,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -378,12 +379,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -405,7 +410,7 @@ Get the `ResourceName` for this encoder.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/components/apis/generated/gantry-table.md b/static/include/components/apis/generated/gantry-table.md
index 6026182924..70da493e32 100644
--- a/static/include/components/apis/generated/gantry-table.md
+++ b/static/include/components/apis/generated/gantry-table.md
@@ -1,15 +1,15 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`GetPosition`](/dev/reference/apis/components/gantry/#getposition) | Get the current positions of the axis of the gantry (mm). |
-| [`MoveToPosition`](/dev/reference/apis/components/gantry/#movetoposition) | Move the axes of the gantry to the desired positions (mm) at the requested speeds (mm/sec). |
-| [`GetLengths`](/dev/reference/apis/components/gantry/#getlengths) | Get the lengths of the axes of the gantry (mm). |
-| [`Home`](/dev/reference/apis/components/gantry/#home) | Run the homing sequence of the gantry to re-calibrate the axes with respect to the limit switches. |
-| [`GetGeometries`](/dev/reference/apis/components/gantry/#getgeometries) | Get all the geometries associated with the gantry in its current configuration, in the frame of the gantry. |
-| [`IsMoving`](/dev/reference/apis/components/gantry/#ismoving) | Get if the gantry is currently moving. |
-| [`Stop`](/dev/reference/apis/components/gantry/#stop) | Stop all motion of the gantry. |
-| [`Reconfigure`](/dev/reference/apis/components/gantry/#reconfigure) | Reconfigure this resource. |
-| [`DoCommand`](/dev/reference/apis/components/gantry/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
-| [`GetKinematics`](/dev/reference/apis/components/gantry/#getkinematics) | Get the kinematics information associated with the gantry. |
-| [`GetResourceName`](/dev/reference/apis/components/gantry/#getresourcename) | Get the `ResourceName` for this gantry. |
-| [`Close`](/dev/reference/apis/components/gantry/#close) | Safely shut down the resource and prevent further use. |
+| [`GetPosition`](/reference/apis/components/gantry/#getposition) | Get the current positions of the axis of the gantry (mm). |
+| [`MoveToPosition`](/reference/apis/components/gantry/#movetoposition) | Move the axes of the gantry to the desired positions (mm) at the requested speeds (mm/sec). |
+| [`GetLengths`](/reference/apis/components/gantry/#getlengths) | Get the lengths of the axes of the gantry (mm). |
+| [`Home`](/reference/apis/components/gantry/#home) | Run the homing sequence of the gantry to re-calibrate the axes with respect to the limit switches. |
+| [`GetGeometries`](/reference/apis/components/gantry/#getgeometries) | Get all the geometries associated with the gantry in its current configuration, in the frame of the gantry. |
+| [`IsMoving`](/reference/apis/components/gantry/#ismoving) | Get if the gantry is currently moving. |
+| [`Stop`](/reference/apis/components/gantry/#stop) | Stop all motion of the gantry. |
+| [`Reconfigure`](/reference/apis/components/gantry/#reconfigure) | Reconfigure this resource. |
+| [`DoCommand`](/reference/apis/components/gantry/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
+| [`GetKinematics`](/reference/apis/components/gantry/#getkinematics) | Get the kinematics information associated with the gantry. |
+| [`GetResourceName`](/reference/apis/components/gantry/#getresourcename) | Get the `ResourceName` for this gantry. |
+| [`Close`](/reference/apis/components/gantry/#close) | Safely shut down the resource and prevent further use. |
diff --git a/static/include/components/apis/generated/gantry.md b/static/include/components/apis/generated/gantry.md
index 37f75a3edd..f016c7f249 100644
--- a/static/include/components/apis/generated/gantry.md
+++ b/static/include/components/apis/generated/gantry.md
@@ -12,7 +12,7 @@ Get the current positions of the axis of the gantry (mm).
 
 **Returns:**
 
-- (List[[float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)]): A list of the position of the axes of the gantry in millimeters.
+- (List[[float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)]): :   A list of the position of the axes of the gantry in millimeters.
 
 **Example:**
 
@@ -77,11 +77,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)>\>
 
 **Example:**
 
@@ -196,13 +196,13 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `positions` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)\> (required)
-- `speeds` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)\> (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `positions` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)> (required)
+- `speeds` [List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)> (required)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -229,7 +229,7 @@ Get the lengths of the axes of the gantry (mm).
 
 **Returns:**
 
-- (List[[float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)]): A list of the lengths of the axes of the gantry in millimeters.
+- (List[[float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)]): :   A list of the lengths of the axes of the gantry in millimeters.
 
 **Example:**
 
@@ -294,11 +294,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)>\>
 
 **Example:**
 
@@ -325,7 +325,7 @@ Run the homing sequence of the gantry to re-calibrate the axes with respect to t
 
 **Returns:**
 
-- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): Whether the gantry has run the homing sequence successfully.
+- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): :   Whether the gantry has run the homing sequence successfully.
 
 **Example:**
 
@@ -389,11 +389,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[bool](https://api.flutter.dev/flutter/dart-core/bool-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[bool](https://api.flutter.dev/flutter/dart-core/bool-class.html)>
 
 **Example:**
 
@@ -421,7 +421,7 @@ The [motion](/operate/reference/services/motion/) and [navigation](/operate/refe
 
 **Returns:**
 
-- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): The geometries associated with the Component.
+- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): :   The geometries associated with the Component.
 
 **Example:**
 
@@ -475,7 +475,7 @@ Get if the gantry is currently moving.
 
 **Returns:**
 
-- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): Whether the gantry is moving.
+- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): :   Whether the gantry is moving.
 
 **Example:**
 
@@ -552,7 +552,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[bool](https://api.flutter.dev/flutter/dart-core/bool-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[bool](https://api.flutter.dev/flutter/dart-core/bool-class.html)>
 
 **Example:**
 
@@ -645,11 +645,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -690,7 +690,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own gantry and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own gantry and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -702,7 +702,7 @@ If you are implementing your own gantry and want to add features that have no co
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Raises:**
 
@@ -747,7 +747,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -757,12 +758,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -773,11 +778,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> (required)
+- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -806,10 +811,11 @@ Get the kinematics information associated with the gantry.
 
 **Returns:**
 
-- (Tuple[viam.proto.common.KinematicsFileFormat.ValueType, [bytes](https://docs.python.org/3/library/stdtypes.html#bytes-objects)]): A tuple containing two values; the first \[0] value represents the format of the
-file, either in URDF format (`KinematicsFileFormat.KINEMATICS_FILE_FORMAT_URDF`) or
-Viam’s kinematic parameter format (spatial vector algebra) (`KinematicsFileFormat.KINEMATICS_FILE_FORMAT_SVA`),
-and the second \[1] value represents the byte contents of the file.
+- ([viam.components.KinematicsReturn](https://python.viam.dev/autoapi/viam/components/index.html#viam.components.KinematicsReturn)): :   A tuple containing two values; the first [0] value represents the format of the
+    file, either in URDF format (`KinematicsFileFormat.KINEMATICS_FILE_FORMAT_URDF`) or
+    Viam’s kinematic parameter format (spatial vector algebra) (`KinematicsFileFormat.KINEMATICS_FILE_FORMAT_SVA`),
+    and the second [1] value represents the byte contents of the file.
+    If available, a third [2] value provides meshes keyed by URDF filepath.
 
 **Example:**
 
@@ -859,7 +865,7 @@ Get the `ResourceName` for this gantry.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/components/apis/generated/generic_component-table.md b/static/include/components/apis/generated/generic_component-table.md
index 2c8ed83757..e47a8ddd57 100644
--- a/static/include/components/apis/generated/generic_component-table.md
+++ b/static/include/components/apis/generated/generic_component-table.md
@@ -1,7 +1,7 @@
 <!-- prettier-ignore -->
 | Method Name | Description | `viam-micro-server` Support |
 | ----------- | ----------- | --------------------------- |
-| [`GetGeometries`](/dev/reference/apis/components/generic/#getgeometries) | Get all the geometries associated with the generic component in its current configuration, in the frame of the generic component. |  |
-| [`DoCommand`](/dev/reference/apis/components/generic/#docommand) | Execute model-specific commands. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetResourceName`](/dev/reference/apis/components/generic/#getresourcename) | Get the `ResourceName` for this generic component. |  |
-| [`Close`](/dev/reference/apis/components/generic/#close) | Safely shut down the resource and prevent further use. |  |
+| [`GetGeometries`](/reference/apis/components/generic/#getgeometries) | Get all the geometries associated with the generic component in its current configuration, in the frame of the generic component. |  |
+| [`DoCommand`](/reference/apis/components/generic/#docommand) | Execute model-specific commands. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetResourceName`](/reference/apis/components/generic/#getresourcename) | Get the `ResourceName` for this generic component. |  |
+| [`Close`](/reference/apis/components/generic/#close) | Safely shut down the resource and prevent further use. |  |
diff --git a/static/include/components/apis/generated/generic_component.md b/static/include/components/apis/generated/generic_component.md
index ac7705d1c5..4569d2cb23 100644
--- a/static/include/components/apis/generated/generic_component.md
+++ b/static/include/components/apis/generated/generic_component.md
@@ -13,7 +13,7 @@ The [motion](/operate/reference/services/motion/) and [navigation](/operate/refe
 
 **Returns:**
 
-- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): The geometries associated with the Component.
+- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): :   The geometries associated with the Component.
 
 **Example:**
 
@@ -61,7 +61,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 ### DoCommand
 
 Execute model-specific commands.
-If you are implementing your own generic component and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own generic component and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 Supported by `viam-micro-server`.
 
 {{< tabs >}}
@@ -74,7 +74,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]): :   Result of the executed command.
 
 **Raises:**
 
@@ -119,7 +119,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -129,12 +130,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -145,11 +150,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> (required)
+- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -177,7 +182,7 @@ Get the `ResourceName` for this generic component.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/components/apis/generated/gripper-table.md b/static/include/components/apis/generated/gripper-table.md
index da499e2c6d..16d4755e39 100644
--- a/static/include/components/apis/generated/gripper-table.md
+++ b/static/include/components/apis/generated/gripper-table.md
@@ -1,14 +1,14 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`Open`](/dev/reference/apis/components/gripper/#open) | Opens the gripper. |
-| [`Grab`](/dev/reference/apis/components/gripper/#grab) | Closes the gripper until it grabs something or closes completely, and returns whether it grabbed something or not. |
-| [`IsMoving`](/dev/reference/apis/components/gripper/#ismoving) | Returns whether the gripper is actively moving (or attempting to move) under its own power. |
-| [`IsHoldingSomething`](/dev/reference/apis/components/gripper/#isholdingsomething) | Return if the gripper is holding something. |
-| [`Stop`](/dev/reference/apis/components/gripper/#stop) | Stops the gripper. |
-| [`GetGeometries`](/dev/reference/apis/components/gripper/#getgeometries) | Get all the geometries associated with the gripper in its current configuration, in the frame of the gripper. |
-| [`Reconfigure`](/dev/reference/apis/components/gripper/#reconfigure) | Reconfigure this resource. |
-| [`DoCommand`](/dev/reference/apis/components/gripper/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
-| [`GetKinematics`](/dev/reference/apis/components/gripper/#getkinematics) | Get the kinematics information associated with the gripper as the format and byte contents of the kinematics file. |
-| [`GetResourceName`](/dev/reference/apis/components/gripper/#getresourcename) | Get the `ResourceName` for this gripper. |
-| [`Close`](/dev/reference/apis/components/gripper/#close) | Safely shut down the resource and prevent further use. |
+| [`Open`](/reference/apis/components/gripper/#open) | Opens the gripper. |
+| [`Grab`](/reference/apis/components/gripper/#grab) | Closes the gripper until it grabs something or closes completely, and returns whether it grabbed something or not. |
+| [`IsMoving`](/reference/apis/components/gripper/#ismoving) | Returns whether the gripper is actively moving (or attempting to move) under its own power. |
+| [`IsHoldingSomething`](/reference/apis/components/gripper/#isholdingsomething) | Return if the gripper is holding something. |
+| [`Stop`](/reference/apis/components/gripper/#stop) | Stops the gripper. |
+| [`GetGeometries`](/reference/apis/components/gripper/#getgeometries) | Get all the geometries associated with the gripper in its current configuration, in the frame of the gripper. |
+| [`Reconfigure`](/reference/apis/components/gripper/#reconfigure) | Reconfigure this resource. |
+| [`DoCommand`](/reference/apis/components/gripper/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
+| [`GetKinematics`](/reference/apis/components/gripper/#getkinematics) | Get the kinematics information associated with the gripper as the format and byte contents of the kinematics file. |
+| [`GetResourceName`](/reference/apis/components/gripper/#getresourcename) | Get the `ResourceName` for this gripper. |
+| [`Close`](/reference/apis/components/gripper/#close) | Safely shut down the resource and prevent further use. |
diff --git a/static/include/components/apis/generated/gripper.md b/static/include/components/apis/generated/gripper.md
index 241485974a..9739f33585 100644
--- a/static/include/components/apis/generated/gripper.md
+++ b/static/include/components/apis/generated/gripper.md
@@ -76,11 +76,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -107,7 +107,7 @@ Closes the gripper until it grabs something or closes completely, and returns wh
 
 **Returns:**
 
-- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): Indicates if the gripper grabbed something.
+- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): :   Indicates if the gripper grabbed something.
 
 **Example:**
 
@@ -172,11 +172,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -202,7 +202,7 @@ Returns whether the gripper is actively moving (or attempting to move) under its
 
 **Returns:**
 
-- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): Whether the gripper is moving.
+- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): :   Whether the gripper is moving.
 
 **Example:**
 
@@ -276,7 +276,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[bool](https://api.flutter.dev/flutter/dart-core/bool-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[bool](https://api.flutter.dev/flutter/dart-core/bool-class.html)>
 
 **Example:**
 
@@ -303,7 +303,7 @@ Return if the gripper is holding something.
 
 **Returns:**
 
-- ([viam.components.gripper.gripper.Gripper.HoldingStatus](https://python.viam.dev/autoapi/viam/components/gripper/gripper/index.html#viam.components.gripper.gripper.Gripper.HoldingStatus)): see documentation on HoldingStatus for more information.
+- ([viam.components.gripper.gripper.Gripper.HoldingStatus](https://python.viam.dev/autoapi/viam/components/gripper/gripper/index.html#viam.components.gripper.gripper.Gripper.HoldingStatus)): :   see documentation on HoldingStatus for more information.
 
 **Example:**
 
@@ -338,11 +338,11 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/c
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[HoldingStatus](https://flutter.viam.dev/viam_sdk/HoldingStatus-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[HoldingStatus](https://flutter.viam.dev/viam_sdk/HoldingStatus-class.html)>
 
 For more information, see the [Flutter SDK Docs](https://flutter.viam.dev/viam_sdk/Gripper/isHoldingSomething.html).
 
@@ -429,11 +429,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -461,7 +461,7 @@ The [motion](/operate/reference/services/motion/) and [navigation](/operate/refe
 
 **Returns:**
 
-- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): The geometries associated with the Component.
+- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): :   The geometries associated with the Component.
 
 **Example:**
 
@@ -561,7 +561,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own gripper and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own gripper and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -573,7 +573,7 @@ If you are implementing your own gripper and want to add features that have no c
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Raises:**
 
@@ -618,7 +618,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -628,12 +629,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -644,11 +649,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> (required)
+- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -677,10 +682,11 @@ Get the kinematics information associated with the gripper as the format and byt
 
 **Returns:**
 
-- (Tuple[viam.components.gripper.KinematicsFileFormat.ValueType, [bytes](https://docs.python.org/3/library/stdtypes.html#bytes-objects)]): A tuple containing two values; the first \[0] value represents the format of the
-file, either in URDF format (`KinematicsFileFormat.KINEMATICS_FILE_FORMAT_URDF`) or
-Viam’s kinematic parameter format (spatial vector algebra) (`KinematicsFileFormat.KINEMATICS_FILE_FORMAT_SVA`),
-and the second \[1] value represents the byte contents of the file.
+- ([viam.components.KinematicsReturn](https://python.viam.dev/autoapi/viam/components/index.html#viam.components.KinematicsReturn)): :   A tuple containing two values; the first [0] value represents the format of the
+    file, either in URDF format (`KinematicsFileFormat.KINEMATICS_FILE_FORMAT_URDF`) or
+    Viam’s kinematic parameter format (spatial vector algebra) (`KinematicsFileFormat.KINEMATICS_FILE_FORMAT_SVA`),
+    and the second [1] value represents the byte contents of the file.
+    If available, a third [2] value provides meshes keyed by URDF filepath.
 
 **Example:**
 
@@ -719,11 +725,11 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Kinematics](https://flutter.viam.dev/viam_sdk/Kinematics-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<Kinematics>
 
 **Example:**
 
@@ -749,7 +755,7 @@ Get the `ResourceName` for this gripper.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/components/apis/generated/input_controller-table.md b/static/include/components/apis/generated/input_controller-table.md
index e72134a262..6a31e14f3c 100644
--- a/static/include/components/apis/generated/input_controller-table.md
+++ b/static/include/components/apis/generated/input_controller-table.md
@@ -1,12 +1,12 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`GetControls`](/dev/reference/apis/components/input-controller/#getcontrols) | Get a list of the Controls that your controller provides. |
-| [`GetEvents`](/dev/reference/apis/components/input-controller/#getevents) | This method returns the current state of the controller as a map of Event Objects, representing the most recent event that has occurred on each available Control. |
-| [`TriggerEvent`](/dev/reference/apis/components/input-controller/#triggerevent) | Directly send an Event Object from external code. |
-| [`GetGeometries`](/dev/reference/apis/components/input-controller/#getgeometries) | Get all the geometries associated with the input controller in its current configuration, in the frame of the input controller. |
-| [`RegisterControlCallback`](/dev/reference/apis/components/input-controller/#registercontrolcallback) | Defines a callback function to execute whenever one of the EventTypes selected occurs on the given Control. |
-| [`Reconfigure`](/dev/reference/apis/components/input-controller/#reconfigure) | Reconfigure this resource. |
-| [`DoCommand`](/dev/reference/apis/components/input-controller/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
-| [`GetResourceName`](/dev/reference/apis/components/input-controller/#getresourcename) | Get the `ResourceName` for this input controller. |
-| [`Close`](/dev/reference/apis/components/input-controller/#close) | Safely shut down the resource and prevent further use. |
+| [`GetControls`](/reference/apis/components/input-controller/#getcontrols) | Get a list of the Controls that your controller provides. |
+| [`GetEvents`](/reference/apis/components/input-controller/#getevents) | This method returns the current state of the controller as a map of Event Objects, representing the most recent event that has occurred on each available Control. |
+| [`TriggerEvent`](/reference/apis/components/input-controller/#triggerevent) | Directly send an Event Object from external code. |
+| [`GetGeometries`](/reference/apis/components/input-controller/#getgeometries) | Get all the geometries associated with the input controller in its current configuration, in the frame of the input controller. |
+| [`RegisterControlCallback`](/reference/apis/components/input-controller/#registercontrolcallback) | Defines a callback function to execute whenever one of the EventTypes selected occurs on the given Control. |
+| [`Reconfigure`](/reference/apis/components/input-controller/#reconfigure) | Reconfigure this resource. |
+| [`DoCommand`](/reference/apis/components/input-controller/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
+| [`GetResourceName`](/reference/apis/components/input-controller/#getresourcename) | Get the `ResourceName` for this input controller. |
+| [`Close`](/reference/apis/components/input-controller/#close) | Safely shut down the resource and prevent further use. |
diff --git a/static/include/components/apis/generated/input_controller.md b/static/include/components/apis/generated/input_controller.md
index d891cf7d9b..4b22d2e1bb 100644
--- a/static/include/components/apis/generated/input_controller.md
+++ b/static/include/components/apis/generated/input_controller.md
@@ -1,6 +1,6 @@
 ### GetControls
 
-Get a list of the [Controls](/dev/reference/apis/components/input-controller/#control-field) that your controller provides.
+Get a list of the [Controls](/reference/apis/components/input-controller/#control-field) that your controller provides.
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -12,7 +12,7 @@ Get a list of the [Controls](/dev/reference/apis/components/input-controller/#co
 
 **Returns:**
 
-- ([List[viam.components.input.input.Control]](https://python.viam.dev/autoapi/viam/components/input/input/index.html#viam.components.input.input.Control)): List of controls provided by the Controller.
+- ([List[viam.components.input.input.Control]](https://python.viam.dev/autoapi/viam/components/input/input/index.html#viam.components.input.input.Control)): :   List of controls provided by the Controller.
 
 **Example:**
 
@@ -71,7 +71,7 @@ This method returns the current state of the controller as a map of [Event Objec
 
 **Returns:**
 
-- ([Dict[viam.components.input.input.Control, viam.components.input.input.Event]](https://python.viam.dev/autoapi/viam/components/input/input/index.html#viam.components.input.input.Control)): The most recent event for each input.
+- ([Dict[viam.components.input.input.Control, viam.components.input.input.Event]](https://python.viam.dev/autoapi/viam/components/input/input/index.html#viam.components.input.input.Control)): :   The most recent event for each input.
 
 **Example:**
 
@@ -249,7 +249,7 @@ The [motion](/operate/reference/services/motion/) and [navigation](/operate/refe
 
 **Returns:**
 
-- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): The geometries associated with the Component.
+- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): :   The geometries associated with the Component.
 
 **Example:**
 
@@ -288,7 +288,7 @@ Doing so registers the same callback to both `ButtonPress` and `ButtonRelease`,
 
 - `control` ([viam.components.input.input.Control](https://python.viam.dev/autoapi/viam/components/input/index.html#viam.components.input.Control)) (required): The control to register the function for.
 - `triggers` ([List[viam.components.input.input.EventType]](https://python.viam.dev/autoapi/viam/components/input/index.html#viam.components.input.EventType)) (required): The events that will trigger the function.
-- `function` (viam.components.input.input.ControlFunction) (optional): The function to run on specific triggers.
+- `function` ([viam.components.input.input.ControlFunction](https://python.viam.dev/autoapi/viam/components/input/index.html#viam.components.input.ControlFunction)) (optional): The function to run on specific triggers.
 - `extra` (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]) (optional): Extra options to pass to the underlying RPC call.
 
 **Returns:**
@@ -327,7 +327,7 @@ async def handle_controller(controller):
 
 
 async def main():
-    # ... < INSERT CONNECTION CODE FROM MACHINE'S CODE SAMPLE TAB >
+    # ... < INSERT CONNECTION CODE FROM MACHINE'S CONNECT TAB >
 
     # Get your controller from the machine.
     my_controller = Controller.from_robot(
@@ -347,7 +347,7 @@ For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/
 **Parameters:**
 
 - `ctx` [(Context)](https://pkg.go.dev/context#Context): A Context carries a deadline, a cancellation signal, and other values across API boundaries.
-- `control` [(Control)](https://pkg.go.dev/go.viam.com/rdk/components/input#Control): The [Control](/dev/reference/apis/components/input-controller/#control-field) to register the function for.
+- `control` [(Control)](https://pkg.go.dev/go.viam.com/rdk/components/input#Control): The [Control](/reference/apis/components/input-controller/#control-field) to register the function for.
 - `triggers` [([]EventType)](https://pkg.go.dev/go.viam.com/rdk/components/input#EventType): The [EventTypes](#eventtype-field) that trigger the function.
 - `ctrlFunc` [(ControlFunction)](https://pkg.go.dev/go.viam.com/rdk/components/input#ControlFunction): The function to run when the specified triggers are invoked.
 - `extra` [(map[string]interface{})](https://go.dev/blog/maps): Extra options to pass to the underlying RPC call.
@@ -414,7 +414,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own input controller and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own input controller and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -426,7 +426,7 @@ If you are implementing your own input controller and want to add features that
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Raises:**
 
@@ -482,7 +482,7 @@ Get the `ResourceName` for this input controller.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/components/apis/generated/motor-table.md b/static/include/components/apis/generated/motor-table.md
index b049fca483..d26a28643a 100644
--- a/static/include/components/apis/generated/motor-table.md
+++ b/static/include/components/apis/generated/motor-table.md
@@ -1,17 +1,18 @@
 <!-- prettier-ignore -->
 | Method Name | Description | `viam-micro-server` Support |
 | ----------- | ----------- | --------------------------- |
-| [`SetPower`](/dev/reference/apis/components/motor/#setpower) | Set the portion of max power to send to the motor (between `-1` and `1`). | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`SetRPM`](/dev/reference/apis/components/motor/#setrpm) | Spin the motor indefinitely at the specified speed, in revolutions per minute. If `rpm` is positive, the motor will spin forwards, and if `rpm` is negative, the motor will spin backwards. |  |
-| [`GoFor`](/dev/reference/apis/components/motor/#gofor) | Spin the motor the specified number of revolutions at specified revolutions per minute. |  |
-| [`GoTo`](/dev/reference/apis/components/motor/#goto) | Turn the motor to a specified position (in terms of revolutions from home/zero) at a specified speed in revolutions per minute (RPM). |  |
-| [`ResetZeroPosition`](/dev/reference/apis/components/motor/#resetzeroposition) | Set the current position (modified by `offset`) to be the new zero (home) position. |  |
-| [`GetPosition`](/dev/reference/apis/components/motor/#getposition) | Report the position of the motor based on its encoder. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetProperties`](/dev/reference/apis/components/motor/#getproperties) | Report a dictionary mapping optional properties to whether it is supported by this motor. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`IsPowered`](/dev/reference/apis/components/motor/#ispowered) | Return whether or not the motor is currently running, and the portion of max power (between `0` and `1`; if the motor is off the power will be `0`). |  |
-| [`IsMoving`](/dev/reference/apis/components/motor/#ismoving) | Return whether the motor is actively moving (or attempting to move) under its own power. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`Stop`](/dev/reference/apis/components/motor/#stop) | Cut the power to the motor immediately, without any gradual step down. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`Reconfigure`](/dev/reference/apis/components/motor/#reconfigure) | Reconfigure this resource. |  |
-| [`DoCommand`](/dev/reference/apis/components/motor/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
-| [`GetResourceName`](/dev/reference/apis/components/motor/#getresourcename) | Get the `ResourceName` for this motor. |  |
-| [`Close`](/dev/reference/apis/components/motor/#close) | Safely shut down the resource and prevent further use. |  |
+| [`SetPower`](/reference/apis/components/motor/#setpower) | Set the portion of max power to send to the motor (between `-1` and `1`). | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`SetRPM`](/reference/apis/components/motor/#setrpm) | Spin the motor indefinitely at the specified speed, in revolutions per minute. If `rpm` is positive, the motor will spin forwards, and if `rpm` is negative, the motor will spin backwards. |  |
+| [`GoFor`](/reference/apis/components/motor/#gofor) | Spin the motor the specified number of revolutions at specified revolutions per minute. |  |
+| [`GoTo`](/reference/apis/components/motor/#goto) | Turn the motor to a specified position (in terms of revolutions from home/zero) at a specified speed in revolutions per minute (RPM). |  |
+| [`ResetZeroPosition`](/reference/apis/components/motor/#resetzeroposition) | Set the current position (modified by `offset`) to be the new zero (home) position. |  |
+| [`GetPosition`](/reference/apis/components/motor/#getposition) | Report the position of the motor based on its encoder. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetProperties`](/reference/apis/components/motor/#getproperties) | Report a dictionary mapping optional properties to whether it is supported by this motor. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`IsPowered`](/reference/apis/components/motor/#ispowered) | Return whether or not the motor is currently running, and the portion of max power (between `0` and `1`; if the motor is off the power will be `0`). |  |
+| [`IsMoving`](/reference/apis/components/motor/#ismoving) | Return whether the motor is actively moving (or attempting to move) under its own power. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`Stop`](/reference/apis/components/motor/#stop) | Cut the power to the motor immediately, without any gradual step down. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetGeometries`](/reference/apis/components/motor/#getgeometries) | Get all the geometries associated with the motor in its current configuration, in the frame of the motor. |  |
+| [`Reconfigure`](/reference/apis/components/motor/#reconfigure) | Reconfigure this resource. |  |
+| [`DoCommand`](/reference/apis/components/motor/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
+| [`GetResourceName`](/reference/apis/components/motor/#getresourcename) | Get the `ResourceName` for this motor. |  |
+| [`Close`](/reference/apis/components/motor/#close) | Safely shut down the resource and prevent further use. |  |
diff --git a/static/include/components/apis/generated/motor.md b/static/include/components/apis/generated/motor.md
index 822161b839..cb1bb35e68 100644
--- a/static/include/components/apis/generated/motor.md
+++ b/static/include/components/apis/generated/motor.md
@@ -58,7 +58,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/c
 
 **Parameters:**
 
-- `power` (number) (required): A value between \-1 and 1 where negative values indicate a
+- `power` (number) (required): A value between -1 and 1 where negative values indicate a
   backwards direction and positive values a forward direction.
 - `extra` (None) (optional)
 - `callOptions` (CallOptions) (optional)
@@ -84,11 +84,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 **Parameters:**
 
 - `powerPct` [double](https://api.flutter.dev/flutter/dart-core/double-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -182,11 +182,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 **Parameters:**
 
 - `rpm` [double](https://api.flutter.dev/flutter/dart-core/double-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -290,11 +290,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 - `rpm` [double](https://api.flutter.dev/flutter/dart-core/double-class.html) (required)
 - `revolutions` [double](https://api.flutter.dev/flutter/dart-core/double-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -395,11 +395,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 - `rpm` [double](https://api.flutter.dev/flutter/dart-core/double-class.html) (required)
 - `positionRevolutions` [double](https://api.flutter.dev/flutter/dart-core/double-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -493,11 +493,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 **Parameters:**
 
 - `offset` [double](https://api.flutter.dev/flutter/dart-core/double-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -528,7 +528,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): Number of revolutions the motor is away from zero/home.
+- ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): :   Number of revolutions the motor is away from zero/home.
 
 **Example:**
 
@@ -596,11 +596,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)>
 
 **Example:**
 
@@ -629,7 +629,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- ([viam.components.motor.motor.Motor.Properties](https://python.viam.dev/autoapi/viam/components/motor/motor/index.html#viam.components.motor.motor.Motor.Properties)): Map of feature names to supported status.
+- ([viam.components.motor.motor.Motor.Properties](https://python.viam.dev/autoapi/viam/components/motor/motor/index.html#viam.components.motor.motor.Motor.Properties)): :   Map of feature names to supported status.
 
 **Example:**
 
@@ -702,11 +702,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[MotorProperties](https://flutter.viam.dev/viam_sdk/MotorProperties.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[MotorProperties](https://flutter.viam.dev/viam_sdk/MotorProperties.html)>
 
 **Example:**
 
@@ -735,8 +735,8 @@ Stepper motors will report `true` if they are being powered while holding a posi
 
 **Returns:**
 
-- (Tuple[[bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool), [float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)]): A tuple containing two values; the first \[0] value indicates whether the motor is currently powered, and
-the second \[1] value indicates the current power percentage of the motor.
+- (Tuple[[bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool), [float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)]): :   A tuple containing two values; the first [0] value indicates whether the motor is currently powered, and
+    the second [1] value indicates the current power percentage of the motor.
 
 **Example:**
 
@@ -809,11 +809,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[PowerState](https://flutter.viam.dev/viam_sdk/PowerState-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[PowerState](https://flutter.viam.dev/viam_sdk/PowerState-class.html)>
 
 **Example:**
 
@@ -844,7 +844,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): Whether the motor is moving.
+- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): :   Whether the motor is moving.
 
 **Example:**
 
@@ -914,11 +914,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[bool](https://api.flutter.dev/flutter/dart-core/bool-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[bool](https://api.flutter.dev/flutter/dart-core/bool-class.html)>
 
 **Example:**
 
@@ -1012,11 +1012,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -1030,6 +1030,39 @@ For more information, see the [Flutter SDK Docs](https://flutter.viam.dev/viam_s
 {{% /tab %}}
 {{< /tabs >}}
 
+### GetGeometries
+
+Get all the geometries associated with the motor in its current configuration, in the [frame](/operate/reference/services/frame-system/) of the motor.
+The [motion](/operate/reference/services/motion/) and [navigation](/operate/reference/services/navigation/) services use the relative position of inherent geometries to configured geometries representing obstacles for collision detection and obstacle avoidance while motion planning.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+**Parameters:**
+
+- `extra` (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]) (optional): Extra options to pass to the underlying RPC call.
+- `timeout` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (optional): An option to set how long to wait (in seconds) before calling a time-out and closing the underlying RPC call.
+
+**Returns:**
+
+- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): :   The geometries associated with the Component.
+
+**Example:**
+
+```python {class="line-numbers linkable-line-numbers"}
+my_motor = Motor.from_robot(robot=machine, name="my_motor")
+geometries = await my_motor.get_geometries()
+
+if geometries:
+    # Get the center of the first geometry
+    print(f"Pose of the first geometry's centerpoint: {geometries[0].center}")
+```
+
+For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/components/motor/client/index.html#viam.components.motor.client.MotorClient.get_geometries).
+
+{{% /tab %}}
+{{< /tabs >}}
+
 ### Reconfigure
 
 Reconfigure this resource.
@@ -1058,7 +1091,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own motor and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own motor and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -1070,7 +1103,7 @@ If you are implementing your own motor and want to add features that have no cor
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Raises:**
 
@@ -1115,7 +1148,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -1125,12 +1159,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -1141,11 +1179,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> (required)
+- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -1173,7 +1211,7 @@ Get the `ResourceName` for this motor.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/components/apis/generated/movement_sensor.md b/static/include/components/apis/generated/movement_sensor.md
index 0daa40190d..0fc71eee44 100644
--- a/static/include/components/apis/generated/movement_sensor.md
+++ b/static/include/components/apis/generated/movement_sensor.md
@@ -15,7 +15,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- ([viam.components.movement_sensor.Vector3](https://python.viam.dev/autoapi/viam/components/movement_sensor/index.html#viam.components.movement_sensor.Vector3)): The linear velocity in m/sec.
+- ([viam.components.movement_sensor.Vector3](https://python.viam.dev/autoapi/viam/components/movement_sensor/index.html#viam.components.movement_sensor.Vector3)): :   The linear velocity in m/sec.
 
 **Example:**
 
@@ -80,11 +80,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Vector3](https://flutter.viam.dev/viam_sdk/Vector3-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Vector3](https://flutter.viam.dev/viam_sdk/Vector3-class.html)>
 
 **Example:**
 
@@ -114,7 +114,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- ([viam.components.movement_sensor.Vector3](https://python.viam.dev/autoapi/viam/components/movement_sensor/index.html#viam.components.movement_sensor.Vector3)): The angular velocity in degrees/sec.
+- ([viam.components.movement_sensor.Vector3](https://python.viam.dev/autoapi/viam/components/movement_sensor/index.html#viam.components.movement_sensor.Vector3)): :   The angular velocity in degrees/sec.
 
 **Example:**
 
@@ -185,11 +185,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Vector3](https://flutter.viam.dev/viam_sdk/Vector3-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Vector3](https://flutter.viam.dev/viam_sdk/Vector3-class.html)>
 
 **Example:**
 
@@ -219,7 +219,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): The compass heading in degrees.
+- ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): :   The compass heading in degrees.
 
 **Example:**
 
@@ -284,11 +284,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)>
 
 **Example:**
 
@@ -317,7 +317,7 @@ Supported by IMU models.
 
 **Returns:**
 
-- ([viam.components.movement_sensor.Orientation](https://python.viam.dev/autoapi/viam/components/movement_sensor/index.html#viam.components.movement_sensor.Orientation)): The orientation.
+- ([viam.components.movement_sensor.Orientation](https://python.viam.dev/autoapi/viam/components/movement_sensor/index.html#viam.components.movement_sensor.Orientation)): :   The orientation.
 
 **Example:**
 
@@ -391,11 +391,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Orientation](https://flutter.viam.dev/viam_sdk/Orientation-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Orientation](https://flutter.viam.dev/viam_sdk/Orientation-class.html)>
 
 **Example:**
 
@@ -425,7 +425,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- (Tuple[viam.components.movement_sensor.GeoPoint, [float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)]): The current lat/long, along with the altitude in m.
+- (Tuple[viam.components.movement_sensor.GeoPoint, [float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)]): :   The current lat/long, along with the altitude in m.
 
 **Example:**
 
@@ -492,11 +492,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Position](https://flutter.viam.dev/viam_sdk/Position-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Position](https://flutter.viam.dev/viam_sdk/Position-class.html)>
 
 **Example:**
 
@@ -526,7 +526,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- ([viam.components.movement_sensor.movement_sensor.MovementSensor.Properties](https://python.viam.dev/autoapi/viam/components/movement_sensor/movement_sensor/index.html#viam.components.movement_sensor.movement_sensor.MovementSensor.Properties)): The properties.
+- ([viam.components.movement_sensor.movement_sensor.MovementSensor.Properties](https://python.viam.dev/autoapi/viam/components/movement_sensor/movement_sensor/index.html#viam.components.movement_sensor.movement_sensor.MovementSensor.Properties)): :   The properties.
 
 **Example:**
 
@@ -591,11 +591,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Properties](https://flutter.viam.dev/viam_sdk/Properties.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Properties](https://flutter.viam.dev/viam_sdk/Properties.html)>
 
 **Example:**
 
@@ -624,7 +624,7 @@ Supported by GPS models and `imu-wit`.
 
 **Returns:**
 
-- ([MovementSensor.Accuracy](https://python.viam.dev/autoapi/viam/components/movement_sensor/movement_sensor/index.html#viam.components.movement_sensor.movement_sensor.MovementSensor.Accuracy)): The accuracies of the movement sensor.
+- ([MovementSensor.Accuracy](https://python.viam.dev/autoapi/viam/components/movement_sensor/movement_sensor/index.html#viam.components.movement_sensor.movement_sensor.MovementSensor.Accuracy)): :   The accuracies of the movement sensor.
 
 **Example:**
 
@@ -704,11 +704,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Accuracy](https://flutter.viam.dev/viam_sdk/Accuracy.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Accuracy](https://flutter.viam.dev/viam_sdk/Accuracy.html)>
 
 **Example:**
 
@@ -738,7 +738,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- ([viam.components.movement_sensor.Vector3](https://python.viam.dev/autoapi/viam/components/movement_sensor/index.html#viam.components.movement_sensor.Vector3)): The linear acceleration in m/sec^2.
+- ([viam.components.movement_sensor.Vector3](https://python.viam.dev/autoapi/viam/components/movement_sensor/index.html#viam.components.movement_sensor.Vector3)): :   The linear acceleration in m/sec^2.
 
 **Example:**
 
@@ -807,11 +807,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Vector3](https://flutter.viam.dev/viam_sdk/Vector3-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Vector3](https://flutter.viam.dev/viam_sdk/Vector3-class.html)>
 
 **Example:**
 
@@ -839,7 +839,7 @@ The [motion](/operate/reference/services/motion/) and [navigation](/operate/refe
 
 **Returns:**
 
-- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): The geometries associated with the Component.
+- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): :   The geometries associated with the Component.
 
 **Example:**
 
@@ -874,7 +874,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.SensorReading]): The readings for the MovementSensor. Can be of any type.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.SensorReading]): :   The readings for the MovementSensor. Can be of any type.
 
 **Example:**
 
@@ -939,11 +939,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -984,7 +984,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own movement sensor and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own movement sensor and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 Supported by `viam-micro-server`.
 
 {{< tabs >}}
@@ -997,7 +997,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Raises:**
 
@@ -1042,7 +1042,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -1052,12 +1053,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -1068,11 +1073,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> (required)
+- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -1100,7 +1105,7 @@ Get the `ResourceName` for this movement sensor.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/components/apis/generated/power_sensor-table.md b/static/include/components/apis/generated/power_sensor-table.md
index fb10d9830a..76cb68ca31 100644
--- a/static/include/components/apis/generated/power_sensor-table.md
+++ b/static/include/components/apis/generated/power_sensor-table.md
@@ -1,11 +1,11 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`GetVoltage`](/dev/reference/apis/components/power-sensor/#getvoltage) | Return the voltage reading of a specified device and whether it is AC or DC. |
-| [`GetCurrent`](/dev/reference/apis/components/power-sensor/#getcurrent) | Return the current of a specified device and whether it is AC or DC. |
-| [`GetPower`](/dev/reference/apis/components/power-sensor/#getpower) | Return the power reading in watts. |
-| [`GetReadings`](/dev/reference/apis/components/power-sensor/#getreadings) | Get the measurements or readings that this power sensor provides. |
-| [`Reconfigure`](/dev/reference/apis/components/power-sensor/#reconfigure) | Reconfigure this resource. |
-| [`DoCommand`](/dev/reference/apis/components/power-sensor/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
-| [`GetResourceName`](/dev/reference/apis/components/power-sensor/#getresourcename) | Get the `ResourceName` for this power sensor. |
-| [`Close`](/dev/reference/apis/components/power-sensor/#close) | Safely shut down the resource and prevent further use. |
+| [`GetVoltage`](/reference/apis/components/power-sensor/#getvoltage) | Return the voltage reading of a specified device and whether it is AC or DC. |
+| [`GetCurrent`](/reference/apis/components/power-sensor/#getcurrent) | Return the current of a specified device and whether it is AC or DC. |
+| [`GetPower`](/reference/apis/components/power-sensor/#getpower) | Return the power reading in watts. |
+| [`GetReadings`](/reference/apis/components/power-sensor/#getreadings) | Get the measurements or readings that this power sensor provides. |
+| [`Reconfigure`](/reference/apis/components/power-sensor/#reconfigure) | Reconfigure this resource. |
+| [`DoCommand`](/reference/apis/components/power-sensor/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
+| [`GetResourceName`](/reference/apis/components/power-sensor/#getresourcename) | Get the `ResourceName` for this power sensor. |
+| [`Close`](/reference/apis/components/power-sensor/#close) | Safely shut down the resource and prevent further use. |
diff --git a/static/include/components/apis/generated/power_sensor.md b/static/include/components/apis/generated/power_sensor.md
index 378cbb5839..3ad1c1b293 100644
--- a/static/include/components/apis/generated/power_sensor.md
+++ b/static/include/components/apis/generated/power_sensor.md
@@ -12,8 +12,8 @@ Return the voltage reading of a specified device and whether it is AC or DC.
 
 **Returns:**
 
-- (Tuple[[float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex), [bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)]): A float representing the voltage reading in V. A bool indicating whether the voltage is AC (true) or DC
-(false).
+- (Tuple[[float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex), [bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)]): :   A float representing the voltage reading in V. A bool indicating whether the voltage is AC (true) or DC
+    (false).
 
 **Example:**
 
@@ -79,11 +79,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Voltage](https://flutter.viam.dev/viam_sdk/Voltage.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Voltage](https://flutter.viam.dev/viam_sdk/Voltage.html)>
 
 **Example:**
 
@@ -112,8 +112,8 @@ Return the current of a specified device and whether it is AC or DC.
 
 **Returns:**
 
-- (Tuple[[float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex), [bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)]): A tuple which includes a float representing the current reading in amps, and a bool indicating whether the
-current is AC (true) or DC (false).
+- (Tuple[[float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex), [bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)]): :   A tuple which includes a float representing the current reading in amps, and a bool indicating whether the
+    current is AC (true) or DC (false).
 
 **Example:**
 
@@ -179,11 +179,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Current](https://flutter.viam.dev/viam_sdk/Current.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Current](https://flutter.viam.dev/viam_sdk/Current.html)>
 
 **Example:**
 
@@ -212,7 +212,7 @@ Return the power reading in watts.
 
 **Returns:**
 
-- ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): The power reading in watts.
+- ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): :   The power reading in watts.
 
 **Example:**
 
@@ -277,11 +277,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[double](https://api.flutter.dev/flutter/dart-core/double-class.html)>
 
 **Example:**
 
@@ -309,8 +309,8 @@ If a sensor is not configured to have a measurement or fails to read a piece of
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.SensorReading]): The readings for the PowerSensor. Can be of any type. Includes voltage in volts (float), current in
-amperes (float), is\_ac (bool), and power in watts (float).
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.SensorReading]): :   The readings for the PowerSensor. Can be of any type. Includes voltage in volts (float), current in
+    amperes (float), is\_ac (bool), and power in watts (float).
 
 **Example:**
 
@@ -374,11 +374,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -419,7 +419,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own power sensor and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own power sensor and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -431,7 +431,7 @@ If you are implementing your own power sensor and want to add features that have
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Raises:**
 
@@ -476,7 +476,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -486,12 +487,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -502,11 +507,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> (required)
+- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -534,7 +539,7 @@ Get the `ResourceName` for this power sensor.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/components/apis/generated/sensor-table.md b/static/include/components/apis/generated/sensor-table.md
index e68922a922..875d5758a6 100644
--- a/static/include/components/apis/generated/sensor-table.md
+++ b/static/include/components/apis/generated/sensor-table.md
@@ -1,9 +1,9 @@
 <!-- prettier-ignore -->
 | Method Name | Description | `viam-micro-server` Support |
 | ----------- | ----------- | --------------------------- |
-| [`GetReadings`](/dev/reference/apis/components/sensor/#getreadings) | Get the measurements or readings that this sensor provides. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetGeometries`](/dev/reference/apis/components/sensor/#getgeometries) | Get all the geometries associated with the sensor in its current configuration, in the frame of the sensor. |
-| [`Reconfigure`](/dev/reference/apis/components/sensor/#reconfigure) | Reconfigure this resource. |  |
-| [`DoCommand`](/dev/reference/apis/components/sensor/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
-| [`GetResourceName`](/dev/reference/apis/components/sensor/#getresourcename) | Get the `ResourceName` for this sensor. |  |
-| [`Close`](/dev/reference/apis/components/sensor/#close) | Safely shut down the resource and prevent further use. |  |
+| [`GetReadings`](/reference/apis/components/sensor/#getreadings) | Get the measurements or readings that this sensor provides. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetGeometries`](/reference/apis/components/sensor/#getgeometries) | Get all the geometries associated with the sensor in its current configuration, in the frame of the sensor. |
+| [`Reconfigure`](/reference/apis/components/sensor/#reconfigure) | Reconfigure this resource. |  |
+| [`DoCommand`](/reference/apis/components/sensor/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
+| [`GetResourceName`](/reference/apis/components/sensor/#getresourcename) | Get the `ResourceName` for this sensor. |  |
+| [`Close`](/reference/apis/components/sensor/#close) | Safely shut down the resource and prevent further use. |  |
diff --git a/static/include/components/apis/generated/sensor.md b/static/include/components/apis/generated/sensor.md
index 6e9b33c028..53be45d465 100644
--- a/static/include/components/apis/generated/sensor.md
+++ b/static/include/components/apis/generated/sensor.md
@@ -13,7 +13,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.SensorReading]): The measurements. Can be of any type.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.SensorReading]): :   The measurements. Can be of any type.
 
 **Example:**
 
@@ -76,11 +76,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -108,7 +108,7 @@ The [motion](/operate/reference/services/motion/) and [navigation](/operate/refe
 
 **Returns:**
 
-- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): The geometries associated with the Component.
+- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): :   The geometries associated with the Component.
 
 **Example:**
 
@@ -154,7 +154,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own sensor and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own sensor and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -166,7 +166,7 @@ If you are implementing your own sensor and want to add features that have no co
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Raises:**
 
@@ -211,7 +211,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -221,12 +222,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -237,11 +242,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> (required)
+- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -269,7 +274,7 @@ Get the `ResourceName` for this sensor.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/components/apis/generated/servo-table.md b/static/include/components/apis/generated/servo-table.md
index c55a13ca2f..5a8e497685 100644
--- a/static/include/components/apis/generated/servo-table.md
+++ b/static/include/components/apis/generated/servo-table.md
@@ -1,11 +1,12 @@
 <!-- prettier-ignore -->
 | Method Name | Description | `viam-micro-server` Support |
 | ----------- | ----------- | --------------------------- |
-| [`Move`](/dev/reference/apis/components/servo/#move) | Move the servo to the desired angle in degrees. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetPosition`](/dev/reference/apis/components/servo/#getposition) | Get the current set angle of the servo in degrees. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`IsMoving`](/dev/reference/apis/components/servo/#ismoving) | Returns whether the servo is actively moving (or attempting to move) under its own power. |  |
-| [`Stop`](/dev/reference/apis/components/servo/#stop) | Stop the servo from moving. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`Reconfigure`](/dev/reference/apis/components/servo/#reconfigure) | Reconfigure this resource. |  |
-| [`DoCommand`](/dev/reference/apis/components/servo/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
-| [`GetResourceName`](/dev/reference/apis/components/servo/#getresourcename) | Get the `ResourceName` for this servo. |  |
-| [`Close`](/dev/reference/apis/components/servo/#close) | Safely shut down the resource and prevent further use. |  |
+| [`Move`](/reference/apis/components/servo/#move) | Move the servo to the desired angle in degrees. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetPosition`](/reference/apis/components/servo/#getposition) | Get the current set angle of the servo in degrees. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`IsMoving`](/reference/apis/components/servo/#ismoving) | Returns whether the servo is actively moving (or attempting to move) under its own power. |  |
+| [`Stop`](/reference/apis/components/servo/#stop) | Stop the servo from moving. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetGeometries`](/reference/apis/components/servo/#getgeometries) | Get all the geometries associated with the servo in its current configuration, in the frame of the servo. |  |
+| [`Reconfigure`](/reference/apis/components/servo/#reconfigure) | Reconfigure this resource. |  |
+| [`DoCommand`](/reference/apis/components/servo/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. |
+| [`GetResourceName`](/reference/apis/components/servo/#getresourcename) | Get the `ResourceName` for this servo. |  |
+| [`Close`](/reference/apis/components/servo/#close) | Safely shut down the resource and prevent further use. |  |
diff --git a/static/include/components/apis/generated/servo.md b/static/include/components/apis/generated/servo.md
index 80e2a868c0..8b128393e2 100644
--- a/static/include/components/apis/generated/servo.md
+++ b/static/include/components/apis/generated/servo.md
@@ -98,11 +98,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 **Parameters:**
 
 - `angle` [int](https://api.flutter.dev/flutter/dart-core/int-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -130,7 +130,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): The current angle of the servo in degrees.
+- ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): :   The current angle of the servo in degrees.
 
 **Example:**
 
@@ -211,11 +211,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[int](https://api.flutter.dev/flutter/dart-core/int-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[int](https://api.flutter.dev/flutter/dart-core/int-class.html)>
 
 **Example:**
 
@@ -241,7 +241,7 @@ Returns whether the servo is actively moving (or attempting to move) under its o
 
 **Returns:**
 
-- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): Whether the servo is moving.
+- ([bool](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)): :   Whether the servo is moving.
 
 **Example:**
 
@@ -312,7 +312,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[bool](https://api.flutter.dev/flutter/dart-core/bool-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[bool](https://api.flutter.dev/flutter/dart-core/bool-class.html)>
 
 **Example:**
 
@@ -411,11 +411,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -428,6 +428,39 @@ For more information, see the [Flutter SDK Docs](https://flutter.viam.dev/viam_s
 {{% /tab %}}
 {{< /tabs >}}
 
+### GetGeometries
+
+Get all the geometries associated with the servo in its current configuration, in the [frame](/operate/reference/services/frame-system/) of the servo.
+The [motion](/operate/reference/services/motion/) and [navigation](/operate/reference/services/navigation/) services use the relative position of inherent geometries to configured geometries representing obstacles for collision detection and obstacle avoidance while motion planning.
+
+{{< tabs >}}
+{{% tab name="Python" %}}
+
+**Parameters:**
+
+- `extra` (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]) (optional): Extra options to pass to the underlying RPC call.
+- `timeout` ([float](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)) (optional): An option to set how long to wait (in seconds) before calling a time-out and closing the underlying RPC call.
+
+**Returns:**
+
+- ([List[viam.proto.common.Geometry]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.Geometry)): :   The geometries associated with the Component.
+
+**Example:**
+
+```python {class="line-numbers linkable-line-numbers"}
+my_servo = Servo.from_robot(robot=machine, name="my_servo")
+geometries = await my_servo.get_geometries()
+
+if geometries:
+    # Get the center of the first geometry
+    print(f"Pose of the first geometry's centerpoint: {geometries[0].center}")
+```
+
+For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/components/servo/client/index.html#viam.components.servo.client.ServoClient.get_geometries).
+
+{{% /tab %}}
+{{< /tabs >}}
+
 ### Reconfigure
 
 Reconfigure this resource.
@@ -456,7 +489,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own servo and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own servo and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -468,7 +501,7 @@ If you are implementing your own servo and want to add features that have no cor
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Raises:**
 
@@ -513,7 +546,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -523,12 +557,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -539,11 +577,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> (required)
+- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -571,7 +609,7 @@ Get the `ResourceName` for this servo.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/components/apis/generated/switch-table.md b/static/include/components/apis/generated/switch-table.md
index 8618b963e8..0ba389e99d 100644
--- a/static/include/components/apis/generated/switch-table.md
+++ b/static/include/components/apis/generated/switch-table.md
@@ -1,9 +1,9 @@
 <!-- prettier-ignore -->
 | Method Name | Description | `viam-micro-server` Support |
 | ----------- | ----------- | --------------------------- |
-| [`SetPosition`](/dev/reference/apis/components/switch/#setposition) | Set the position of the switch. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetPosition`](/dev/reference/apis/components/switch/#getposition) | Return the current position of the switch. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetNumberOfPositions`](/dev/reference/apis/components/switch/#getnumberofpositions) | Return the number of valid positions for this switch. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`DoCommand`](/dev/reference/apis/components/switch/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetResourceName`](/dev/reference/apis/components/switch/#getresourcename) | Get the `ResourceName` for this servo. |  |
-| [`Close`](/dev/reference/apis/components/switch/#close) | Safely shut down the resource and prevent further use. |  |
+| [`SetPosition`](/reference/apis/components/switch/#setposition) | Set the position of the switch. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetPosition`](/reference/apis/components/switch/#getposition) | Return the current position of the switch. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetNumberOfPositions`](/reference/apis/components/switch/#getnumberofpositions) | Return the number of valid positions for this switch. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`DoCommand`](/reference/apis/components/switch/#docommand) | Execute model-specific commands that are not otherwise defined by the component API. | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetResourceName`](/reference/apis/components/switch/#getresourcename) | Get the `ResourceName` for this servo. |  |
+| [`Close`](/reference/apis/components/switch/#close) | Safely shut down the resource and prevent further use. |  |
diff --git a/static/include/components/apis/generated/switch.md b/static/include/components/apis/generated/switch.md
index bbe30ceb92..af857c5020 100644
--- a/static/include/components/apis/generated/switch.md
+++ b/static/include/components/apis/generated/switch.md
@@ -99,7 +99,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): The current position of the switch within the range of available positions.
+- ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): :   The current position of the switch within the range of available positions.
 
 **Example:**
 
@@ -194,7 +194,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- ([int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)): The number of available positions.
+- (Tuple[[int](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex), Sequence[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)]]): :   The number of available positions and their labels.
 
 **Example:**
 
@@ -262,7 +262,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own switch and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own switch and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 Supported by `viam-micro-server`.
 
 {{< tabs >}}
@@ -275,7 +275,7 @@ Supported by `viam-micro-server`.
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Raises:**
 
@@ -320,7 +320,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -330,12 +331,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -357,7 +362,7 @@ Get the `ResourceName` for this servo.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/components/apis/movement-sensor.md b/static/include/components/apis/movement-sensor.md
index 7f7b6286e3..a825895794 100644
--- a/static/include/components/apis/movement-sensor.md
+++ b/static/include/components/apis/movement-sensor.md
@@ -1,14 +1,14 @@
 <!-- prettier-ignore -->
 | Method Name | Description | Models That Support This Method | `viam-micro-server` Support |
 | ----------- | ----------- | ------------------------------- | ----------------- |
-| [`GetPosition`](/dev/reference/apis/components/movement-sensor/#getposition) | Get the current latitude, longitude and altitude. | GPS models, `wheeled-odometry` | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetLinearVelocity`](/dev/reference/apis/components/movement-sensor/#getlinearvelocity) | Get the current linear velocity as a 3D vector. | GPS models, `wheeled-odometry` | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetAngularVelocity`](/dev/reference/apis/components/movement-sensor/#getangularvelocity) | Get the current angular velocity as a 3D vector. | IMU models, `gyro-mpu6050`, and `wheeled-odometry` | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetLinearAcceleration`](/dev/reference/apis/components/movement-sensor/#getlinearacceleration) | Get the current linear acceleration as a 3D vector. | IMU models,  `accel-adxl345`, and `gyro-mpu6050` | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetCompassHeading`](/dev/reference/apis/components/movement-sensor/#getcompassheading) | Get the current compass heading in degrees. | GPS models | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetOrientation`](/dev/reference/apis/components/movement-sensor/#getorientation) | Get the current orientation. | IMU models, `wheeled-odometry` |  |
-| [`GetProperties`](/dev/reference/apis/components/movement-sensor/#getproperties) | Get the supported properties of this sensor. | all models | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`GetAccuracy`](/dev/reference/apis/components/movement-sensor/#getaccuracy) | Get the accuracy of the various sensors. | GPS models |  |
-| [`GetReadings`](/dev/reference/apis/components/movement-sensor/#getreadings) | Obtain the measurements/data specific to this sensor. | all models | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`DoCommand`](/dev/reference/apis/components/movement-sensor/#docommand) | Send or receive model-specific commands. | all models | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
-| [`Close`](/dev/reference/apis/components/movement-sensor/#close) | Safely shut down the resource and prevent further use. | all models |  |
+| [`GetPosition`](/reference/apis/components/movement-sensor/#getposition) | Get the current latitude, longitude and altitude. | GPS models, `wheeled-odometry` | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetLinearVelocity`](/reference/apis/components/movement-sensor/#getlinearvelocity) | Get the current linear velocity as a 3D vector. | GPS models, `wheeled-odometry` | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetAngularVelocity`](/reference/apis/components/movement-sensor/#getangularvelocity) | Get the current angular velocity as a 3D vector. | IMU models, `gyro-mpu6050`, and `wheeled-odometry` | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetLinearAcceleration`](/reference/apis/components/movement-sensor/#getlinearacceleration) | Get the current linear acceleration as a 3D vector. | IMU models,  `accel-adxl345`, and `gyro-mpu6050` | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetCompassHeading`](/reference/apis/components/movement-sensor/#getcompassheading) | Get the current compass heading in degrees. | GPS models | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetOrientation`](/reference/apis/components/movement-sensor/#getorientation) | Get the current orientation. | IMU models, `wheeled-odometry` |  |
+| [`GetProperties`](/reference/apis/components/movement-sensor/#getproperties) | Get the supported properties of this sensor. | all models | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`GetAccuracy`](/reference/apis/components/movement-sensor/#getaccuracy) | Get the accuracy of the various sensors. | GPS models |  |
+| [`GetReadings`](/reference/apis/components/movement-sensor/#getreadings) | Obtain the measurements/data specific to this sensor. | all models | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`DoCommand`](/reference/apis/components/movement-sensor/#docommand) | Send or receive model-specific commands. | all models | <p class="center-text"><i class="fas fa-check" title="yes"></i></p> |
+| [`Close`](/reference/apis/components/movement-sensor/#close) | Safely shut down the resource and prevent further use. | all models |  |
diff --git a/static/include/components/apis/overrides/methods/go.camera.Stream.before.md b/static/include/components/apis/overrides/methods/go.camera.Stream.before.md
index c30302f63e..ceae7a65f3 100644
--- a/static/include/components/apis/overrides/methods/go.camera.Stream.before.md
+++ b/static/include/components/apis/overrides/methods/go.camera.Stream.before.md
@@ -1,6 +1,6 @@
 {{% alert title="Info" color="info" %}}
 
-Unlike most Viam [component APIs](/dev/reference/apis/#component-apis), the methods of the Go camera client do not map exactly to the names of the other SDK's camera methods.
+Unlike most Viam [component APIs](/reference/apis/#component-apis), the methods of the Go camera client do not map exactly to the names of the other SDK's camera methods.
 To get an image in the Go SDK, you first need to construct a `Stream` and then you can get the next image from that stream.
 
 {{% /alert %}}
diff --git a/static/include/components/apis/overrides/methods/go.input_controller.RegisterControlCallback.control.md b/static/include/components/apis/overrides/methods/go.input_controller.RegisterControlCallback.control.md
index 7dd8ecbcb5..ef03e79912 100644
--- a/static/include/components/apis/overrides/methods/go.input_controller.RegisterControlCallback.control.md
+++ b/static/include/components/apis/overrides/methods/go.input_controller.RegisterControlCallback.control.md
@@ -1 +1 @@
-The [Control](/dev/reference/apis/components/input-controller/#control-field) to register the function for.
+The [Control](/reference/apis/components/input-controller/#control-field) to register the function for.
diff --git a/static/include/components/apis/overrides/protos/arm.DoCommand.md b/static/include/components/apis/overrides/protos/arm.DoCommand.md
index 66be2f67bf..afe56e3520 100644
--- a/static/include/components/apis/overrides/protos/arm.DoCommand.md
+++ b/static/include/components/apis/overrides/protos/arm.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own arm and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own arm and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/components/apis/overrides/protos/audio_in.DoCommand.md b/static/include/components/apis/overrides/protos/audio_in.DoCommand.md
index 66be2f67bf..afe56e3520 100644
--- a/static/include/components/apis/overrides/protos/audio_in.DoCommand.md
+++ b/static/include/components/apis/overrides/protos/audio_in.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own arm and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own arm and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/components/apis/overrides/protos/audio_out.DoCommand.md b/static/include/components/apis/overrides/protos/audio_out.DoCommand.md
index 66be2f67bf..afe56e3520 100644
--- a/static/include/components/apis/overrides/protos/audio_out.DoCommand.md
+++ b/static/include/components/apis/overrides/protos/audio_out.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own arm and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own arm and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/components/apis/overrides/protos/base.DoCommand.md b/static/include/components/apis/overrides/protos/base.DoCommand.md
index a1dfde929d..738db15a9e 100644
--- a/static/include/components/apis/overrides/protos/base.DoCommand.md
+++ b/static/include/components/apis/overrides/protos/base.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own base and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own base and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/components/apis/overrides/protos/board.DoCommand.md b/static/include/components/apis/overrides/protos/board.DoCommand.md
index 37147fdbb8..fec2b8a0d5 100644
--- a/static/include/components/apis/overrides/protos/board.DoCommand.md
+++ b/static/include/components/apis/overrides/protos/board.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own board and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own board and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/components/apis/overrides/protos/button.DoCommand.md b/static/include/components/apis/overrides/protos/button.DoCommand.md
index 9d1238835d..5cc882c774 100644
--- a/static/include/components/apis/overrides/protos/button.DoCommand.md
+++ b/static/include/components/apis/overrides/protos/button.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own button and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own button and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/components/apis/overrides/protos/camera.DoCommand.md b/static/include/components/apis/overrides/protos/camera.DoCommand.md
index ef3a50bb4a..cb57da5025 100644
--- a/static/include/components/apis/overrides/protos/camera.DoCommand.md
+++ b/static/include/components/apis/overrides/protos/camera.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own camera and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own camera and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/components/apis/overrides/protos/encoder.DoCommand.md b/static/include/components/apis/overrides/protos/encoder.DoCommand.md
index 4833ab054b..ca1a4a4ef8 100644
--- a/static/include/components/apis/overrides/protos/encoder.DoCommand.md
+++ b/static/include/components/apis/overrides/protos/encoder.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own encoder as a {{< glossary_tooltip term_id="modular-resource" text="modular resource" >}} and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own encoder as a {{< glossary_tooltip term_id="modular-resource" text="modular resource" >}} and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/components/apis/overrides/protos/gantry.DoCommand.md b/static/include/components/apis/overrides/protos/gantry.DoCommand.md
index c4296883cc..f81bcc1553 100644
--- a/static/include/components/apis/overrides/protos/gantry.DoCommand.md
+++ b/static/include/components/apis/overrides/protos/gantry.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own gantry and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own gantry and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/components/apis/overrides/protos/generic_component.DoCommand.md b/static/include/components/apis/overrides/protos/generic_component.DoCommand.md
index 55073402a6..fbff3e633c 100644
--- a/static/include/components/apis/overrides/protos/generic_component.DoCommand.md
+++ b/static/include/components/apis/overrides/protos/generic_component.DoCommand.md
@@ -1,2 +1,2 @@
 Execute model-specific commands.
-If you are implementing your own generic component and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own generic component and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/components/apis/overrides/protos/gripper.DoCommand.md b/static/include/components/apis/overrides/protos/gripper.DoCommand.md
index 4286d26dc3..beddb5598f 100644
--- a/static/include/components/apis/overrides/protos/gripper.DoCommand.md
+++ b/static/include/components/apis/overrides/protos/gripper.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own gripper and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own gripper and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/components/apis/overrides/protos/input_controller.DoCommand.md b/static/include/components/apis/overrides/protos/input_controller.DoCommand.md
index a973bf236d..b1282f3a9b 100644
--- a/static/include/components/apis/overrides/protos/input_controller.DoCommand.md
+++ b/static/include/components/apis/overrides/protos/input_controller.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own input controller and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own input controller and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/components/apis/overrides/protos/input_controller.GetControls.md b/static/include/components/apis/overrides/protos/input_controller.GetControls.md
index 657f2a7291..ea5953cf4d 100644
--- a/static/include/components/apis/overrides/protos/input_controller.GetControls.md
+++ b/static/include/components/apis/overrides/protos/input_controller.GetControls.md
@@ -1 +1 @@
-Get a list of the [Controls](/dev/reference/apis/components/input-controller/#control-field) that your controller provides.
+Get a list of the [Controls](/reference/apis/components/input-controller/#control-field) that your controller provides.
diff --git a/static/include/components/apis/overrides/protos/motor.DoCommand.md b/static/include/components/apis/overrides/protos/motor.DoCommand.md
index f1491d2440..9b821988ff 100644
--- a/static/include/components/apis/overrides/protos/motor.DoCommand.md
+++ b/static/include/components/apis/overrides/protos/motor.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own motor and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own motor and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/components/apis/overrides/protos/movement_sensor.DoCommand.md b/static/include/components/apis/overrides/protos/movement_sensor.DoCommand.md
index d573e70a28..74c2aeeaa6 100644
--- a/static/include/components/apis/overrides/protos/movement_sensor.DoCommand.md
+++ b/static/include/components/apis/overrides/protos/movement_sensor.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own movement sensor and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own movement sensor and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/components/apis/overrides/protos/power_sensor.DoCommand.md b/static/include/components/apis/overrides/protos/power_sensor.DoCommand.md
index 38ebd77f9f..1e8678a770 100644
--- a/static/include/components/apis/overrides/protos/power_sensor.DoCommand.md
+++ b/static/include/components/apis/overrides/protos/power_sensor.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own power sensor and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own power sensor and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/components/apis/overrides/protos/sensor.DoCommand.md b/static/include/components/apis/overrides/protos/sensor.DoCommand.md
index e6e4130c58..b6f1b66f42 100644
--- a/static/include/components/apis/overrides/protos/sensor.DoCommand.md
+++ b/static/include/components/apis/overrides/protos/sensor.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own sensor and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own sensor and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/components/apis/overrides/protos/servo.DoCommand.md b/static/include/components/apis/overrides/protos/servo.DoCommand.md
index 74c7b6bafc..efeedb05ff 100644
--- a/static/include/components/apis/overrides/protos/servo.DoCommand.md
+++ b/static/include/components/apis/overrides/protos/servo.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own servo and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own servo and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/components/apis/overrides/protos/switch.DoCommand.md b/static/include/components/apis/overrides/protos/switch.DoCommand.md
index bdf1c66c5f..74ca8d2d2d 100644
--- a/static/include/components/apis/overrides/protos/switch.DoCommand.md
+++ b/static/include/components/apis/overrides/protos/switch.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the component API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own switch and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own switch and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/components/board/board-digital-interrupts.md b/static/include/components/board/board-digital-interrupts.md
index 10b77fb940..f8b4bb39b6 100644
--- a/static/include/components/board/board-digital-interrupts.md
+++ b/static/include/components/board/board-digital-interrupts.md
@@ -2,8 +2,8 @@
 Configuring digital interrupts to monitor GPIO pins on your board is useful when your application needs to know precisely when there is a change in GPIO value between high and low.
 
 - When an interrupt configured on your board processes a change in the state of the GPIO pin it is configured to monitor, it ticks to record the state change.
-  You can stream these ticks with the board API's [`StreamTicks()`](/dev/reference/apis/components/board/#streamticks), or get the current value of the digital interrupt with [`Value()`](/dev/reference/apis/components/board/#getdigitalinterruptvalue).
-- Calling [`GetGPIO()`](/dev/reference/apis/components/board/#getgpio) on a GPIO pin, which you can do without configuring interrupts, is useful when you want to know a pin's value at specific points in your program, but is less precise and convenient than using an interrupt.
+  You can stream these ticks with the board API's [`StreamTicks()`](/reference/apis/components/board/#streamticks), or get the current value of the digital interrupt with [`Value()`](/reference/apis/components/board/#getdigitalinterruptvalue).
+- Calling [`GetGPIO()`](/reference/apis/components/board/#getgpio) on a GPIO pin, which you can do without configuring interrupts, is useful when you want to know a pin's value at specific points in your program, but is less precise and convenient than using an interrupt.
 
 Integrate `digital_interrupts` into your machine in the `attributes` of your board by following the **Config Builder** instructions, or by adding the following to your board's JSON configuration:
 
diff --git a/static/include/components/board/test-board-analogs.md b/static/include/components/board/test-board-analogs.md
index 3d2c983d46..4eb9ace555 100644
--- a/static/include/components/board/test-board-analogs.md
+++ b/static/include/components/board/test-board-analogs.md
@@ -1,4 +1,4 @@
-Once you have configured your analogs, open the board's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/manage/troubleshoot/teleoperate/default-interface/#web-ui) tabs to monitor analogs.
+Once you have configured your analogs, open the board's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/monitor/default-interface/#web-ui) tabs to monitor analogs.
 The numbers displayed next to each analog name represent the digital signal received from the analog inputs.
 
 {{<imgproc src="/components/board/analogs-control-tab.png" alt="Analogs in the test panel." resize="800x" style="width:500px" class="imgzoom">}}
diff --git a/static/include/components/board/test-board-digital-interrupts.md b/static/include/components/board/test-board-digital-interrupts.md
index 8266efdc0b..996de837f8 100644
--- a/static/include/components/board/test-board-digital-interrupts.md
+++ b/static/include/components/board/test-board-digital-interrupts.md
@@ -1,4 +1,4 @@
-Once you have configured your digital interrupts, open the board's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/manage/troubleshoot/teleoperate/default-interface/#web-ui) tabs to monitor interrupt activity.
+Once you have configured your digital interrupts, open the board's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/monitor/default-interface/#web-ui) tabs to monitor interrupt activity.
 The value displayed next to each interrupt name represents the total count of interrupts triggered by the corresponding digital interrupt.
 
 {{<imgproc src="/components/board/digital-interrupts-control-tab.png" alt="Digital interrupts in the test panel." resize="800x" style="width:500px" class="imgzoom">}}
diff --git a/static/include/components/camera-view-camera-stream.md b/static/include/components/camera-view-camera-stream.md
index 923d770eef..23c8bb36c7 100644
--- a/static/include/components/camera-view-camera-stream.md
+++ b/static/include/components/camera-view-camera-stream.md
@@ -1,4 +1,4 @@
-Once your camera is configured and connected, expand the **TEST** panel on the **CONFIGURE** or [**CONTROL**](/manage/troubleshoot/teleoperate/default-interface/#web-ui) tabs.
+Once your camera is configured and connected, expand the **TEST** panel on the **CONFIGURE** or [**CONTROL**](/monitor/default-interface/#web-ui) tabs.
 If everything is configured correctly, you will see the live feed from your camera.
 
 {{< imgproc src="/components/camera/example_camera_image.png" alt="Example Camera view" resize="800x" style="width:500px" class="imgzoom shadow" >}}
diff --git a/static/include/components/test-control/arm-control.md b/static/include/components/test-control/arm-control.md
index 8dd87b2377..1129415fdb 100644
--- a/static/include/components/test-control/arm-control.md
+++ b/static/include/components/test-control/arm-control.md
@@ -1,9 +1,9 @@
 ## Test the arm
 
-Once your arm is configured and connected, open the arm's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/manage/troubleshoot/teleoperate/default-interface/#web-ui) tabs.
+Once your arm is configured and connected, open the arm's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/monitor/default-interface/#web-ui) tabs.
 
 Use the buttons to move the end position or the joints and check whether it moves as expected.
 
 {{<imgproc src="/components/arm/control.png" alt="Arm test panel." resize="800x" style="width:500px" class="imgzoom shadow">}}
 
-If the arm does not appear on the **TEST** panel, or if you notice unexpected behavior, check your machine's [**LOGS** tab](/manage/troubleshoot/troubleshoot/#check-logs) for errors, and review the configuration.
+If the arm does not appear on the **TEST** panel, or if you notice unexpected behavior, check your machine's [**LOGS** tab](/monitor/troubleshoot/#check-logs) for errors, and review the configuration.
diff --git a/static/include/components/test-control/base-control.md b/static/include/components/test-control/base-control.md
index 9f5d6ea2f8..f1d1b43d77 100644
--- a/static/include/components/test-control/base-control.md
+++ b/static/include/components/test-control/base-control.md
@@ -1,4 +1,4 @@
-After you configure the base, open the base's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/manage/troubleshoot/teleoperate/default-interface/#web-ui) tabs to view the controls to enable keyboard or discrete control over your machine's movement.
+After you configure the base, open the base's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/monitor/default-interface/#web-ui) tabs to view the controls to enable keyboard or discrete control over your machine's movement.
 
 {{< imgproc src="/components/base/base-control-tab.png" alt="The base component in control tab" resize="800x" style="width:500px" class="imgzoom" >}}
 
diff --git a/static/include/components/test-control/encoder-control.md b/static/include/components/test-control/encoder-control.md
index 4ce96fd2d8..bb87dd891c 100644
--- a/static/include/components/test-control/encoder-control.md
+++ b/static/include/components/test-control/encoder-control.md
@@ -1,9 +1,9 @@
 ## Test the encoder
 
-Once your encoder is configured and connected, open the encoders's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/manage/troubleshoot/teleoperate/default-interface/#web-ui) tabs.
+Once your encoder is configured and connected, open the encoders's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/monitor/default-interface/#web-ui) tabs.
 The ticks count is displayed.
 Try moving the encoder (for example, by turning a motor it is attached to) and check whether the count increases as expected.
 
 {{<imgproc src="/components/encoder/control.png" alt="Encoder test panel." resize="800x" style="width:500px" class="imgzoom">}}
 
-If the encoder does not appear on the **TEST** panel, or if you notice unexpected behavior, check your machine's [**LOGS** tab](/manage/troubleshoot/troubleshoot/#check-logs) for errors, and review the configuration.
+If the encoder does not appear on the **TEST** panel, or if you notice unexpected behavior, check your machine's [**LOGS** tab](/monitor/troubleshoot/#check-logs) for errors, and review the configuration.
diff --git a/static/include/components/test-control/gantry-control.md b/static/include/components/test-control/gantry-control.md
index dc4005f10c..fd0b820be8 100644
--- a/static/include/components/test-control/gantry-control.md
+++ b/static/include/components/test-control/gantry-control.md
@@ -1,9 +1,9 @@
 ## Test the gantry
 
-Once your gantry is configured and connected, open the gantry's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/manage/troubleshoot/teleoperate/default-interface/#web-ui) tabs.
+Once your gantry is configured and connected, open the gantry's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/monitor/default-interface/#web-ui) tabs.
 
 Use the panel to adjust the position of the actuator on the axis and check whether it moves as expected.
 
 {{<imgproc src="/components/gantry/gantry-control-tab.png" declaredimensions=true alt="Gantry test panel." resize="800x" style="width:500px" class="imgzoom">}}
 
-If the gantry does not appear on the **TEST** panel, or if you notice unexpected behavior, check your machine's [**LOGS** tab](/manage/troubleshoot/troubleshoot/#check-logs) for errors, and review the configuration.
+If the gantry does not appear on the **TEST** panel, or if you notice unexpected behavior, check your machine's [**LOGS** tab](/monitor/troubleshoot/#check-logs) for errors, and review the configuration.
diff --git a/static/include/components/test-control/generic-control.md b/static/include/components/test-control/generic-control.md
index 90bb352858..15eec0016b 100644
--- a/static/include/components/test-control/generic-control.md
+++ b/static/include/components/test-control/generic-control.md
@@ -1,7 +1,7 @@
 ## Test the generic component
 
-After you configure your generic component, open the generic's panel on the [**CONTROL**](/manage/troubleshoot/teleoperate/default-interface/#web-ui) tab.
-Use the card to send arbitrary commands to the resource with [`DoCommand()`](/dev/reference/apis/components/generic/#docommand).
+After you configure your generic component, open the generic's panel on the [**CONTROL**](/monitor/default-interface/#web-ui) tab.
+Use the card to send arbitrary commands to the resource with [`DoCommand()`](/reference/apis/components/generic/#docommand).
 
 {{<imgproc src="/components/generic/generic-control.png" alt="The generic component in control panel." resize="900x" style="width:500px" class="imgzoom shadow">}}
 
diff --git a/static/include/components/test-control/gripper-control.md b/static/include/components/test-control/gripper-control.md
index d0b8ac3eab..af0a2bf442 100644
--- a/static/include/components/test-control/gripper-control.md
+++ b/static/include/components/test-control/gripper-control.md
@@ -1,6 +1,6 @@
 ## Test the gripper
 
-After you configure your gripper, open the gripper's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/manage/troubleshoot/teleoperate/default-interface/#web-ui) tabs.
+After you configure your gripper, open the gripper's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/monitor/default-interface/#web-ui) tabs.
 Use the buttons to open and close the gripper.
 
 {{<imgproc src="/components/gripper/gripper-control-tab.png" alt="The gripper component in the test panel" resize="800x" style="width:500px" class="imgzoom">}}
diff --git a/static/include/components/test-control/input-controller-control.md b/static/include/components/test-control/input-controller-control.md
index 2f455f11cf..51ae48639f 100644
--- a/static/include/components/test-control/input-controller-control.md
+++ b/static/include/components/test-control/input-controller-control.md
@@ -1,6 +1,6 @@
 ## Test the input controller
 
-After you configure your input controller, open the input controller's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/manage/troubleshoot/teleoperate/default-interface/#web-ui) tabs.
+After you configure your input controller, open the input controller's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/monitor/default-interface/#web-ui) tabs.
 View the current value of each input on your controller.
 
 {{<imgproc src="/components/input-controller/input-controller-control-tab.png" alt="The input controller component in the test panel." resize="800x" style="width:500px">}}
diff --git a/static/include/components/test-control/motor-control.md b/static/include/components/test-control/motor-control.md
index c4ff2c6c33..f5cf8c8b8e 100644
--- a/static/include/components/test-control/motor-control.md
+++ b/static/include/components/test-control/motor-control.md
@@ -1,6 +1,6 @@
-Once your motor is configured and connected, open the motor's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/manage/troubleshoot/teleoperate/default-interface/#web-ui) tabs.
+Once your motor is configured and connected, open the motor's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/monitor/default-interface/#web-ui) tabs.
 Use the buttons to try turning your motor forwards or backwards at different power levels and check whether it moves as expected.
 
 {{<imgproc src="/components/motor/control.png" alt="Motor test panel." resize="800x" style="width:500px" class="imgzoom">}}
 
-If the motor does not appear on the **TEST** panel, or if you notice unexpected behavior, check your machine's [**LOGS** tab](/manage/troubleshoot/troubleshoot/#check-logs) for errors, and review the configuration.
+If the motor does not appear on the **TEST** panel, or if you notice unexpected behavior, check your machine's [**LOGS** tab](/monitor/troubleshoot/#check-logs) for errors, and review the configuration.
diff --git a/static/include/components/test-control/movement-sensor-gps-control.md b/static/include/components/test-control/movement-sensor-gps-control.md
index 9a32354b4a..7a17384ebc 100644
--- a/static/include/components/test-control/movement-sensor-gps-control.md
+++ b/static/include/components/test-control/movement-sensor-gps-control.md
@@ -1,6 +1,6 @@
 ## Test the movement sensor
 
-After you configure your movement sensor, open the movement sensor's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/manage/troubleshoot/teleoperate/default-interface/#web-ui) tabs.
+After you configure your movement sensor, open the movement sensor's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/monitor/default-interface/#web-ui) tabs.
 This panel presents the data collected by the movement sensor.
 The sections in the panel include the position, linear velocity and compass heading.
 
diff --git a/static/include/components/test-control/movement-sensor-imu-control.md b/static/include/components/test-control/movement-sensor-imu-control.md
index e0ae630483..14b15e7d1f 100644
--- a/static/include/components/test-control/movement-sensor-imu-control.md
+++ b/static/include/components/test-control/movement-sensor-imu-control.md
@@ -1,6 +1,6 @@
 ## Test the movement sensor
 
-After you configure your movement sensor, open the movement sensor's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/manage/troubleshoot/teleoperate/default-interface/#web-ui) tabs.
+After you configure your movement sensor, open the movement sensor's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/monitor/default-interface/#web-ui) tabs.
 This panel presents the data collected by the movement sensor.
 The sections in the panel include the orientation, angular velocity and linear acceleration.
 
diff --git a/static/include/components/test-control/power-sensor-control.md b/static/include/components/test-control/power-sensor-control.md
index fb2bb9feab..655a0c747d 100644
--- a/static/include/components/test-control/power-sensor-control.md
+++ b/static/include/components/test-control/power-sensor-control.md
@@ -1,6 +1,6 @@
 ## Test the power sensor
 
-After you configure your power sensor, open the power sensor's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/manage/troubleshoot/teleoperate/default-interface/#web-ui) tabs.
+After you configure your power sensor, open the power sensor's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/monitor/default-interface/#web-ui) tabs.
 The panel contains readings for your voltage, current, and power.
 
 {{<imgproc src="/components/power-sensor/power-sensor-control.png" alt="An instance of the power sensor component's test panel with voltage, current, and power readings." resize="800x" style="width:500px" class="imgzoom">}}
diff --git a/static/include/components/test-control/sensor-control.md b/static/include/components/test-control/sensor-control.md
index 48ce0b1f34..72b49112ff 100644
--- a/static/include/components/test-control/sensor-control.md
+++ b/static/include/components/test-control/sensor-control.md
@@ -1,4 +1,4 @@
-After you configure your sensor, open the sensor's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/manage/troubleshoot/teleoperate/default-interface/#web-ui) tabs.
+After you configure your sensor, open the sensor's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/monitor/default-interface/#web-ui) tabs.
 To access detailed readings from your sensor, click on the **Get Readings** button.
 
 {{<imgproc src="/components/sensor/sensor-control-tab.png" declaredimensions=true alt="The sensor component in the test panel" resize="800x" style="width:500px" class="imgzoom">}}
diff --git a/static/include/components/test-control/servo-control.md b/static/include/components/test-control/servo-control.md
index 9244624664..ec7886220a 100644
--- a/static/include/components/test-control/servo-control.md
+++ b/static/include/components/test-control/servo-control.md
@@ -1,5 +1,5 @@
 ## Test the servo
 
-After you establish the connection to your servo motor, open the servo's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/manage/troubleshoot/teleoperate/default-interface/#web-ui) tabs. Use the buttons to move the servo motor to the desired angle.
+After you establish the connection to your servo motor, open the servo's **TEST** panel on the **CONFIGURE** or [**CONTROL**](/monitor/default-interface/#web-ui) tabs. Use the buttons to move the servo motor to the desired angle.
 
 {{<imgproc src="/components/servo/servo-control-tab.png" alt="The servo component in the test panel" resize="800x" style="width:500px" class="imgzoom">}}
diff --git a/static/include/components/troubleshoot/camera.md b/static/include/components/troubleshoot/camera.md
index fc99132596..8fd75d42bf 100644
--- a/static/include/components/troubleshoot/camera.md
+++ b/static/include/components/troubleshoot/camera.md
@@ -2,7 +2,7 @@ If your camera is not working as expected, follow these steps:
 
 1. Check your machine logs on the **LOGS** tab to check for errors.
 1. Review this camera model's documentation to ensure you have configured all required attributes.
-1. Click on the **TEST** panel on the **CONFIGURE** or **CONTROL** tab and test if you can use the camera there.
+1. Click on the **Test** panel on the **CONFIGURE** or **CONTROL** tab and test if you can use the camera there.
 
 If none of these steps work, reach out to us on the [Community Discord](https://discord.gg/viam) and we will be happy to help.
 
@@ -13,6 +13,6 @@ If none of these steps work, reach out to us on the [Community Discord](https://
 When working with a [camera](/operate/reference/components/camera/) component, depending on the camera, you may need to explicitly provide some camera-specific configuration parameters.
 
 **Solution:** Check the specifications for your camera, and manually provide configuration parameters such as width and height to the camera component configuration panel.
-On the **CONFIGURE** page, find your camera, then fill in your camera's specific configuration either using the **Show more** button to show the relevant configuration options, or the **{}** (Switch to Advanced) button in the top right of the component panel to enter these attributes manually.
+On the **CONFIGURE** page, find your camera, then fill in your camera's specific configuration either using the **Show more** button to show the relevant configuration options, or the **JSON** button to enter these attributes manually.
 Provide at least the width and height values to start.
 {{% /expand%}}
diff --git a/static/include/data/capture-supported.md b/static/include/data/capture-supported.md
index 9a8734147c..f1258cec54 100644
--- a/static/include/data/capture-supported.md
+++ b/static/include/data/capture-supported.md
@@ -4,25 +4,25 @@
 <!-- prettier-ignore -->
 | Type                                            | Method |
 | ----------------------------------------------- | ------ |
-| [Arm](/operate/reference/components/arm/)                         | `EndPosition`, `JointPositions`, `DoCommand` |
-| [Base](/operate/reference/components/base/)                       | `Position`, `DoCommand` |
-| [Board](/operate/reference/components/board/)                     | `Analogs`, `Gpios`, `DoCommand` |
-| [Button](/operate/reference/components/button/)                   | `DoCommand` |
-| [Camera](/operate/reference/components/camera/)                   | `GetImages`, `ReadImage` (deprecated), `NextPointCloud`, `DoCommand` |
-| [Encoder](/operate/reference/components/encoder/)                 | `TicksCount`, `DoCommand` |
-| [Gantry](/operate/reference/components/gantry/)                   | `Lengths`, `Position`, `DoCommand` |
-| [Gripper](/operate/reference/components/gripper/)                 | `DoCommand` |
-| [Input Controller](/operate/reference/components/input-controller/) | `DoCommand` | 
-| [Motor](/operate/reference/components/motor/)                     | `Position`, `IsPowered`, `DoCommand` |
-| [Movement sensor](/operate/reference/components/movement-sensor/) | `AngularVelocity`, `CompassHeading`, `LinearAcceleration`, `LinearVelocity`, `Orientation`, `Position`, `DoCommand` |
-| [Sensor](/operate/reference/components/sensor/)                   | `Readings`, `DoCommand` |
-| [Power sensor](/operate/reference/components/power-sensor/)       | `Voltage`, `Current`, `Power`, `DoCommand` |
-| [Servo](/operate/reference/components/servo/)                     | `Position`, `DoCommand` |
-| [Switch](/operate/reference/components/switch/)                   | `DoCommand` |
-| [Generic](/operate/reference/components/generic/)                 | `DoCommand` |
+| [Arm](/hardware/common-components/add-an-arm/)                         | `EndPosition`, `JointPositions`, `DoCommand` |
+| [Base](/hardware/common-components/add-a-base/)                       | `Position`, `DoCommand` |
+| [Board](/hardware/common-components/add-a-board/)                     | `Analogs`, `Gpios`, `DoCommand` |
+| [Button](/hardware/common-components/add-a-button/)                   | `DoCommand` |
+| [Camera](/hardware/common-components/add-a-camera/)                   | `GetImages`, `ReadImage` (deprecated), `NextPointCloud`, `DoCommand` |
+| [Encoder](/hardware/common-components/add-an-encoder/)                 | `TicksCount`, `DoCommand` |
+| [Gantry](/hardware/common-components/add-a-gantry/)                   | `Lengths`, `Position`, `DoCommand` |
+| [Gripper](/hardware/common-components/add-a-gripper/)                 | `DoCommand` |
+| [Input Controller](/hardware/common-components/add-an-input-controller/) | `DoCommand` | 
+| [Motor](/hardware/common-components/add-a-motor/)                     | `Position`, `IsPowered`, `DoCommand` |
+| [Movement sensor](/hardware/common-components/add-a-movement-sensor/) | `AngularVelocity`, `CompassHeading`, `LinearAcceleration`, `LinearVelocity`, `Orientation`, `Position`, `DoCommand` |
+| [Sensor](/hardware/common-components/add-a-sensor/)                   | `Readings`, `DoCommand` |
+| [Power sensor](/hardware/common-components/add-a-power-sensor/)       | `Voltage`, `Current`, `Power`, `DoCommand` |
+| [Servo](/hardware/common-components/add-a-servo/)                     | `Position`, `DoCommand` |
+| [Switch](/hardware/common-components/add-a-switch/)                   | `DoCommand` |
+| [Generic](/hardware/common-components/add-a-generic/)                 | `DoCommand` |
 | [Base remote control service](/operate/reference/services/base-rc/) | `DoCommand` |
 | [Discovery service](/operate/reference/services/discovery/)       | `DoCommand` |
-| [Vision service](/operate/reference/services/vision/)             | `CaptureAllFromCamera`, `DoCommand` |
+| [Vision service](/vision/configure/)             | `CaptureAllFromCamera`, `DoCommand` |
 | [SLAM service](/operate/reference/services/slam/)                 | `Position`, `PointCloudMap`, `DoCommand` |
 | [Motion service](/operate/reference/services/motion/)             | `DoCommand` |
 | [Navigation service](/operate/reference/services/navigation/)     | `DoCommand` |
@@ -34,8 +34,8 @@
 <!-- prettier-ignore -->
 | Type | Method |
 | ---- | ------ |
-| [Movement Sensor](/operate/reference/components/movement-sensor/) | [`AngularVelocity`](/dev/reference/apis/components/movement-sensor/#getangularvelocity), [`LinearAcceleration`](/dev/reference/apis/components/movement-sensor/#getlinearacceleration), [`LinearVelocity`](/dev/reference/apis/components/movement-sensor/#getlinearvelocity) |
-| [Sensor](/operate/reference/components/sensor/) | [`GetReadings`](/dev/reference/apis/components/sensor/#getreadings) |
+| [Movement Sensor](/hardware/common-components/add-a-movement-sensor/) | [`AngularVelocity`](/reference/apis/components/movement-sensor/#getangularvelocity), [`LinearAcceleration`](/reference/apis/components/movement-sensor/#getlinearacceleration), [`LinearVelocity`](/reference/apis/components/movement-sensor/#getlinearvelocity) |
+| [Sensor](/hardware/common-components/add-a-sensor/) | [`GetReadings`](/reference/apis/components/sensor/#getreadings) |
 
 {{% /tab %}}
 {{< /tabs >}}
diff --git a/static/include/how-to/get-credentials.md b/static/include/how-to/get-credentials.md
new file mode 100644
index 0000000000..db717b0ec1
--- /dev/null
+++ b/static/include/how-to/get-credentials.md
@@ -0,0 +1,8 @@
+To get your credentials:
+
+1. Go to your machine's page in the Viam app.
+2. Click the **CONNECT** tab.
+3. Select **API keys**.
+4. Copy the **API key** and **API key ID**.
+
+Find your organization ID in the Viam app by clicking your organization name and selecting **Settings**.
diff --git a/static/include/how-to/install-cli.md b/static/include/how-to/install-cli.md
index 196ef63834..2171ecb717 100644
--- a/static/include/how-to/install-cli.md
+++ b/static/include/how-to/install-cli.md
@@ -61,4 +61,4 @@ echo 'export PATH="$HOME/go/bin:$PATH"' >> ~/.bashrc
 {{% /tab %}}
 {{< /tabs >}}
 
-For more information see [install the Viam CLI](/dev/tools/cli/#install).
+For more information see [install the Viam CLI](/cli/).
diff --git a/static/include/how-to/query-data.md b/static/include/how-to/query-data.md
index 8504e6fd6f..b2d06dbcf8 100644
--- a/static/include/how-to/query-data.md
+++ b/static/include/how-to/query-data.md
@@ -8,7 +8,7 @@ Authenticate using a personal access token:
 viam login
 ```
 
-For alternative authentication methods, see [Authenticate](/dev/tools/cli/#authenticate).
+For alternative authentication methods, see [Authenticate](/cli/).
 
 {{% /tablestep %}}
 {{% tablestep number=2 %}}
diff --git a/static/include/install/install-linux-aarch.md b/static/include/install/install-linux-aarch.md
index afd56aa2a6..237d8ee432 100644
--- a/static/include/install/install-linux-aarch.md
+++ b/static/include/install/install-linux-aarch.md
@@ -15,7 +15,7 @@ Install `viam-server` on the computer or single-board computer (SBC) that is dir
 
 1. Select your installation method:
 
-   - `viam-agent` (recommended): installs viam-agent, which will automatically install (and update) viam-server **and** provide additional functionality such as [provisioning](/manage/fleet/provision/setup/) and operating system update configuration.
+   - `viam-agent` (recommended): installs viam-agent, which will automatically install (and update) viam-server **and** provide additional functionality such as [provisioning](/fleet/provision-devices/) and operating system update configuration.
    - `manual`: installs only `viam-server` on your machine.
 
 1. Follow the instructions on the page to install `viam-server` and connect it to the cloud with your machine’s unique credentials.
diff --git a/static/include/install/install-linux.md b/static/include/install/install-linux.md
index 4ce3399f3b..b74956af6b 100644
--- a/static/include/install/install-linux.md
+++ b/static/include/install/install-linux.md
@@ -17,7 +17,7 @@ Install `viam-server` on the computer or single-board computer (SBC) that is dir
 
    If you selected **Linux / Aarch 64** or **Linux / x86** also select your installation method:
 
-   - `viam-agent` (recommended): installs viam-agent, which will automatically install (and update) viam-server **and** provide additional functionality such as [provisioning](/manage/fleet/provision/setup/) and operating system update configuration.
+   - `viam-agent` (recommended): installs viam-agent, which will automatically install (and update) viam-server **and** provide additional functionality such as [provisioning](/fleet/provision-devices/) and operating system update configuration.
    - `manual`: installs only `viam-server` on your machine.
 
 1. Follow the instructions on the page to install `viam-server` and connect it to the cloud with your machine’s unique credentials.
diff --git a/static/include/metajson.md b/static/include/metajson.md
index 6edf8c3509..4bc44b0393 100644
--- a/static/include/metajson.md
+++ b/static/include/metajson.md
@@ -24,7 +24,7 @@ Do not change the <code>module_id</code>.</p>
 <td><code>visibility</code></td>
 <td>string</td>
 <td><strong>Required</strong></td>
-<td>Whether the module is accessible only to members of your <a href="/manage/reference/organize/">organization</a> (<code>private</code>), or visible to all Viam users (<code>public</code>). You can later make a private module public using the <code>viam module update</code> command. Once you make a module public, you can only change it back to private if it is not configured on any machines outside of your organization.</td>
+<td>Whether the module is accessible only to members of your <a href="/reference/">organization</a> (<code>private</code>), or visible to all Viam users (<code>public</code>). You can later make a private module public using the <code>viam module update</code> command. Once you make a module public, you can only change it back to private if it is not configured on any machines outside of your organization.</td>
 </tr>
 <tr>
 <td><code>url</code></td>
@@ -56,7 +56,7 @@ Do not change the <code>module_id</code>.</p>
 <td><code>build</code></td>
 <td>object</td>
 <td>Optional</td>
-<td>An object containing the command to run to build your module, as well as optional fields for the path to your dependency setup script, the target architectures to build for, and the path to your built module. Use with the <a href="/dev/tools/cli/#using-the-build-subcommand">Viam CLI build subcommand</a>.<br><ul><li><code>"setup"</code> (Optional): Command to run for setting up the build environment.</li><li><code>"build"</code> (Required): Command to run to build the module tarball.</li><li><code>"path"</code> (Optional): Path to the built module tarball.</li>
+<td>An object containing the command to run to build your module, as well as optional fields for the path to your dependency setup script, the target architectures to build for, and the path to your built module. Use with the <a href="/cli/#using-the-build-subcommand">Viam CLI build subcommand</a>.<br><ul><li><code>"setup"</code> (Optional): Command to run for setting up the build environment.</li><li><code>"build"</code> (Required): Command to run to build the module tarball.</li><li><code>"path"</code> (Optional): Path to the built module tarball.</li>
 <li><code>"arch"</code> (Required): Array of architectures to build for. For more information see <a href="/operate/modules/advanced/manage-modules/#supported-platforms-for-automatic-updates">Supported platforms for automatic updates</a>.</li><li><code>"darwin_deps"</code> (Required): Array of homebrew dependencies for Darwin builds. Explicitly pass <code>[]</code> for empty. Default: <code>["go", "pkg-config", "nlopt-static", "x264", "jpeg-turbo", "ffmpeg"]</code></li></ul></td>
 </tr>
 <tr>
diff --git a/static/include/program/authenticate.md b/static/include/program/authenticate.md
index 7cf87c7340..97cc237729 100644
--- a/static/include/program/authenticate.md
+++ b/static/include/program/authenticate.md
@@ -4,7 +4,7 @@ To authenticate yourself to your machine, you need
 
       <!-- we will be releasing the ability to create API keys across all types of resources and combinations soon (i.e an API key can have an authorization on a org, location, machine or any combination of all three). this is correct for now though but it will be changing shortly. -->
 
-   To authenticate, [use a machine part API key](/operate/control/api-keys/) or [an API key](/dev/tools/cli/#authenticate) with access to the machine.
+   To authenticate, [use a machine part API key](/operate/control/api-keys/) or [an API key](/cli/) with access to the machine.
    Copy and paste the API key ID and the API key into your environment variables or directly into the code:
 
    {{< tabs >}}
diff --git a/static/include/robot/apis/generated/robot-table.md b/static/include/robot/apis/generated/robot-table.md
index 51c82fd556..81209a4ffc 100644
--- a/static/include/robot/apis/generated/robot-table.md
+++ b/static/include/robot/apis/generated/robot-table.md
@@ -1,25 +1,25 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`GetOperations`](/dev/reference/apis/robot/#getoperations) | Get the list of operations currently running on the machine. |
-| [`GetMachineStatus`](/dev/reference/apis/robot/#getmachinestatus) | Get status information about the machine including the status of the machine and its resources and the revision of the machine config. |
-| [`GetSessions`](/dev/reference/apis/robot/#getsessions) | Get the list of sessions currently connected to the robot. |
-| [`ResourceNames`](/dev/reference/apis/robot/#resourcenames) | Get a list of all known resource names connected to this machine. |
-| [`ResourceRPCSubtypes`](/dev/reference/apis/robot/#resourcerpcsubtypes) | Get a list of all resource types. |
-| [`CancelOperation`](/dev/reference/apis/robot/#canceloperation) | Cancel the specified operation on the machine. |
-| [`BlockForOperation`](/dev/reference/apis/robot/#blockforoperation) | Blocks on the specified operation on the machine. |
-| [`FrameSystemConfig`](/dev/reference/apis/robot/#framesystemconfig) | Get the configuration of the frame system of a given machine. |
-| [`TransformPose`](/dev/reference/apis/robot/#transformpose) | Transform a given source Pose from the original reference frame to a new destination reference frame. |
-| [`TransformPCD`](/dev/reference/apis/robot/#transformpcd) | Transforms the pointcloud to the desired frame in the robot's frame system. |
-| [`GetModelsFromModules`](/dev/reference/apis/robot/#getmodelsfrommodules) | Get a list of all models provided by local and registry modules on the machine. |
-| [`StopAll`](/dev/reference/apis/robot/#stopall) | Cancel all current and outstanding operations for the machine and stop all actuators and movement. |
-| [`RestartModule`](/dev/reference/apis/robot/#restartmodule) | Reload a module as if its config changed. |
-| [`Log`](/dev/reference/apis/robot/#log) | Create a LogEntry object from the log to send to the RDK over gRPC. |
-| [`GetCloudMetadata`](/dev/reference/apis/robot/#getcloudmetadata) | Get app-related information about the robot. |
-| [`GetVersion`](/dev/reference/apis/robot/#getversion) | Return version information about the machine. |
-| [`Options.with_api_key`](/dev/reference/apis/robot/#optionswith_api_key) | Create a `RobotClient.Options` using an API key as credentials. |
-| [`AtAddress`](/dev/reference/apis/robot/#ataddress) | Create a RobotClient that is connected to the machine at the provided address. |
-| [`WithChannel`](/dev/reference/apis/robot/#withchannel) | Create a RobotClient that is connected to a machine over the given channel. |
-| [`Refresh`](/dev/reference/apis/robot/#refresh) | Manually refresh the underlying parts of this machine. |
-| [`Shutdown`](/dev/reference/apis/robot/#shutdown) | Shutdown shuts down the machine. |
-| [`Close`](/dev/reference/apis/robot/#close) | Close the underlying connections and stop any periodic tasks across all constituent parts of the machine. |
+| [`GetOperations`](/reference/apis/robot/#getoperations) | Get the list of operations currently running on the machine. |
+| [`GetMachineStatus`](/reference/apis/robot/#getmachinestatus) | Get status information about the machine including the status of the machine and its resources and the revision of the machine config. |
+| [`GetSessions`](/reference/apis/robot/#getsessions) | Get the list of sessions currently connected to the robot. |
+| [`ResourceNames`](/reference/apis/robot/#resourcenames) | Get a list of all known resource names connected to this machine. |
+| [`ResourceRPCSubtypes`](/reference/apis/robot/#resourcerpcsubtypes) | Get a list of all resource types. |
+| [`CancelOperation`](/reference/apis/robot/#canceloperation) | Cancel the specified operation on the machine. |
+| [`BlockForOperation`](/reference/apis/robot/#blockforoperation) | Blocks on the specified operation on the machine. |
+| [`FrameSystemConfig`](/reference/apis/robot/#framesystemconfig) | Get the configuration of the frame system of a given machine. |
+| [`TransformPose`](/reference/apis/robot/#transformpose) | Transform a given source Pose from the original reference frame to a new destination reference frame. |
+| [`TransformPCD`](/reference/apis/robot/#transformpcd) | Transforms the pointcloud to the desired frame in the robot's frame system. |
+| [`GetModelsFromModules`](/reference/apis/robot/#getmodelsfrommodules) | Get a list of all models provided by local and registry modules on the machine. |
+| [`StopAll`](/reference/apis/robot/#stopall) | Cancel all current and outstanding operations for the machine and stop all actuators and movement. |
+| [`RestartModule`](/reference/apis/robot/#restartmodule) | Reload a module as if its config changed. |
+| [`Log`](/reference/apis/robot/#log) | Create a LogEntry object from the log to send to the RDK over gRPC. |
+| [`GetCloudMetadata`](/reference/apis/robot/#getcloudmetadata) | Get app-related information about the robot. |
+| [`GetVersion`](/reference/apis/robot/#getversion) | Return version information about the machine. |
+| [`Options.with_api_key`](/reference/apis/robot/#optionswith_api_key) | Create a `RobotClient.Options` using an API key as credentials. |
+| [`AtAddress`](/reference/apis/robot/#ataddress) | Create a RobotClient that is connected to the machine at the provided address. |
+| [`WithChannel`](/reference/apis/robot/#withchannel) | Create a RobotClient that is connected to a machine over the given channel. |
+| [`Refresh`](/reference/apis/robot/#refresh) | Manually refresh the underlying parts of this machine. |
+| [`Shutdown`](/reference/apis/robot/#shutdown) | Shutdown shuts down the machine. |
+| [`Close`](/reference/apis/robot/#close) | Close the underlying connections and stop any periodic tasks across all constituent parts of the machine. |
diff --git a/static/include/robot/apis/generated/robot.md b/static/include/robot/apis/generated/robot.md
index 02397bfccb..b70f3bc22f 100644
--- a/static/include/robot/apis/generated/robot.md
+++ b/static/include/robot/apis/generated/robot.md
@@ -11,7 +11,7 @@ Get the list of operations currently running on the machine.
 
 **Returns:**
 
-- ([List[viam.proto.robot.Operation]](https://python.viam.dev/autoapi/viam/proto/robot/index.html#viam.proto.robot.Operation)): The list of operations currently running on a given machine.
+- ([List[viam.proto.robot.Operation]](https://python.viam.dev/autoapi/viam/proto/robot/index.html#viam.proto.robot.Operation)): :   The list of operations currently running on a given machine.
 
 **Example:**
 
@@ -56,7 +56,7 @@ Get status information about the machine including the status of the machine and
 
 **Returns:**
 
-- ([viam.proto.robot.GetMachineStatusResponse](https://python.viam.dev/autoapi/viam/proto/robot/index.html#viam.proto.robot.GetMachineStatusResponse)): current status of the machine (initializing or running), current status of the resources (List\[ResourceStatus]) and the revision of the config of the machine.
+- ([viam.proto.robot.GetMachineStatusResponse](https://python.viam.dev/autoapi/viam/proto/robot/index.html#viam.proto.robot.GetMachineStatusResponse)): :   current status of the machine (initializing or running), current status of the resources (List[ResourceStatus]) and the revision of the config of the machine.
 
 **Example:**
 
@@ -112,7 +112,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[GetMachineStatusResponse](https://flutter.viam.dev/viam_protos.robot.robot/GetMachineStatusResponse-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[GetMachineStatusResponse](https://flutter.viam.dev/viam_protos.robot.robot/GetMachineStatusResponse-class.html)>
 
 **Example:**
 
@@ -345,7 +345,7 @@ Get the configuration of the frame system of a given machine.
 
 **Returns:**
 
-- ([List[viam.proto.robot.FrameSystemConfig]](https://python.viam.dev/autoapi/viam/proto/robot/index.html#viam.proto.robot.FrameSystemConfig)): The configuration of a given machine’s frame system.
+- ([List[viam.proto.robot.FrameSystemConfig]](https://python.viam.dev/autoapi/viam/proto/robot/index.html#viam.proto.robot.FrameSystemConfig)): :   The configuration of a given machine’s frame system.
 
 **Example:**
 
@@ -357,28 +357,6 @@ print(f"frame system configuration: {frame_system}")
 
 For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/robot/client/index.html#viam.robot.client.RobotClient.get_frame_system_config).
 
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-**Parameters:**
-
-- `ctx` [(Context)](https://pkg.go.dev/context#Context): A Context carries a deadline, a cancellation signal, and other values across API boundaries.
-
-**Returns:**
-
-- [(*framesystem.Config)](https://pkg.go.dev/go.viam.com/rdk/robot/framesystem#Config): The configuration of the given machine’s frame system.
-- [(error)](https://pkg.go.dev/builtin#error): An error, if one occurred.
-
-**Example:**
-
-```go {class="line-numbers linkable-line-numbers"}
-// Print the frame system configuration
-frameSystem, err := machine.FrameSystemConfig(context.Background())
-fmt.Println(frameSystem)
-```
-
-For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/robot#Robot).
-
 {{% /tab %}}
 {{% tab name="TypeScript" %}}
 
@@ -416,7 +394,7 @@ Transform a given source Pose from the original reference frame to a new destina
 
 **Returns:**
 
-- ([viam.proto.common.PoseInFrame](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.PoseInFrame)): The pose and the reference frame for the new destination.
+- ([viam.proto.common.PoseInFrame](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.PoseInFrame)): :   The pose and the reference frame for the new destination.
 
 **Example:**
 
@@ -443,35 +421,6 @@ transformed_pose = await machine.transform_pose(pose_in_frame, "world")
 
 For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/viam/robot/client/index.html#viam.robot.client.RobotClient.transform_pose).
 
-{{% /tab %}}
-{{% tab name="Go" %}}
-
-**Parameters:**
-
-- `ctx` [(Context)](https://pkg.go.dev/context#Context): A Context carries a deadline, a cancellation signal, and other values across API boundaries.
-- `pose` [(*referenceframe.PoseInFrame)](https://pkg.go.dev/go.viam.com/rdk/referenceframe#PoseInFrame): The pose that should be transformed.
-- `dst` [(string)](https://pkg.go.dev/builtin#string): The name of the reference pose to transform the given pose to.
-- `additionalTransforms` [([]*referenceframe.LinkInFrame)](https://pkg.go.dev/go.viam.com/rdk/referenceframe#LinkInFrame): Any additional transforms.
-
-**Returns:**
-
-- [(*referenceframe.PoseInFrame)](https://pkg.go.dev/go.viam.com/rdk/referenceframe#PoseInFrame): Transformed pose in frame.
-- [(error)](https://pkg.go.dev/builtin#error): An error, if one occurred.
-
-**Example:**
-
-```go {class="line-numbers linkable-line-numbers"}
-import (
-  "go.viam.com/rdk/referenceframe"
-  "go.viam.com/rdk/spatialmath"
-)
-
-baseOrigin := referenceframe.NewPoseInFrame("test-base", spatialmath.NewZeroPose())
-movementSensorToBase, err := machine.TransformPose(context.Background(), baseOrigin, "my-movement-sensor", nil)
-```
-
-For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/robot#Robot).
-
 {{% /tab %}}
 {{% tab name="TypeScript" %}}
 
@@ -497,23 +446,6 @@ Transforms the pointcloud to the desired frame in the robot's frame system.
 Do not move the robot between the generation of the initial pointcloud and the receipt of the transformed pointcloud, as doing so will make the transformations inaccurate.
 
 {{< tabs >}}
-{{% tab name="Go" %}}
-
-**Parameters:**
-
-- `ctx` [(Context)](https://pkg.go.dev/context#Context): A Context carries a deadline, a cancellation signal, and other values across API boundaries.
-- `srcpc` [(pointcloud.PointCloud)](https://pkg.go.dev/go.viam.com/rdk/pointcloud#PointCloud): The source `PointCloud` to transform.
-- `srcName` [(string)](https://pkg.go.dev/builtin#string): The name of the source point cloud to transform.
-- `dstName` [(string)](https://pkg.go.dev/builtin#string): The name of the destination point cloud.
-
-**Returns:**
-
-- [(pointcloud.PointCloud)](https://pkg.go.dev/go.viam.com/rdk/pointcloud#PointCloud): The transformed `PointCloud`.
-- [(error)](https://pkg.go.dev/builtin#error): An error, if one occurred.
-
-For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/robot#Robot).
-
-{{% /tab %}}
 {{% tab name="TypeScript" %}}
 
 **Parameters:**
@@ -550,7 +482,7 @@ This includes models that are not currently configured on the machine.
 
 **Returns:**
 
-- ([List[viam.proto.robot.ModuleModel]](https://python.viam.dev/autoapi/viam/proto/robot/index.html#viam.proto.robot.ModuleModel)): A list of discovered models.
+- ([List[viam.proto.robot.ModuleModel]](https://python.viam.dev/autoapi/viam/proto/robot/index.html#viam.proto.robot.ModuleModel)): :   A list of discovered models.
 
 **Example:**
 
@@ -610,7 +542,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[ModuleModel](https://flutter.viam.dev/viam_protos.robot.robot/ModuleModel-class.html)\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[ModuleModel](https://flutter.viam.dev/viam_protos.robot.robot/ModuleModel-class.html)>\>
 
 **Example:**
 
@@ -794,7 +726,7 @@ Get app-related information about the robot.
 
 **Returns:**
 
-- ([viam.proto.robot.GetCloudMetadataResponse](https://python.viam.dev/autoapi/viam/proto/robot/index.html#viam.proto.robot.GetCloudMetadataResponse)): App\-related metadata.
+- ([viam.proto.robot.GetCloudMetadataResponse](https://python.viam.dev/autoapi/viam/proto/robot/index.html#viam.proto.robot.GetCloudMetadataResponse)): :   App-related metadata.
 
 **Example:**
 
@@ -860,7 +792,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[CloudMetadata](https://flutter.viam.dev/viam_sdk/CloudMetadata.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[CloudMetadata](https://flutter.viam.dev/viam_sdk/CloudMetadata.html)>
 
 **Example:**
 
@@ -886,7 +818,7 @@ Return version information about the machine.
 
 **Returns:**
 
-- ([viam.proto.robot.GetVersionResponse](https://python.viam.dev/autoapi/viam/proto/robot/index.html#viam.proto.robot.GetVersionResponse)): Machine version related information.
+- ([viam.proto.robot.GetVersionResponse](https://python.viam.dev/autoapi/viam/proto/robot/index.html#viam.proto.robot.GetVersionResponse)): :   Machine version related information.
 
 **Example:**
 
@@ -944,7 +876,7 @@ Pass these options to [`AtAddress`](#ataddress).
 
 **Returns:**
 
-- (typing_extensions.Self): the RobotClient.Options.
+- (Self): :   the RobotClient.Options.
 
 **Raises:**
 
@@ -982,7 +914,7 @@ Create a RobotClient that is connected to the machine at the provided address.
 
 **Returns:**
 
-- (typing_extensions.Self)
+- (Self)
 
 **Example:**
 
@@ -1015,7 +947,7 @@ For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[RobotClient](https://flutter.viam.dev/viam_sdk/RobotClient-class.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[RobotClient](https://flutter.viam.dev/viam_sdk/RobotClient-class.html)>
 
 **Example:**
 
@@ -1056,7 +988,7 @@ Any machines created using this method will NOT automatically close the channel
 
 **Returns:**
 
-- (typing_extensions.Self)
+- (Self)
 
 **Example:**
 
@@ -1109,7 +1041,7 @@ For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
@@ -1224,7 +1156,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<void\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<void>
 
 **Example:**
 
diff --git a/static/include/services/apis/billing-client.md b/static/include/services/apis/billing-client.md
index fbc74f103c..d5537de9d0 100644
--- a/static/include/services/apis/billing-client.md
+++ b/static/include/services/apis/billing-client.md
@@ -1,7 +1,7 @@
 <!-- prettier-ignore -->
 Method Name | Description
 ----------- | -----------
-[`GetCurrentMonthUsage`](/dev/reference/apis/billing-client/#getcurrentmonthusage) | Access data usage information for the current month for a given organization.
-[`GetInvoicePdf`](/dev/reference/apis/billing-client/#getinvoicepdf) | Access invoice PDF data and optionally save it to a provided file path.
-[`GetInvoicesSummary`](/dev/reference/apis/billing-client/#getinvoicessummary) | Access total outstanding balance plus invoice summaries for a given org.
-[`GetOrgBillingInformation`](/dev/reference/apis/billing-client/#getorgbillinginformation) | Access billing information (payment method, billing tier, etc.) for a given org.
+[`GetCurrentMonthUsage`](/reference/apis/billing-client/#getcurrentmonthusage) | Access data usage information for the current month for a given organization.
+[`GetInvoicePdf`](/reference/apis/billing-client/#getinvoicepdf) | Access invoice PDF data and optionally save it to a provided file path.
+[`GetInvoicesSummary`](/reference/apis/billing-client/#getinvoicessummary) | Access total outstanding balance plus invoice summaries for a given org.
+[`GetOrgBillingInformation`](/reference/apis/billing-client/#getorgbillinginformation) | Access billing information (payment method, billing tier, etc.) for a given org.
diff --git a/static/include/services/apis/fleet.md b/static/include/services/apis/fleet.md
index c86bbf6dd0..27e46ee887 100644
--- a/static/include/services/apis/fleet.md
+++ b/static/include/services/apis/fleet.md
@@ -1,54 +1,54 @@
 <!-- prettier-ignore -->
 Method Name | Description
 ----------- | -----------
-[`ListOrganizations`](/dev/reference/apis/fleet/#listorganizations) | List the {{< glossary_tooltip term_id="organization" text="organizations" >}} the user owns.
-[`GetOrganizationNamespaceAvailability`](/dev/reference/apis/fleet/#getorganizationnamespaceavailability) | Check the availability of an organization namespace.
-[`ListOrganizationMembers`](/dev/reference/apis/fleet/#listorganizationmembers) | List the members and invites of the current organization.
-[`UpdateOrganizationInviteAuthorizations`](/dev/reference/apis/fleet/#updateorganizationinviteauthorizations) | Update the authorizations attached to an organization invite that has already been created.
-[`CreateLocation`](/dev/reference/apis/fleet/#createlocation) | Create and name a {{< glossary_tooltip term_id="location" text="location" >}}.
-[`GetLocation`](/dev/reference/apis/fleet/#getlocation) | Get a location by its ID.
-[`UpdateLocation`](/dev/reference/apis/fleet/#updatelocation ) | Change the name of a location and/or assign a parent location to a location.
-[`DeleteLocation`](/dev/reference/apis/fleet/#deletelocation ) | Delete a location.
-[`ListLocations`](/dev/reference/apis/fleet/#listlocations ) | List locations.
-[`LocationAuth`](/dev/reference/apis/fleet/#locationauth ) | Get a location's authorization (location secrets).
-[`CreateLocationSecret`](/dev/reference/apis/fleet/#createlocationsecret ) | Create a new location secret. *Deprecated*.
-[`DeleteLocationSecret`](/dev/reference/apis/fleet/#deletelocationsecret ) | Delete a location secret. *Deprecated*.
-[`GetRobot`](/dev/reference/apis/fleet/#getrobot ) | Get a {{< glossary_tooltip term_id="machine" text="machine" >}} by machine ID.
-[`GetRobotParts`](/dev/reference/apis/fleet/#getrobotparts ) | Get a list of all the {{< glossary_tooltip term_id="part" text="parts" >}} under a specific machine.
-[`GetRobotPart`](/dev/reference/apis/fleet/#getrobotpart ) | Get a machine {{< glossary_tooltip term_id="part" text="part" >}}.
-[`GetRobotPartLogs`](/dev/reference/apis/fleet/#getrobotpartlogs ) | Get the logs associated with a machine part.
-[`TailRobotPartLogs`](/dev/reference/apis/fleet/#tailrobotpartlogs ) | Get an asynchronous iterator that receives live machine part logs.
-[`GetRobotPartHistory`](/dev/reference/apis/fleet/#getrobotparthistory ) | Get a list containing the history of a machine part.
-[`UpdateRobotPart`](/dev/reference/apis/fleet/#updaterobotpart ) | Update the name or configuration of a machine part.
-[`NewRobotPart`](/dev/reference/apis/fleet/#newrobotpart ) | Create a new machine part.
-[`DeleteRobotPart`](/dev/reference/apis/fleet/#deleterobotpart ) | Delete a machine part.
-[`MarkPartAsMain`](/dev/reference/apis/fleet/#markpartasmain ) | Mark a part as the [_main_ part](/operate/reference/architecture/parts/#machine-parts) of a machine.
-[`MarkPartForRestart`](/dev/reference/apis/fleet/#markpartforrestart ) | Mark a machine part for restart.
-[`CreateRobotPartSecret`](/dev/reference/apis/fleet/#createrobotpartsecret ) | Create a machine part secret. *Deprecated*.
-[`DeleteRobotPartSecret`](/dev/reference/apis/fleet/#deleterobotpartsecret ) | Delete a machine part secret. *Deprecated*.
-[`ListRobots`](/dev/reference/apis/fleet/#listrobots ) | Get a list of all machines in a location.
-[`NewRobot`](/dev/reference/apis/fleet/#newrobot ) | Create a new machine.
-[`UpdateRobot`](/dev/reference/apis/fleet/#updaterobot ) | Change the name of an existing machine.
-[`DeleteRobot`](/dev/reference/apis/fleet/#deleterobot ) | Delete a machine.
-[`ListFragments`](/dev/reference/apis/fleet/#listfragments ) | Get a list of {{< glossary_tooltip term_id="fragment" text="fragments" >}}.
-[`GetFragment`](/dev/reference/apis/fleet/#getfragment ) | Get a fragment by its ID.
-[`CreateFragment`](/dev/reference/apis/fleet/#createfragment ) | Create a new private fragment.
-[`UpdateFragment`](/dev/reference/apis/fleet/#updatefragment ) | Update a fragment name, config or visibility.
-[`DeleteFragment`](/dev/reference/apis/fleet/#deletefragment ) | Delete a fragment.
-[`AddRole`](/dev/reference/apis/fleet/#addrole ) | Add a role (owner or operator).
-[`RemoveRole`](/dev/reference/apis/fleet/#removerole ) | Remove a role (owner or operator).
-[`ListAuthorizations`](/dev/reference/apis/fleet/#listauthorizations ) | List authorizations (owners and operators).
-[`CreateModule`](/dev/reference/apis/fleet/#createmodule ) | Create a {{< glossary_tooltip term_id="module" text="module" >}}.
-[`UpdateModule`](/dev/reference/apis/fleet/#updatemodule ) | Update module metadata.
-[`UploadModuleFile`](/dev/reference/apis/fleet/#uploadmodulefile ) | Upload a module file.
-[`GetModule`](/dev/reference/apis/fleet/#getmodule ) | Get a module by its ID.
-[`ListModules`](/dev/reference/apis/fleet/#listmodules ) | List available modules.
-[`CreateOrganizationInvite`](/dev/reference/apis/fleet/#createorganizationinvite) | Create an organization invite and send it by email.
-[`DeleteOrganizationMember`](/dev/reference/apis/fleet/#deleteorganizationmember) | Remove a member from the organization.
-[`DeleteOrganizationInvite`](/dev/reference/apis/fleet/#deleteorganizationinvite) | Delete a pending organization invite.
-[`ResendOrganizationInvite`](/dev/reference/apis/fleet/#resendorganizationinvite) | Resend a pending organization invite email.
-[`GetRoverRentalRobots`](/dev/reference/apis/fleet/#getroverrentalrobots) | Return a list of rover rental robots within an org.
-[`CheckPermissions`](/dev/reference/apis/fleet/#checkpermissions) | Check if the entity you're currently authenticated to is permitted to perform some action or set of actions on the resource you pass to the method.
-[`CreateKey`](/dev/reference/apis/fleet/#createkey) | Create a new API key.
-[`CreateKeyFromExistingKeyAuthorizations`](/dev/reference/apis/fleet/#createkeyfromexistingkeyauthorizations) | Create a new API key with an existing key’s authorizations.
-[`ListKeys`](/dev/reference/apis/fleet/#listkeys) | List all keys for an organization.
+[`ListOrganizations`](/reference/apis/fleet/#listorganizations) | List the {{< glossary_tooltip term_id="organization" text="organizations" >}} the user owns.
+[`GetOrganizationNamespaceAvailability`](/reference/apis/fleet/#getorganizationnamespaceavailability) | Check the availability of an organization namespace.
+[`ListOrganizationMembers`](/reference/apis/fleet/#listorganizationmembers) | List the members and invites of the current organization.
+[`UpdateOrganizationInviteAuthorizations`](/reference/apis/fleet/#updateorganizationinviteauthorizations) | Update the authorizations attached to an organization invite that has already been created.
+[`CreateLocation`](/reference/apis/fleet/#createlocation) | Create and name a {{< glossary_tooltip term_id="location" text="location" >}}.
+[`GetLocation`](/reference/apis/fleet/#getlocation) | Get a location by its ID.
+[`UpdateLocation`](/reference/apis/fleet/#updatelocation ) | Change the name of a location and/or assign a parent location to a location.
+[`DeleteLocation`](/reference/apis/fleet/#deletelocation ) | Delete a location.
+[`ListLocations`](/reference/apis/fleet/#listlocations ) | List locations.
+[`LocationAuth`](/reference/apis/fleet/#locationauth ) | Get a location's authorization (location secrets).
+[`CreateLocationSecret`](/reference/apis/fleet/#createlocationsecret ) | Create a new location secret. *Deprecated*.
+[`DeleteLocationSecret`](/reference/apis/fleet/#deletelocationsecret ) | Delete a location secret. *Deprecated*.
+[`GetRobot`](/reference/apis/fleet/#getrobot ) | Get a {{< glossary_tooltip term_id="machine" text="machine" >}} by machine ID.
+[`GetRobotParts`](/reference/apis/fleet/#getrobotparts ) | Get a list of all the {{< glossary_tooltip term_id="part" text="parts" >}} under a specific machine.
+[`GetRobotPart`](/reference/apis/fleet/#getrobotpart ) | Get a machine {{< glossary_tooltip term_id="part" text="part" >}}.
+[`GetRobotPartLogs`](/reference/apis/fleet/#getrobotpartlogs ) | Get the logs associated with a machine part.
+[`TailRobotPartLogs`](/reference/apis/fleet/#tailrobotpartlogs ) | Get an asynchronous iterator that receives live machine part logs.
+[`GetRobotPartHistory`](/reference/apis/fleet/#getrobotparthistory ) | Get a list containing the history of a machine part.
+[`UpdateRobotPart`](/reference/apis/fleet/#updaterobotpart ) | Update the name or configuration of a machine part.
+[`NewRobotPart`](/reference/apis/fleet/#newrobotpart ) | Create a new machine part.
+[`DeleteRobotPart`](/reference/apis/fleet/#deleterobotpart ) | Delete a machine part.
+[`MarkPartAsMain`](/reference/apis/fleet/#markpartasmain ) | Mark a part as the [_main_ part](/operate/reference/architecture/parts/#machine-parts) of a machine.
+[`MarkPartForRestart`](/reference/apis/fleet/#markpartforrestart ) | Mark a machine part for restart.
+[`CreateRobotPartSecret`](/reference/apis/fleet/#createrobotpartsecret ) | Create a machine part secret. *Deprecated*.
+[`DeleteRobotPartSecret`](/reference/apis/fleet/#deleterobotpartsecret ) | Delete a machine part secret. *Deprecated*.
+[`ListRobots`](/reference/apis/fleet/#listrobots ) | Get a list of all machines in a location.
+[`NewRobot`](/reference/apis/fleet/#newrobot ) | Create a new machine.
+[`UpdateRobot`](/reference/apis/fleet/#updaterobot ) | Change the name of an existing machine.
+[`DeleteRobot`](/reference/apis/fleet/#deleterobot ) | Delete a machine.
+[`ListFragments`](/reference/apis/fleet/#listfragments ) | Get a list of {{< glossary_tooltip term_id="fragment" text="fragments" >}}.
+[`GetFragment`](/reference/apis/fleet/#getfragment ) | Get a fragment by its ID.
+[`CreateFragment`](/reference/apis/fleet/#createfragment ) | Create a new private fragment.
+[`UpdateFragment`](/reference/apis/fleet/#updatefragment ) | Update a fragment name, config or visibility.
+[`DeleteFragment`](/reference/apis/fleet/#deletefragment ) | Delete a fragment.
+[`AddRole`](/reference/apis/fleet/#addrole ) | Add a role (owner or operator).
+[`RemoveRole`](/reference/apis/fleet/#removerole ) | Remove a role (owner or operator).
+[`ListAuthorizations`](/reference/apis/fleet/#listauthorizations ) | List authorizations (owners and operators).
+[`CreateModule`](/reference/apis/fleet/#createmodule ) | Create a {{< glossary_tooltip term_id="module" text="module" >}}.
+[`UpdateModule`](/reference/apis/fleet/#updatemodule ) | Update module metadata.
+[`UploadModuleFile`](/reference/apis/fleet/#uploadmodulefile ) | Upload a module file.
+[`GetModule`](/reference/apis/fleet/#getmodule ) | Get a module by its ID.
+[`ListModules`](/reference/apis/fleet/#listmodules ) | List available modules.
+[`CreateOrganizationInvite`](/reference/apis/fleet/#createorganizationinvite) | Create an organization invite and send it by email.
+[`DeleteOrganizationMember`](/reference/apis/fleet/#deleteorganizationmember) | Remove a member from the organization.
+[`DeleteOrganizationInvite`](/reference/apis/fleet/#deleteorganizationinvite) | Delete a pending organization invite.
+[`ResendOrganizationInvite`](/reference/apis/fleet/#resendorganizationinvite) | Resend a pending organization invite email.
+[`GetRoverRentalRobots`](/reference/apis/fleet/#getroverrentalrobots) | Return a list of rover rental robots within an org.
+[`CheckPermissions`](/reference/apis/fleet/#checkpermissions) | Check if the entity you're currently authenticated to is permitted to perform some action or set of actions on the resource you pass to the method.
+[`CreateKey`](/reference/apis/fleet/#createkey) | Create a new API key.
+[`CreateKeyFromExistingKeyAuthorizations`](/reference/apis/fleet/#createkeyfromexistingkeyauthorizations) | Create a new API key with an existing key’s authorizations.
+[`ListKeys`](/reference/apis/fleet/#listkeys) | List all keys for an organization.
diff --git a/static/include/services/apis/generated/base_remote_control-table.md b/static/include/services/apis/generated/base_remote_control-table.md
index 24ef4749f3..1c14ff269a 100644
--- a/static/include/services/apis/generated/base_remote_control-table.md
+++ b/static/include/services/apis/generated/base_remote_control-table.md
@@ -1,8 +1,8 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`ControllerInputs`](/dev/reference/apis/services/base-rc/#controllerinputs) | Get a list of inputs from the controller that are being monitored for that control mode. |
-| [`Reconfigure`](/dev/reference/apis/services/base-rc/#reconfigure) | Reconfigure this resource. |
-| [`DoCommand`](/dev/reference/apis/services/base-rc/#docommand) | Execute model-specific commands that are not otherwise defined by the service API. |
-| [`GetResourceName`](/dev/reference/apis/services/base-rc/#getresourcename) | Get the `ResourceName` for this instance of the generic service with the given name. |
-| [`Close`](/dev/reference/apis/services/base-rc/#close) | Close out of all remote control related systems. |
+| [`ControllerInputs`](/reference/apis/services/base-rc/#controllerinputs) | Get a list of inputs from the controller that are being monitored for that control mode. |
+| [`Reconfigure`](/reference/apis/services/base-rc/#reconfigure) | Reconfigure this resource. |
+| [`DoCommand`](/reference/apis/services/base-rc/#docommand) | Execute model-specific commands that are not otherwise defined by the service API. |
+| [`GetResourceName`](/reference/apis/services/base-rc/#getresourcename) | Get the `ResourceName` for this instance of the generic service with the given name. |
+| [`Close`](/reference/apis/services/base-rc/#close) | Close out of all remote control related systems. |
diff --git a/static/include/services/apis/generated/base_remote_control.md b/static/include/services/apis/generated/base_remote_control.md
index a68020cac0..94471c85b0 100644
--- a/static/include/services/apis/generated/base_remote_control.md
+++ b/static/include/services/apis/generated/base_remote_control.md
@@ -53,7 +53,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the service API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own base remote control service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own base remote control service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Go" %}}
diff --git a/static/include/services/apis/generated/data_manager-table.md b/static/include/services/apis/generated/data_manager-table.md
index 4645ee858c..293850af59 100644
--- a/static/include/services/apis/generated/data_manager-table.md
+++ b/static/include/services/apis/generated/data_manager-table.md
@@ -1,10 +1,9 @@
 <!-- prettier-ignore -->
 | Method Name | Description | `viam-micro-server` Support |
 | ----------- | ----------- | --------------------------- |
-| [`Sync`](/dev/reference/apis/services/data/#sync) | Sync data stored on the machine to the cloud. |  |
-| [`UploadImageToDatasets`](/dev/reference/apis/services/data/#uploadimagetodatasets) | Upload an image data to the specified datasets. |  |
-| [`UploadBinaryDataToDatasets`](/dev/reference/apis/services/data/#uploadbinarydatatodatasets) | Upload Binary data to the specified datasets. |  |
-| [`Reconfigure`](/dev/reference/apis/services/data/#reconfigure) | Reconfigure this resource. |  |
-| [`DoCommand`](/dev/reference/apis/services/data/#docommand) | Execute model-specific commands that are not otherwise defined by the service API. |  |
-| [`GetResourceName`](/dev/reference/apis/services/data/#getresourcename) | Get the `ResourceName` for this instance of the service. |  |
-| [`Close`](/dev/reference/apis/services/data/#close) | Safely shut down the resource and prevent further use. |  |
+| [`Sync`](/reference/apis/services/data/#sync) | Sync data stored on the machine to the cloud. |  |
+| [`UploadBinaryDataToDatasets`](/reference/apis/services/data/#uploadbinarydatatodatasets) | Upload Binary data to the specified datasets. |  |
+| [`Reconfigure`](/reference/apis/services/data/#reconfigure) | Reconfigure this resource. |  |
+| [`DoCommand`](/reference/apis/services/data/#docommand) | Execute model-specific commands that are not otherwise defined by the service API. |  |
+| [`GetResourceName`](/reference/apis/services/data/#getresourcename) | Get the `ResourceName` for this instance of the service. |  |
+| [`Close`](/reference/apis/services/data/#close) | Safely shut down the resource and prevent further use. |  |
diff --git a/static/include/services/apis/generated/data_manager.md b/static/include/services/apis/generated/data_manager.md
index 947c838a0f..ff8a005137 100644
--- a/static/include/services/apis/generated/data_manager.md
+++ b/static/include/services/apis/generated/data_manager.md
@@ -57,31 +57,6 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 {{% /tab %}}
 {{< /tabs >}}
 
-### UploadImageToDatasets
-
-Upload an image data to the specified datasets.
-
-{{< tabs >}}
-{{% tab name="Go" %}}
-
-**Parameters:**
-
-- `ctx` [(Context)](https://pkg.go.dev/context#Context): A Context carries a deadline, a cancellation signal, and other values across API boundaries.
-- `image` [(image.Image)](https://pkg.go.dev/image#Image)
-- `datasetIDs`
-- `tags` [([]string)](https://pkg.go.dev/builtin#string)
-- `mimeType` [(datasyncpb.MimeType)](https://pkg.go.dev/go.viam.com/api/app/datasync/v1#MimeType)
-- `extra` [(map[string]interface{})](https://go.dev/blog/maps): Extra options to pass to the underlying RPC call.
-
-**Returns:**
-
-- [(error)](https://pkg.go.dev/builtin#error): An error, if one occurred.
-
-For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/services/datamanager#Service).
-
-{{% /tab %}}
-{{< /tabs >}}
-
 ### UploadBinaryDataToDatasets
 
 Upload Binary data to the specified datasets.
@@ -168,7 +143,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the service API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own data manager service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own data manager service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Go" %}}
@@ -199,8 +174,9 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to do.
-- `callOptions` (CallOptions) (optional): Call options for the command.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
+- `callOptions` (CallOptions) (optional)
 
 **Returns:**
 
@@ -209,11 +185,17 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
-const dataManager = new VIAM.DataManagerClient(
-  machine,
-  'my_data_manager'
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
+import { Struct } from '@viamrobotics/sdk';
+
+const result = await resource.doCommand(
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
-await dataManager.doCommand(new Struct({ cmd: 'test', data1: 500 }));
 ```
 
 For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/DataManagerClient.html#docommand).
diff --git a/static/include/services/apis/generated/discovery-table.md b/static/include/services/apis/generated/discovery-table.md
index 17513c5aae..cbbd494341 100644
--- a/static/include/services/apis/generated/discovery-table.md
+++ b/static/include/services/apis/generated/discovery-table.md
@@ -1,7 +1,7 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`DiscoverResources`](/dev/reference/apis/services/discovery/#discoverresources) | Get a list of component configs of all resources available to configure on a machine based on the hardware that is connected to or part of the machine. |
-| [`GetResourceName`](/dev/reference/apis/services/discovery/#getresourcename) | Get the `ResourceName` for this instance of the service. |
-| [`DoCommand`](/dev/reference/apis/services/discovery/#docommand) | Execute model-specific commands. |
-| [`Close`](/dev/reference/apis/services/discovery/#close) | Safely shut down the resource and prevent further use. |
+| [`DiscoverResources`](/reference/apis/services/discovery/#discoverresources) | Get a list of component configs of all resources available to configure on a machine based on the hardware that is connected to or part of the machine. |
+| [`GetResourceName`](/reference/apis/services/discovery/#getresourcename) | Get the `ResourceName` for this instance of the service. |
+| [`DoCommand`](/reference/apis/services/discovery/#docommand) | Execute model-specific commands. |
+| [`Close`](/reference/apis/services/discovery/#close) | Safely shut down the resource and prevent further use. |
diff --git a/static/include/services/apis/generated/discovery.md b/static/include/services/apis/generated/discovery.md
index b159434a59..66b94b6193 100644
--- a/static/include/services/apis/generated/discovery.md
+++ b/static/include/services/apis/generated/discovery.md
@@ -12,8 +12,8 @@ Get a list of component configs of all resources available to configure on a mac
 
 **Returns:**
 
-- ([List[viam.proto.app.robot.ComponentConfig]](https://python.viam.dev/autoapi/viam/proto/app/robot/index.html#viam.proto.app.robot.ComponentConfig)): A list of ComponentConfigs that describe
-the components found by a discover service.
+- ([List[viam.proto.app.robot.ComponentConfig]](https://python.viam.dev/autoapi/viam/proto/app/robot/index.html#viam.proto.app.robot.ComponentConfig)): :   A list of ComponentConfigs that describe
+    the components found by a discover service.
 
 **Example:**
 
@@ -78,11 +78,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[ComponentConfig](https://flutter.viam.dev/viam_protos.app.robot/ComponentConfig-class.html)\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[ComponentConfig](https://flutter.viam.dev/viam_protos.app.robot/ComponentConfig-class.html)>\>
 
 **Example:**
 
@@ -109,7 +109,7 @@ Get the `ResourceName` for this instance of the service.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
@@ -178,7 +178,7 @@ For more information, see the [Flutter SDK Docs](https://flutter.viam.dev/viam_s
 ### DoCommand
 
 Execute model-specific commands.
-If you are implementing your own generic service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own generic service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -190,7 +190,7 @@ If you are implementing your own generic service and want to add features that h
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Example:**
 
@@ -236,7 +236,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -246,12 +247,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -262,11 +267,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> (required)
+- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
diff --git a/static/include/services/apis/generated/generic_service-table.md b/static/include/services/apis/generated/generic_service-table.md
index d08c9416c0..7f858cf2ea 100644
--- a/static/include/services/apis/generated/generic_service-table.md
+++ b/static/include/services/apis/generated/generic_service-table.md
@@ -1,6 +1,6 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`DoCommand`](/dev/reference/apis/services/generic/#docommand) | Execute model-specific commands. |
-| [`GetResourceName`](/dev/reference/apis/services/generic/#getresourcename) | Get the `ResourceName` for this instance of the generic service. |
-| [`Close`](/dev/reference/apis/services/generic/#close) | Safely shut down the resource and prevent further use. |
+| [`DoCommand`](/reference/apis/services/generic/#docommand) | Execute model-specific commands. |
+| [`GetResourceName`](/reference/apis/services/generic/#getresourcename) | Get the `ResourceName` for this instance of the generic service. |
+| [`Close`](/reference/apis/services/generic/#close) | Safely shut down the resource and prevent further use. |
diff --git a/static/include/services/apis/generated/generic_service.md b/static/include/services/apis/generated/generic_service.md
index 8df47f43b2..2e4a9a5c96 100644
--- a/static/include/services/apis/generated/generic_service.md
+++ b/static/include/services/apis/generated/generic_service.md
@@ -1,7 +1,7 @@
 ### DoCommand
 
 Execute model-specific commands.
-If you are implementing your own generic service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own generic service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -13,7 +13,7 @@ If you are implementing your own generic service and want to add features that h
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), Any]): :   Result of the executed command.
 
 **Example:**
 
@@ -59,7 +59,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -69,12 +70,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -85,11 +90,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> (required)
+- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -117,7 +122,7 @@ Get the `ResourceName` for this instance of the generic service.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/services/apis/generated/mlmodel-table.md b/static/include/services/apis/generated/mlmodel-table.md
index 6cf184196c..5e4a343741 100644
--- a/static/include/services/apis/generated/mlmodel-table.md
+++ b/static/include/services/apis/generated/mlmodel-table.md
@@ -1,9 +1,9 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`Infer`](/dev/reference/apis/services/ml/#infer) | Take an already ordered input tensor as an array, make an inference on the model, and return an output tensor map. |
-| [`Metadata`](/dev/reference/apis/services/ml/#metadata) | Get the metadata: name, data type, expected tensor/array shape, inputs, and outputs associated with the ML model. |
-| [`Reconfigure`](/dev/reference/apis/services/ml/#reconfigure) | Reconfigure this resource. |
-| [`DoCommand`](/dev/reference/apis/services/ml/#docommand) | Execute model-specific commands that are not otherwise defined by the service API. |
-| [`GetResourceName`](/dev/reference/apis/services/ml/#getresourcename) | Get the `ResourceName` for this instance of the ML model service. |
-| [`Close`](/dev/reference/apis/services/ml/#close) | Safely shut down the resource and prevent further use. |
+| [`Infer`](/reference/apis/services/ml/#infer) | Take an already ordered input tensor as an array, make an inference on the model, and return an output tensor map. |
+| [`Metadata`](/reference/apis/services/ml/#metadata) | Get the metadata: name, data type, expected tensor/array shape, inputs, and outputs associated with the ML model. |
+| [`Reconfigure`](/reference/apis/services/ml/#reconfigure) | Reconfigure this resource. |
+| [`DoCommand`](/reference/apis/services/ml/#docommand) | Execute model-specific commands that are not otherwise defined by the service API. |
+| [`GetResourceName`](/reference/apis/services/ml/#getresourcename) | Get the `ResourceName` for this instance of the ML model service. |
+| [`Close`](/reference/apis/services/ml/#close) | Safely shut down the resource and prevent further use. |
diff --git a/static/include/services/apis/generated/mlmodel.md b/static/include/services/apis/generated/mlmodel.md
index 37640e1bda..a1928fe182 100644
--- a/static/include/services/apis/generated/mlmodel.md
+++ b/static/include/services/apis/generated/mlmodel.md
@@ -13,7 +13,7 @@ Take an already ordered input tensor as an array, make an inference on the model
 
 **Returns:**
 
-- (Dict[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), [typing.NDArray](https://numpy.org/doc/stable/reference/typing.html#numpy.typing.NDArray)]): A dictionary of output flat tensors as specified in the metadata.
+- (Dict[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), [typing.NDArray](https://numpy.org/doc/stable/reference/typing.html#numpy.typing.NDArray)]): :   A dictionary of output flat tensors as specified in the metadata.
 
 **Example:**
 
@@ -87,7 +87,7 @@ Get the metadata: name, data type, expected tensor/array shape, inputs, and outp
 
 **Returns:**
 
-- (viam.services.mlmodel.mlmodel.Metadata): The metadata.
+- (viam.services.mlmodel.mlmodel.Metadata): :   The metadata.
 
 **Example:**
 
@@ -151,7 +151,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the service API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own ML model service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own ML model service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Go" %}}
@@ -193,7 +193,7 @@ Get the `ResourceName` for this instance of the ML model service.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/services/apis/generated/motion-table.md b/static/include/services/apis/generated/motion-table.md
index 08833c654a..3c03fd5dbf 100644
--- a/static/include/services/apis/generated/motion-table.md
+++ b/static/include/services/apis/generated/motion-table.md
@@ -1,15 +1,15 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`Move`](/dev/reference/apis/services/motion/#move) | The `Move` method is the primary way to move multiple components, or to move any object to any other location. |
-| [`MoveOnMap`](/dev/reference/apis/services/motion/#moveonmap) | Move a base component to a destination pose on a {{< glossary_tooltip term_id="slam" text="SLAM" >}} map. |
-| [`MoveOnGlobe`](/dev/reference/apis/services/motion/#moveonglobe) | Move a base component to a destination GPS point, represented in geographic notation _(latitude, longitude)_. |
-| [`GetPose`](/dev/reference/apis/services/motion/#getpose) | `GetPose` gets the location and orientation of a component within the frame system. |
-| [`StopPlan`](/dev/reference/apis/services/motion/#stopplan) | Stop a base component being moved by an in progress `MoveOnGlobe` or `MoveOnMap` call. |
-| [`ListPlanStatuses`](/dev/reference/apis/services/motion/#listplanstatuses) | Returns the statuses of plans created by `MoveOnGlobe` or `MoveOnMap` calls that meet at least one of the following conditions since the motion service initialized:  - the plan's status is in progress - the plan's status changed state within the last 24 hours  All repeated fields are in chronological order. |
-| [`GetPlan`](/dev/reference/apis/services/motion/#getplan) | By default, returns the plan history of the most recent `MoveOnGlobe` or `MoveOnMap` call to move a base component. |
-| [`Reconfigure`](/dev/reference/apis/services/motion/#reconfigure) | Reconfigure this resource. |
-| [`FromRobot`](/dev/reference/apis/services/motion/#fromrobot) | Get the resource from the provided machine. |
-| [`DoCommand`](/dev/reference/apis/services/motion/#docommand) | Execute model-specific commands that are not otherwise defined by the service API. |
-| [`GetResourceName`](/dev/reference/apis/services/motion/#getresourcename) | Get the `ResourceName` for this instance of the motion service. |
-| [`Close`](/dev/reference/apis/services/motion/#close) | Safely shut down the resource and prevent further use. |
+| [`Move`](/reference/apis/services/motion/#move) | The `Move` method is the primary way to move multiple components, or to move any object to any other location. |
+| [`MoveOnMap`](/reference/apis/services/motion/#moveonmap) | Move a base component to a destination pose on a {{< glossary_tooltip term_id="slam" text="SLAM" >}} map. |
+| [`MoveOnGlobe`](/reference/apis/services/motion/#moveonglobe) | Move a base component to a destination GPS point, represented in geographic notation _(latitude, longitude)_. |
+| [`GetPose`](/reference/apis/services/motion/#getpose) | `GetPose` gets the location and orientation of a component within the frame system. |
+| [`StopPlan`](/reference/apis/services/motion/#stopplan) | Stop a base component being moved by an in progress `MoveOnGlobe` or `MoveOnMap` call. |
+| [`ListPlanStatuses`](/reference/apis/services/motion/#listplanstatuses) | Returns the statuses of plans created by `MoveOnGlobe` or `MoveOnMap` calls that meet at least one of the following conditions since the motion service initialized:  - the plan's status is in progress - the plan's status changed state within the last 24 hours  All repeated fields are in chronological order. |
+| [`GetPlan`](/reference/apis/services/motion/#getplan) | By default, returns the plan history of the most recent `MoveOnGlobe` or `MoveOnMap` call to move a base component. |
+| [`Reconfigure`](/reference/apis/services/motion/#reconfigure) | Reconfigure this resource. |
+| [`FromRobot`](/reference/apis/services/motion/#fromrobot) | Get the resource from the provided machine. |
+| [`DoCommand`](/reference/apis/services/motion/#docommand) | Execute model-specific commands that are not otherwise defined by the service API. |
+| [`GetResourceName`](/reference/apis/services/motion/#getresourcename) | Get the `ResourceName` for this instance of the motion service. |
+| [`Close`](/reference/apis/services/motion/#close) | Safely shut down the resource and prevent further use. |
diff --git a/static/include/services/apis/generated/motion.md b/static/include/services/apis/generated/motion.md
index 79a0f79776..a9042a21fc 100644
--- a/static/include/services/apis/generated/motion.md
+++ b/static/include/services/apis/generated/motion.md
@@ -177,7 +177,7 @@ Use the machine's position reported by the {{< glossary_tooltip term_id="slam" t
 {{< alert title="Requirements" color="info" >}}
 To use `MoveOnMap()`, your [SLAM service](/operate/reference/services/slam/) must implement `GetPointCloudMap()` and `GetPosition()`
 
-Make sure the [SLAM service](/operate/reference/services/slam/) you use alongside this motion service supports the following methods in its {{< glossary_tooltip term_id="model" text="model's" >}} implementation of the [SLAM service API](/dev/reference/apis/services/slam/):
+Make sure the [SLAM service](/operate/reference/services/slam/) you use alongside this motion service supports the following methods in its {{< glossary_tooltip term_id="model" text="model's" >}} implementation of the SLAM service API:
 
 - It must support `GetPointCloudMap()` to report the SLAM map as a pointcloud.
 - It must support `GetPosition()` to report the machine's current location on the SLAM map.
@@ -359,7 +359,7 @@ You can monitor the progress of the `MoveOnGlobe()` call by querying `GetPlan()`
 {{< alert title="Requirements" color="info" >}}
 To use `MoveOnGlobe()`, your movement sensor must be able to measure the GPS location and orientation of the machine.
 
-Make sure the [movement sensor](/operate/reference/components/movement-sensor/) you use supports usage of the following methods in its {{< glossary_tooltip term_id="model" text="model's" >}} implementation of the [movement sensor API](/dev/reference/apis/components/movement-sensor/).
+Make sure the [movement sensor](/operate/reference/components/movement-sensor/) you use supports usage of the following methods in its {{< glossary_tooltip term_id="model" text="model's" >}} implementation of the [movement sensor API](/reference/apis/components/movement-sensor/).
 
 - It must support `GetPosition()` to report the machine's current GPS location.
 - It must **also** support **either** `GetCompassHeading()` or `GetOrientation()` to report which way the machine is facing.
@@ -561,7 +561,7 @@ You can use the `supplemental_transforms` argument to augment the machine's exis
 
 **Returns:**
 
-- ([viam.proto.common.PoseInFrame](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.PoseInFrame)): Pose of the given component and the frame in which it was observed.
+- ([viam.proto.common.PoseInFrame](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.PoseInFrame)): :   Pose of the given component and the frame in which it was observed.
 
 **Example:**
 
@@ -649,12 +649,9 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/s
 
 **Parameters:**
 
-- `componentName` (string) (required): The component whose `Pose` is being requested.
-- `destinationFrame` (string) (required): The reference frame in which the component's
-  `Pose` should be provided, if unset this defaults to the "world"
-  reference frame.
-- `supplementalTransforms` ([PlainMessage](https://ts.viam.dev/types/PlainMessage.html)) (required): `Pose` information on any additional
-  reference frames that are needed to compute the component's `Pose`.
+- `componentName` (string) (required)
+- `destinationFrame` (string) (required)
+- `supplementalTransforms` ([PlainMessage](https://ts.viam.dev/types/PlainMessage.html)) (required)
 - `extra` (None) (optional)
 - `callOptions` (CallOptions) (optional)
 
@@ -662,21 +659,6 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/s
 
 - (Promise<[commonApi](https://ts.viam.dev/modules/commonApi.html).[PoseInFrame](https://ts.viam.dev/classes/commonApi.PoseInFrame.html)>)
 
-**Example:**
-
-```ts {class="line-numbers linkable-line-numbers"}
-const motion = new VIAM.MotionClient(machine, 'builtin');
-
-const gripperName = 'my_gripper';
-
-// Get the gripper's pose in world coordinates
-const gripperPoseInWorld = await motion.getPose(
-  gripperName,
-  'world',
-  []
-);
-```
-
 For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/MotionClient.html#getpose).
 
 {{% /tab %}}
@@ -684,7 +666,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 ### StopPlan
 
-Stop a [base](/operate/reference/components/base/) component being moved by an in progress [`MoveOnGlobe`](/dev/reference/apis/services/motion/#moveonglobe) or [`MoveOnMap`](/dev/reference/apis/services/motion/#moveonmap) call.
+Stop a [base](/operate/reference/components/base/) component being moved by an in progress [`MoveOnGlobe`](/reference/apis/services/motion/#moveonglobe) or [`MoveOnMap`](/reference/apis/services/motion/#moveonmap) call.
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -775,7 +757,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 ### ListPlanStatuses
 
-Returns the statuses of plans created by [`MoveOnGlobe`](/dev/reference/apis/services/motion/#moveonglobe) or [`MoveOnMap`](/dev/reference/apis/services/motion/#moveonmap) calls that meet at least one of the following conditions since the motion service initialized:
+Returns the statuses of plans created by [`MoveOnGlobe`](/reference/apis/services/motion/#moveonglobe) or [`MoveOnMap`](/reference/apis/services/motion/#moveonmap) calls that meet at least one of the following conditions since the motion service initialized:
 
 - the plan's status is in progress
 - the plan's status changed state within the last 24 hours
@@ -793,8 +775,8 @@ All repeated fields are in chronological order.
 
 **Returns:**
 
-- ([Sequence[viam.proto.service.motion.PlanStatusWithID]](https://python.viam.dev/autoapi/viam/proto/service/motion/index.html#viam.proto.service.motion.PlanStatusWithID)): List of last known statuses with the
-associated IDs of all plans within the TTL ordered by timestamp in ascending order.
+- ([Sequence[viam.proto.service.motion.PlanStatusWithID]](https://python.viam.dev/autoapi/viam/proto/service/motion/index.html#viam.proto.service.motion.PlanStatusWithID)): :   List of last known statuses with the
+    associated IDs of all plans within the TTL ordered by timestamp in ascending order.
 
 **Example:**
 
@@ -862,7 +844,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 ### GetPlan
 
-By default, returns the plan history of the most recent [`MoveOnGlobe`](/dev/reference/apis/services/motion/#moveonglobe) or [`MoveOnMap`](/dev/reference/apis/services/motion/#moveonmap) call to move a [base](/operate/reference/components/base/) component.
+By default, returns the plan history of the most recent [`MoveOnGlobe`](/reference/apis/services/motion/#moveonglobe) or [`MoveOnMap`](/reference/apis/services/motion/#moveonmap) call to move a [base](/operate/reference/components/base/) component.
 
 The plan history for executions before the most recent can be requested by providing an `ExecutionID` in the request.
 
@@ -892,7 +874,7 @@ All repeated fields are in chronological order.
 
 **Returns:**
 
-- ([viam.proto.service.motion.GetPlanResponse](https://python.viam.dev/autoapi/viam/proto/service/motion/index.html#viam.proto.service.motion.GetPlanResponse)): The current PlanWithStatus \& replan history which matches the request.
+- ([viam.proto.service.motion.GetPlanResponse](https://python.viam.dev/autoapi/viam/proto/service/motion/index.html#viam.proto.service.motion.GetPlanResponse)): :   The current PlanWithStatus & replan history which matches the request.
 
 **Example:**
 
@@ -1003,7 +985,7 @@ Get the resource from the provided machine.
 
 **Returns:**
 
-- (typing_extensions.Self): The service, if it exists on the robot.
+- (Self): :   The service, if it exists on the robot.
 
 **Example:**
 
@@ -1033,7 +1015,7 @@ For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/
 Execute model-specific commands that are not otherwise defined by the service API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own motion service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own motion service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -1045,7 +1027,7 @@ If you are implementing your own motion service and want to add features that ha
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Example:**
 
@@ -1091,7 +1073,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -1101,12 +1084,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -1128,7 +1115,7 @@ Get the `ResourceName` for this instance of the motion service.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/services/apis/generated/navigation-table.md b/static/include/services/apis/generated/navigation-table.md
index 3a7a2cfc0c..b206be35f7 100644
--- a/static/include/services/apis/generated/navigation-table.md
+++ b/static/include/services/apis/generated/navigation-table.md
@@ -1,16 +1,16 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`GetMode`](/dev/reference/apis/services/navigation/#getmode) | Get the `Mode` the service is operating in. |
-| [`SetMode`](/dev/reference/apis/services/navigation/#setmode) | Set the `Mode` the service is operating in. |
-| [`GetLocation`](/dev/reference/apis/services/navigation/#getlocation) | Get the current location of the robot in the navigation service. |
-| [`GetWaypoints`](/dev/reference/apis/services/navigation/#getwaypoints) | Get an array of waypoints currently in the service's data storage. |
-| [`AddWaypoint`](/dev/reference/apis/services/navigation/#addwaypoint) | Add a waypoint to the service's data storage. |
-| [`RemoveWaypoint`](/dev/reference/apis/services/navigation/#removewaypoint) | Remove a waypoint from the service's data storage. |
-| [`GetObstacles`](/dev/reference/apis/services/navigation/#getobstacles) | Get an array or list of the obstacles currently in the service's data storage. |
-| [`GetPaths`](/dev/reference/apis/services/navigation/#getpaths) | Get each path, the series of geo points the robot plans to travel through to get to a destination waypoint, in the machine's motion planning. |
-| [`GetProperties`](/dev/reference/apis/services/navigation/#getproperties) | Get information about the navigation service. |
-| [`Reconfigure`](/dev/reference/apis/services/navigation/#reconfigure) | Reconfigure this resource. |
-| [`DoCommand`](/dev/reference/apis/services/navigation/#docommand) | Execute model-specific commands that are not otherwise defined by the service API. |
-| [`GetResourceName`](/dev/reference/apis/services/navigation/#getresourcename) | Get the `ResourceName` for this instance of the navigation service. |
-| [`Close`](/dev/reference/apis/services/navigation/#close) | Safely shut down the resource and prevent further use. |
+| [`GetMode`](/reference/apis/services/navigation/#getmode) | Get the `Mode` the service is operating in. |
+| [`SetMode`](/reference/apis/services/navigation/#setmode) | Set the `Mode` the service is operating in. |
+| [`GetLocation`](/reference/apis/services/navigation/#getlocation) | Get the current location of the robot in the navigation service. |
+| [`GetWaypoints`](/reference/apis/services/navigation/#getwaypoints) | Get an array of waypoints currently in the service's data storage. |
+| [`AddWaypoint`](/reference/apis/services/navigation/#addwaypoint) | Add a waypoint to the service's data storage. |
+| [`RemoveWaypoint`](/reference/apis/services/navigation/#removewaypoint) | Remove a waypoint from the service's data storage. |
+| [`GetObstacles`](/reference/apis/services/navigation/#getobstacles) | Get an array or list of the obstacles currently in the service's data storage. |
+| [`GetPaths`](/reference/apis/services/navigation/#getpaths) | Get each path, the series of geo points the robot plans to travel through to get to a destination waypoint, in the machine's motion planning. |
+| [`GetProperties`](/reference/apis/services/navigation/#getproperties) | Get information about the navigation service. |
+| [`Reconfigure`](/reference/apis/services/navigation/#reconfigure) | Reconfigure this resource. |
+| [`DoCommand`](/reference/apis/services/navigation/#docommand) | Execute model-specific commands that are not otherwise defined by the service API. |
+| [`GetResourceName`](/reference/apis/services/navigation/#getresourcename) | Get the `ResourceName` for this instance of the navigation service. |
+| [`Close`](/reference/apis/services/navigation/#close) | Safely shut down the resource and prevent further use. |
diff --git a/static/include/services/apis/generated/navigation.md b/static/include/services/apis/generated/navigation.md
index 08523098d9..8f6001e799 100644
--- a/static/include/services/apis/generated/navigation.md
+++ b/static/include/services/apis/generated/navigation.md
@@ -16,7 +16,7 @@ There are two options for modes: `MODE_MANUAL` or `MODE_WAYPOINT`.
 
 **Returns:**
 
-- (viam.services.navigation.Mode.ValueType): The Mode the service is operating in.
+- (viam.services.navigation.Mode.ValueType): :   The Mode the service is operating in.
 
 **Example:**
 
@@ -137,7 +137,6 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/s
 
 - `mode` ([navigationApi](https://ts.viam.dev/modules/navigationApi.html)) (required): The mode for the service to operate in.
   
-  
   * 0: MODE\_UNSPECIFIED
   * 1: MODE\_MANUAL
   * 2: MODE\_WAYPOINT
@@ -176,8 +175,8 @@ Get the current location of the robot in the navigation service.
 
 **Returns:**
 
-- ([viam.services.navigation.GeoPoint](https://python.viam.dev/autoapi/viam/services/navigation/index.html#viam.services.navigation.GeoPoint)): The current location of the robot in the navigation service,
-represented in a GeoPoint with latitude and longitude values.
+- ([viam.services.navigation.GeoPoint](https://python.viam.dev/autoapi/viam/services/navigation/index.html#viam.services.navigation.GeoPoint)): :   The current location of the robot in the navigation service,
+    represented in a GeoPoint with latitude and longitude values.
 
 **Example:**
 
@@ -251,8 +250,8 @@ These are locations designated within a path for the robot to navigate to.
 
 **Returns:**
 
-- ([List[viam.services.navigation.Waypoint]](https://python.viam.dev/autoapi/viam/services/navigation/index.html#viam.services.navigation.Waypoint)): An array comprised of each Waypoint in the service’s data storage.
-These are locations designated within a path for the robot to navigate to.
+- ([List[viam.services.navigation.Waypoint]](https://python.viam.dev/autoapi/viam/services/navigation/index.html#viam.services.navigation.Waypoint)): :   An array comprised of each Waypoint in the service’s data storage.
+    These are locations designated within a path for the robot to navigate to.
 
 **Example:**
 
@@ -497,8 +496,8 @@ See the [motion service](/operate/reference/services/motion/) for more informati
 
 **Returns:**
 
-- ([List[viam.services.navigation.GeoGeometry]](https://python.viam.dev/autoapi/viam/services/navigation/index.html#viam.services.navigation.GeoGeometry)): A list comprised of each GeoGeometry in the service’s data storage.
-These are objects designated for the robot to avoid when navigating.
+- ([List[viam.services.navigation.GeoGeometry]](https://python.viam.dev/autoapi/viam/services/navigation/index.html#viam.services.navigation.GeoGeometry)): :   A list comprised of each GeoGeometry in the service’s data storage.
+    These are objects designated for the robot to avoid when navigating.
 
 **Example:**
 
@@ -571,9 +570,9 @@ Get each path, the series of geo points the robot plans to travel through to get
 
 **Returns:**
 
-- ([List[viam.proto.service.navigation.Path]](https://python.viam.dev/autoapi/viam/proto/service/navigation/index.html#viam.proto.service.navigation.Path)): An array comprised of Paths, where each path is either a user\-provided destination or
-a Waypoint, along with the corresponding set of geopoints. This outlines the route the machine is expected to take to
-reach the specified destination or Waypoint.
+- ([List[viam.proto.service.navigation.Path]](https://python.viam.dev/autoapi/viam/proto/service/navigation/index.html#viam.proto.service.navigation.Path)): :   An array comprised of Paths, where each path is either a user-provided destination or
+    a Waypoint, along with the corresponding set of geopoints. This outlines the route the machine is expected to take to
+    reach the specified destination or Waypoint.
 
 **Example:**
 
@@ -646,7 +645,7 @@ Get information about the navigation service.
 
 **Returns:**
 
-- (viam.services.navigation.MapType.ValueType): Information about the type of map the service is using.
+- (viam.services.navigation.MapType.ValueType): :   Information about the type of map the service is using.
 
 **Example:**
 
@@ -732,7 +731,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the service API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own navigation service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own navigation service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -744,7 +743,7 @@ If you are implementing your own navigation service and want to add features tha
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Example:**
 
@@ -790,7 +789,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -800,12 +800,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -827,7 +831,7 @@ Get the `ResourceName` for this instance of the navigation service.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/services/apis/generated/slam-table.md b/static/include/services/apis/generated/slam-table.md
index 731dc08c48..45ac702182 100644
--- a/static/include/services/apis/generated/slam-table.md
+++ b/static/include/services/apis/generated/slam-table.md
@@ -1,13 +1,13 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`GetPosition`](/dev/reference/apis/services/slam/#getposition) | Get the current position of the component the SLAM service is configured to source point cloud data from in the SLAM map as a `Pose`. |
-| [`GetPointCloudMap`](/dev/reference/apis/services/slam/#getpointcloudmap) | Get the point cloud map. |
-| [`GetInternalState`](/dev/reference/apis/services/slam/#getinternalstate) | Get the internal state of the SLAM algorithm required to continue mapping/localization. |
-| [`GetProperties`](/dev/reference/apis/services/slam/#getproperties) | Get information about the current SLAM session. |
-| [`InternalStateFull`](/dev/reference/apis/services/slam/#internalstatefull) | `InternalStateFull` concatenates the streaming responses from `InternalState` into the internal serialized state of the SLAM algorithm. |
-| [`PointCloudMapFull`](/dev/reference/apis/services/slam/#pointcloudmapfull) | `PointCloudMapFull` concatenates the streaming responses from `PointCloudMap` into a full point cloud. |
-| [`Reconfigure`](/dev/reference/apis/services/slam/#reconfigure) | Reconfigure this resource. |
-| [`DoCommand`](/dev/reference/apis/services/slam/#docommand) | Execute model-specific commands that are not otherwise defined by the service API. |
-| [`GetResourceName`](/dev/reference/apis/services/slam/#getresourcename) | Get the `ResourceName` for this instance of the SLAM service. |
-| [`Close`](/dev/reference/apis/services/slam/#close) | Safely shut down the resource and prevent further use. |
+| [`GetPosition`](/reference/apis/services/slam/#getposition) | Get the current position of the component the SLAM service is configured to source point cloud data from in the SLAM map as a `Pose`. |
+| [`GetPointCloudMap`](/reference/apis/services/slam/#getpointcloudmap) | Get the point cloud map. |
+| [`GetInternalState`](/reference/apis/services/slam/#getinternalstate) | Get the internal state of the SLAM algorithm required to continue mapping/localization. |
+| [`GetProperties`](/reference/apis/services/slam/#getproperties) | Get information about the current SLAM session. |
+| [`InternalStateFull`](/reference/apis/services/slam/#internalstatefull) | `InternalStateFull` concatenates the streaming responses from `InternalState` into the internal serialized state of the SLAM algorithm. |
+| [`PointCloudMapFull`](/reference/apis/services/slam/#pointcloudmapfull) | `PointCloudMapFull` concatenates the streaming responses from `PointCloudMap` into a full point cloud. |
+| [`Reconfigure`](/reference/apis/services/slam/#reconfigure) | Reconfigure this resource. |
+| [`DoCommand`](/reference/apis/services/slam/#docommand) | Execute model-specific commands that are not otherwise defined by the service API. |
+| [`GetResourceName`](/reference/apis/services/slam/#getresourcename) | Get the `ResourceName` for this instance of the SLAM service. |
+| [`Close`](/reference/apis/services/slam/#close) | Safely shut down the resource and prevent further use. |
diff --git a/static/include/services/apis/generated/slam.md b/static/include/services/apis/generated/slam.md
index 9df8f5c5d6..5f373ca3ff 100644
--- a/static/include/services/apis/generated/slam.md
+++ b/static/include/services/apis/generated/slam.md
@@ -11,7 +11,7 @@ Get the current position of the component the SLAM service is configured to sour
 
 **Returns:**
 
-- ([viam.services.slam.Pose](https://python.viam.dev/autoapi/viam/services/slam/index.html#viam.services.slam.Pose)): The current position of the specified component.
+- ([viam.services.slam.Pose](https://python.viam.dev/autoapi/viam/services/slam/index.html#viam.services.slam.Pose)): :   The current position of the specified component.
 
 **Example:**
 
@@ -86,8 +86,8 @@ Get the point cloud map.
 
 **Returns:**
 
-- (List[[bytes](https://docs.python.org/3/library/stdtypes.html#bytes-objects)]): Complete pointcloud in standard PCD format. Chunks of the PointCloud, concatenating all
-GetPointCloudMapResponse.point\_cloud\_pcd\_chunk values.
+- (List[[bytes](https://docs.python.org/3/library/stdtypes.html#bytes-objects)]): :   Complete pointcloud in standard PCD format. Chunks of the PointCloud, concatenating all
+    GetPointCloudMapResponse.point\_cloud\_pcd\_chunk values.
 
 **Example:**
 
@@ -156,7 +156,7 @@ Get the internal state of the SLAM algorithm required to continue mapping/locali
 
 **Returns:**
 
-- (List[[bytes](https://docs.python.org/3/library/stdtypes.html#bytes-objects)]): Chunks of the internal state of the SLAM algorithm.
+- (List[[bytes](https://docs.python.org/3/library/stdtypes.html#bytes-objects)]): :   Chunks of the internal state of the SLAM algorithm.
 
 **Example:**
 
@@ -220,7 +220,7 @@ Get information about the current SLAM session.
 
 **Returns:**
 
-- (viam.services.slam.slam.SLAM.Properties): The properties of SLAM.
+- ([viam.services.slam.slam.SLAM.Properties](https://python.viam.dev/autoapi/viam/services/slam/slam/index.html#viam.services.slam.slam.SLAM.Properties)): :   The properties of SLAM.
 
 **Example:**
 
@@ -360,7 +360,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the service API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own SLAM service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own SLAM service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -372,7 +372,7 @@ If you are implementing your own SLAM service and want to add features that have
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Example:**
 
@@ -418,7 +418,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -428,12 +429,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -455,7 +460,7 @@ Get the `ResourceName` for this instance of the SLAM service.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/services/apis/generated/vision-table.md b/static/include/services/apis/generated/vision-table.md
index 4abc54d8e0..9a1426c75e 100644
--- a/static/include/services/apis/generated/vision-table.md
+++ b/static/include/services/apis/generated/vision-table.md
@@ -1,14 +1,14 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`GetDetectionsFromCamera`](/dev/reference/apis/services/vision/#getdetectionsfromcamera) | Get a list of detections from the next image from a specified camera using a configured detector. |
-| [`GetDetections`](/dev/reference/apis/services/vision/#getdetections) | Get a list of detections from a given image using a configured detector. |
-| [`GetClassificationsFromCamera`](/dev/reference/apis/services/vision/#getclassificationsfromcamera) | Get a list of classifications from the next image from a specified camera using a configured classifier. |
-| [`GetClassifications`](/dev/reference/apis/services/vision/#getclassifications) | Get a list of classifications from a given image using a configured classifier. |
-| [`GetObjectPointClouds`](/dev/reference/apis/services/vision/#getobjectpointclouds) | Get a list of 3D point cloud objects and associated metadata in the latest picture from a 3D camera (using a specified segmenter). |
-| [`CaptureAllFromCamera`](/dev/reference/apis/services/vision/#captureallfromcamera) | Get the next image, detections, classifications, and objects all together, given a camera name. |
-| [`Reconfigure`](/dev/reference/apis/services/vision/#reconfigure) | Reconfigure this resource. |
-| [`DoCommand`](/dev/reference/apis/services/vision/#docommand) | Execute model-specific commands that are not otherwise defined by the service API. |
-| [`GetResourceName`](/dev/reference/apis/services/vision/#getresourcename) | Get the `ResourceName` for this instance of the vision service. |
-| [`GetProperties`](/dev/reference/apis/services/vision/#getproperties) | Fetch information about which vision methods a given vision service supports. |
-| [`Close`](/dev/reference/apis/services/vision/#close) | Safely shut down the resource and prevent further use. |
+| [`GetDetectionsFromCamera`](/reference/apis/services/vision/#getdetectionsfromcamera) | Get a list of detections from the next image from a specified camera using a configured detector. |
+| [`GetDetections`](/reference/apis/services/vision/#getdetections) | Get a list of detections from a given image using a configured detector. |
+| [`GetClassificationsFromCamera`](/reference/apis/services/vision/#getclassificationsfromcamera) | Get a list of classifications from the next image from a specified camera using a configured classifier. |
+| [`GetClassifications`](/reference/apis/services/vision/#getclassifications) | Get a list of classifications from a given image using a configured classifier. |
+| [`GetObjectPointClouds`](/reference/apis/services/vision/#getobjectpointclouds) | Get a list of 3D point cloud objects and associated metadata in the latest picture from a 3D camera (using a specified segmenter). |
+| [`CaptureAllFromCamera`](/reference/apis/services/vision/#captureallfromcamera) | Get the next image, detections, classifications, and objects all together, given a camera name. |
+| [`Reconfigure`](/reference/apis/services/vision/#reconfigure) | Reconfigure this resource. |
+| [`DoCommand`](/reference/apis/services/vision/#docommand) | Execute model-specific commands that are not otherwise defined by the service API. |
+| [`GetResourceName`](/reference/apis/services/vision/#getresourcename) | Get the `ResourceName` for this instance of the vision service. |
+| [`GetProperties`](/reference/apis/services/vision/#getproperties) | Fetch information about which vision methods a given vision service supports. |
+| [`Close`](/reference/apis/services/vision/#close) | Safely shut down the resource and prevent further use. |
diff --git a/static/include/services/apis/generated/vision.md b/static/include/services/apis/generated/vision.md
index 24b6b0f260..03425b9e94 100644
--- a/static/include/services/apis/generated/vision.md
+++ b/static/include/services/apis/generated/vision.md
@@ -1,6 +1,6 @@
 ### GetDetectionsFromCamera
 
-Get a list of detections from the next image from a specified camera using a configured [detector](/dev/reference/apis/services/vision/#detections).
+Get a list of detections from the next image from a specified camera using a configured [detector](/reference/apis/services/vision/#detections).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -13,9 +13,9 @@ Get a list of detections from the next image from a specified camera using a con
 
 **Returns:**
 
-- ([List[viam.proto.service.vision.Detection]](https://python.viam.dev/autoapi/viam/proto/service/vision/index.html#viam.proto.service.vision.Detection)): A list of 2D bounding boxes, their labels, and the
-confidence score of the labels, around the found objects in the next 2D image
-from the given camera, with the given detector applied to it.
+- ([List[viam.proto.service.vision.Detection]](https://python.viam.dev/autoapi/viam/proto/service/vision/index.html#viam.proto.service.vision.Detection)): :   A list of 2D bounding boxes, their labels, and the
+    confidence score of the labels, around the found objects in the next 2D image
+    from the given camera, with the given detector applied to it.
 
 **Raises:**
 
@@ -95,11 +95,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 **Parameters:**
 
 - `cameraName` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[Detection](https://flutter.viam.dev/viam_protos.service.vision/Detection-class.html)\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[Detection](https://flutter.viam.dev/viam_protos.service.vision/Detection-class.html)>\>
 
 **Example:**
 
@@ -115,7 +115,7 @@ For more information, see the [Flutter SDK Docs](https://flutter.viam.dev/viam_s
 
 ### GetDetections
 
-Get a list of detections from a given image using a configured [detector](/dev/reference/apis/services/vision/#detections).
+Get a list of detections from a given image using a configured [detector](/reference/apis/services/vision/#detections).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -128,9 +128,9 @@ Get a list of detections from a given image using a configured [detector](/dev/r
 
 **Returns:**
 
-- ([List[viam.proto.service.vision.Detection]](https://python.viam.dev/autoapi/viam/proto/service/vision/index.html#viam.proto.service.vision.Detection)): A list of 2D bounding boxes, their labels, and the
-confidence score of the labels, around the found objects in the next 2D image
-from the given camera, with the given detector applied to it.
+- ([List[viam.proto.service.vision.Detection]](https://python.viam.dev/autoapi/viam/proto/service/vision/index.html#viam.proto.service.vision.Detection)): :   A list of 2D bounding boxes, their labels, and the
+    confidence score of the labels, around the found objects in the next 2D image
+    from the given camera, with the given detector applied to it.
 
 **Raises:**
 
@@ -218,13 +218,12 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/s
 const camera = new VIAM.CameraClient(machine, 'my_camera');
 const vision = new VIAM.VisionClient(machine, 'my_vision');
 
-const mimeType = 'image/jpeg';
-const image = await camera.getImage(mimeType);
+const { images } = await camera.getImages();
 const detections = await vision.getDetections(
-  image,
+  images[0].image,
   600,
   600,
-  mimeType
+  images[0].mimeType
 );
 ```
 
@@ -236,11 +235,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 **Parameters:**
 
 - `image` [ViamImage](https://flutter.viam.dev/viam_sdk/ViamImage-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[Detection](https://flutter.viam.dev/viam_protos.service.vision/Detection-class.html)\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[Detection](https://flutter.viam.dev/viam_protos.service.vision/Detection-class.html)>\>
 
 **Example:**
 
@@ -257,7 +256,7 @@ For more information, see the [Flutter SDK Docs](https://flutter.viam.dev/viam_s
 
 ### GetClassificationsFromCamera
 
-Get a list of classifications from the next image from a specified camera using a configured [classifier](/dev/reference/apis/services/vision/#classifications).
+Get a list of classifications from the next image from a specified camera using a configured [classifier](/reference/apis/services/vision/#classifications).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -271,7 +270,7 @@ Get a list of classifications from the next image from a specified camera using
 
 **Returns:**
 
-- ([List[viam.proto.service.vision.Classification]](https://python.viam.dev/autoapi/viam/proto/service/vision/index.html#viam.proto.service.vision.Classification)): The list of Classifications.
+- ([List[viam.proto.service.vision.Classification]](https://python.viam.dev/autoapi/viam/proto/service/vision/index.html#viam.proto.service.vision.Classification)): :   The list of Classifications.
 
 **Example:**
 
@@ -353,11 +352,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 - `cameraName` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
 - `count` [int](https://api.flutter.dev/flutter/dart-core/int-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[Classification](https://flutter.viam.dev/viam_protos.service.vision/Classification-class.html)\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[Classification](https://flutter.viam.dev/viam_protos.service.vision/Classification-class.html)>\>
 
 **Example:**
 
@@ -373,7 +372,7 @@ For more information, see the [Flutter SDK Docs](https://flutter.viam.dev/viam_s
 
 ### GetClassifications
 
-Get a list of classifications from a given image using a configured [classifier](/dev/reference/apis/services/vision/#classifications).
+Get a list of classifications from a given image using a configured [classifier](/reference/apis/services/vision/#classifications).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -387,7 +386,7 @@ Get a list of classifications from a given image using a configured [classifier]
 
 **Returns:**
 
-- ([List[viam.proto.service.vision.Classification]](https://python.viam.dev/autoapi/viam/proto/service/vision/index.html#viam.proto.service.vision.Classification)): The list of Classifications.
+- ([List[viam.proto.service.vision.Classification]](https://python.viam.dev/autoapi/viam/proto/service/vision/index.html#viam.proto.service.vision.Classification)): :   The list of Classifications.
 
 **Example:**
 
@@ -473,13 +472,12 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/s
 const camera = new VIAM.CameraClient(machine, 'my_camera');
 const vision = new VIAM.VisionClient(machine, 'my_vision');
 
-const mimeType = 'image/jpeg';
-const image = await camera.getImage(mimeType);
+const { images } = await camera.getImages();
 const classifications = await vision.getClassifications(
-  image,
+  images[0].image,
   600,
   600,
-  mimeType,
+  images[0].mimeType,
   10
 );
 ```
@@ -493,11 +491,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 - `image` [ViamImage](https://flutter.viam.dev/viam_sdk/ViamImage-class.html) (required)
 - `count` [int](https://api.flutter.dev/flutter/dart-core/int-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[Classification](https://flutter.viam.dev/viam_protos.service.vision/Classification-class.html)\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[Classification](https://flutter.viam.dev/viam_protos.service.vision/Classification-class.html)>\>
 
 **Example:**
 
@@ -514,7 +512,7 @@ For more information, see the [Flutter SDK Docs](https://flutter.viam.dev/viam_s
 
 ### GetObjectPointClouds
 
-Get a list of 3D point cloud objects and associated metadata in the latest picture from a 3D camera (using a specified [segmenter](/dev/reference/apis/services/vision/#segmentations)).
+Get a list of 3D point cloud objects and associated metadata in the latest picture from a 3D camera (using a specified [segmenter](/reference/apis/services/vision/#segmentations)).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -527,7 +525,7 @@ Get a list of 3D point cloud objects and associated metadata in the latest pictu
 
 **Returns:**
 
-- ([List[viam.proto.common.PointCloudObject]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.PointCloudObject)): The pointcloud objects with metadata.
+- ([List[viam.proto.common.PointCloudObject]](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.PointCloudObject)): :   The pointcloud objects with metadata.
 
 **Example:**
 
@@ -610,11 +608,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 **Parameters:**
 
 - `cameraName` [String](https://api.flutter.dev/flutter/dart-core/String-class.html) (required)
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)\<[PointCloudObject](https://flutter.viam.dev/viam_protos.common.common/PointCloudObject-class.html)\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[List](https://api.flutter.dev/flutter/dart-core/List-class.html)<[PointCloudObject](https://flutter.viam.dev/viam_protos.common.common/PointCloudObject-class.html)>\>
 
 **Example:**
 
@@ -648,9 +646,9 @@ Used for visualization.
 
 **Returns:**
 
-- ([viam.services.vision.vision.CaptureAllResult](https://python.viam.dev/autoapi/viam/services/vision/vision/index.html#viam.services.vision.vision.CaptureAllResult)): A class that stores all potential returns from the vision service.
-It can return the image from the camera along with its associated detections, classifications,
-and objects, as well as any extra info the model may provide.
+- ([viam.services.vision.vision.CaptureAllResult](https://python.viam.dev/autoapi/viam/services/vision/vision/index.html#viam.services.vision.vision.CaptureAllResult)): :   A class that stores all potential returns from the vision service.
+    It can return the image from the camera along with its associated detections, classifications,
+    and objects, as well as any extra info the model may provide.
 
 **Example:**
 
@@ -718,8 +716,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/s
 
 **Returns:**
 
-- (Promise< { classifications: [visionApi](https://ts.viam.dev/modules/visionApi.html).[Classification](https://ts.viam.dev/classes/visionApi.Classification.html)[]; detections: [visionApi](https://ts.viam.dev/modules/visionApi.html).[Detection](https://ts.viam.dev/classes/visionApi.Detection.html)[]; extra: undefined | [Struct](https://ts.viam.dev/classes/Struct.html); image: undefined | [Image](https://ts.viam.dev/classes/cameraApi.Image.html); objectPointClouds: [commonApi](https://ts.viam.dev/modules/commonApi.html).[PointCloudObject](https://ts.viam.dev/classes/commonApi.PointCloudObject.html)[]; },>): * The requested image, classifications, detections, and 3d point
-cloud objects.
+- (Promise< { classifications: [visionApi](https://ts.viam.dev/modules/visionApi.html).[Classification](https://ts.viam.dev/classes/visionApi.Classification.html)[]; detections: [visionApi](https://ts.viam.dev/modules/visionApi.html).[Detection](https://ts.viam.dev/classes/visionApi.Detection.html)[]; extra: undefined | [Struct](https://ts.viam.dev/classes/Struct.html); image: undefined | [Image](https://ts.viam.dev/classes/cameraApi.Image.html); objectPointClouds: [commonApi](https://ts.viam.dev/modules/commonApi.html).[PointCloudObject](https://ts.viam.dev/classes/commonApi.PointCloudObject.html)[]; }, >): * The requested image, classifications, detections, and 3d point
+  cloud objects.
 
 **Example:**
 
@@ -766,7 +764,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 Execute model-specific commands that are not otherwise defined by the service API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own vision service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own vision service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -778,7 +776,7 @@ If you are implementing your own vision service and want to add features that ha
 
 **Returns:**
 
-- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): Result of the executed command.
+- (Mapping[[str](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), viam.utils.ValueTypes]): :   Result of the executed command.
 
 **Example:**
 
@@ -824,7 +822,8 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -834,12 +833,16 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/r
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -850,11 +853,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\> (required)
+- `command` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic> (required)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>\>
 
 **Example:**
 
@@ -882,7 +885,7 @@ Get the `ResourceName` for this instance of the vision service.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
@@ -968,7 +971,7 @@ Fetch information about which vision methods a given vision service supports.
 
 **Returns:**
 
-- ([Vision.Properties](https://python.viam.dev/autoapi/viam/components/audio_input/audio_input/index.html#viam.components.audio_input.audio_input.AudioInput.Properties)): The properties of the vision service.
+- ([Vision.Properties](https://python.viam.dev/autoapi/viam/components/audio_input/audio_input/index.html#viam.components.audio_input.audio_input.AudioInput.Properties)): :   The properties of the vision service.
 
 **Example:**
 
@@ -1006,7 +1009,7 @@ For more information, see the [Go SDK Docs](https://pkg.go.dev/go.viam.com/rdk/s
 
 **Returns:**
 
-- (Promise< { classificationsSupported: boolean; detectionsSupported: boolean; objectPointCloudsSupported: boolean; },>): * The properties of the vision service.
+- (Promise< { classificationsSupported: boolean; detectionsSupported: boolean; objectPointCloudsSupported: boolean; }, >): * The properties of the vision service.
 
 **Example:**
 
@@ -1022,11 +1025,11 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 
 **Parameters:**
 
-- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)\<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic\>? (optional)
+- `extra` [Map](https://api.flutter.dev/flutter/dart-core/Map-class.html)<[String](https://api.flutter.dev/flutter/dart-core/String-class.html), dynamic>? (optional)
 
 **Returns:**
 
-- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)\<[VisionProperties](https://flutter.viam.dev/viam_sdk/VisionProperties.html)\>
+- [Future](https://api.flutter.dev/flutter/dart-async/Future-class.html)<[VisionProperties](https://flutter.viam.dev/viam_sdk/VisionProperties.html)>
 
 **Example:**
 
diff --git a/static/include/services/apis/generated/world_state_store-table.md b/static/include/services/apis/generated/world_state_store-table.md
index ddfff5b675..06957fb522 100644
--- a/static/include/services/apis/generated/world_state_store-table.md
+++ b/static/include/services/apis/generated/world_state_store-table.md
@@ -1,9 +1,9 @@
 <!-- prettier-ignore -->
 | Method Name | Description |
 | ----------- | ----------- |
-| [`ListUUIDs`](/dev/reference/apis/services/world-state-store/#listuuids) | List all world state transform UUIDs. |
-| [`GetTransform`](/dev/reference/apis/services/world-state-store/#gettransform) | Get a world state transform by UUID. |
-| [`StreamTransformChanges`](/dev/reference/apis/services/world-state-store/#streamtransformchanges) | Stream changes to world state transforms. |
-| [`DoCommand`](/dev/reference/apis/services/world-state-store/#docommand) | Execute model-specific commands that are not otherwise defined by the service API. |
-| [`GetResourceName`](/dev/reference/apis/services/world-state-store/#getresourcename) | Get the ResourceName for this Resource with the given name. |
-| [`Close`](/dev/reference/apis/services/world-state-store/#close) | Safely shut down the resource and prevent further use. |
+| [`ListUUIDs`](/reference/apis/services/world-state-store/#listuuids) | List all world state transform UUIDs. |
+| [`GetTransform`](/reference/apis/services/world-state-store/#gettransform) | Get a world state transform by UUID. |
+| [`StreamTransformChanges`](/reference/apis/services/world-state-store/#streamtransformchanges) | Stream changes to world state transforms. |
+| [`DoCommand`](/reference/apis/services/world-state-store/#docommand) | Execute model-specific commands that are not otherwise defined by the service API. |
+| [`GetResourceName`](/reference/apis/services/world-state-store/#getresourcename) | Get the ResourceName for this Resource with the given name. |
+| [`Close`](/reference/apis/services/world-state-store/#close) | Safely shut down the resource and prevent further use. |
diff --git a/static/include/services/apis/generated/world_state_store.md b/static/include/services/apis/generated/world_state_store.md
index ef24c9c353..8dd73c1cd3 100644
--- a/static/include/services/apis/generated/world_state_store.md
+++ b/static/include/services/apis/generated/world_state_store.md
@@ -178,7 +178,7 @@ For more information, see the [TypeScript SDK Docs](https://ts.viam.dev/classes/
 Execute model-specific commands that are not otherwise defined by the service API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own vision service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own vision service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
 
 {{< tabs >}}
 {{% tab name="Python" %}}
@@ -212,7 +212,8 @@ For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/
 
 **Parameters:**
 
-- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute.
+- `command` ([Struct](https://ts.viam.dev/classes/Struct.html)) (required): The command to execute. Accepts either a [Struct](https://ts.viam.dev/classes/Struct.html) or
+  a plain object, which will be converted automatically.
 - `callOptions` (CallOptions) (optional)
 
 **Returns:**
@@ -222,12 +223,16 @@ For more information, see the [Python SDK Docs](https://python.viam.dev/autoapi/
 **Example:**
 
 ```ts {class="line-numbers linkable-line-numbers"}
+// Plain object (recommended)
+const result = await resource.doCommand({
+  myCommand: { key: 'value' },
+});
+
+// Struct (still supported)
 import { Struct } from '@viamrobotics/sdk';
 
 const result = await resource.doCommand(
-  Struct.fromJson({
-    myCommand: { key: 'value' },
-  })
+  Struct.fromJson({ myCommand: { key: 'value' } })
 );
 ```
 
@@ -249,7 +254,7 @@ Get the ResourceName for this Resource with the given name.
 
 **Returns:**
 
-- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): The ResourceName of this Resource.
+- ([viam.proto.common.ResourceName](https://python.viam.dev/autoapi/viam/proto/common/index.html#viam.proto.common.ResourceName)): :   The ResourceName of this Resource.
 
 **Example:**
 
diff --git a/static/include/services/apis/generic.md b/static/include/services/apis/generic.md
index 143521bdbb..541940e7e5 100644
--- a/static/include/services/apis/generic.md
+++ b/static/include/services/apis/generic.md
@@ -1,5 +1,5 @@
 <!-- prettier-ignore -->
 | Method Name                                   | Description                              |
 | --------------------------------------------- | ---------------------------------------- |
-| [`DoCommand`](/dev/reference/apis/services/generic/#docommand) | Send or receive model-specific commands. |
-| [`Close`](/dev/reference/apis/services/generic/#close) | Safely shut down the resource and prevent further use. |
+| [`DoCommand`](/reference/apis/services/generic/#docommand) | Send or receive model-specific commands. |
+| [`Close`](/reference/apis/services/generic/#close) | Safely shut down the resource and prevent further use. |
diff --git a/static/include/services/apis/overrides/protos/base_remote_control.DoCommand.md b/static/include/services/apis/overrides/protos/base_remote_control.DoCommand.md
index 36d6b47993..769bc4594c 100644
--- a/static/include/services/apis/overrides/protos/base_remote_control.DoCommand.md
+++ b/static/include/services/apis/overrides/protos/base_remote_control.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the service API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own base remote control service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own base remote control service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/services/apis/overrides/protos/data_manager.DoCommand.md b/static/include/services/apis/overrides/protos/data_manager.DoCommand.md
index 5eeb458233..bb2824216a 100644
--- a/static/include/services/apis/overrides/protos/data_manager.DoCommand.md
+++ b/static/include/services/apis/overrides/protos/data_manager.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the service API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own data manager service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own data manager service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/services/apis/overrides/protos/discovery.DoCommand.md b/static/include/services/apis/overrides/protos/discovery.DoCommand.md
index 356450f8a1..21100714af 100644
--- a/static/include/services/apis/overrides/protos/discovery.DoCommand.md
+++ b/static/include/services/apis/overrides/protos/discovery.DoCommand.md
@@ -1,2 +1,2 @@
 Execute model-specific commands.
-If you are implementing your own generic service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own generic service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/services/apis/overrides/protos/generic_service.DoCommand.md b/static/include/services/apis/overrides/protos/generic_service.DoCommand.md
index 356450f8a1..21100714af 100644
--- a/static/include/services/apis/overrides/protos/generic_service.DoCommand.md
+++ b/static/include/services/apis/overrides/protos/generic_service.DoCommand.md
@@ -1,2 +1,2 @@
 Execute model-specific commands.
-If you are implementing your own generic service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own generic service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/services/apis/overrides/protos/mlmodel.DoCommand.md b/static/include/services/apis/overrides/protos/mlmodel.DoCommand.md
index 37302a7c44..26edb4f5bd 100644
--- a/static/include/services/apis/overrides/protos/mlmodel.DoCommand.md
+++ b/static/include/services/apis/overrides/protos/mlmodel.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the service API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own ML model service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own ML model service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/services/apis/overrides/protos/motion.DoCommand.md b/static/include/services/apis/overrides/protos/motion.DoCommand.md
index 706bc0d940..602710d996 100644
--- a/static/include/services/apis/overrides/protos/motion.DoCommand.md
+++ b/static/include/services/apis/overrides/protos/motion.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the service API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own motion service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own motion service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/services/apis/overrides/protos/motion.GetPlan.md b/static/include/services/apis/overrides/protos/motion.GetPlan.md
index 69dfb9702d..13f1e9cfa3 100644
--- a/static/include/services/apis/overrides/protos/motion.GetPlan.md
+++ b/static/include/services/apis/overrides/protos/motion.GetPlan.md
@@ -1,4 +1,4 @@
-By default, returns the plan history of the most recent [`MoveOnGlobe`](/dev/reference/apis/services/motion/#moveonglobe) or [`MoveOnMap`](/dev/reference/apis/services/motion/#moveonmap) call to move a [base](/operate/reference/components/base/) component.
+By default, returns the plan history of the most recent [`MoveOnGlobe`](/reference/apis/services/motion/#moveonglobe) or [`MoveOnMap`](/reference/apis/services/motion/#moveonmap) call to move a [base](/operate/reference/components/base/) component.
 
 The plan history for executions before the most recent can be requested by providing an `ExecutionID` in the request.
 
diff --git a/static/include/services/apis/overrides/protos/motion.ListPlanStatuses.md b/static/include/services/apis/overrides/protos/motion.ListPlanStatuses.md
index e20a08753d..e5dbd899de 100644
--- a/static/include/services/apis/overrides/protos/motion.ListPlanStatuses.md
+++ b/static/include/services/apis/overrides/protos/motion.ListPlanStatuses.md
@@ -1,4 +1,4 @@
-Returns the statuses of plans created by [`MoveOnGlobe`](/dev/reference/apis/services/motion/#moveonglobe) or [`MoveOnMap`](/dev/reference/apis/services/motion/#moveonmap) calls that meet at least one of the following conditions since the motion service initialized:
+Returns the statuses of plans created by [`MoveOnGlobe`](/reference/apis/services/motion/#moveonglobe) or [`MoveOnMap`](/reference/apis/services/motion/#moveonmap) calls that meet at least one of the following conditions since the motion service initialized:
 
 - the plan's status is in progress
 - the plan's status changed state within the last 24 hours
diff --git a/static/include/services/apis/overrides/protos/motion.MoveOnGlobe.md b/static/include/services/apis/overrides/protos/motion.MoveOnGlobe.md
index 8a841050bf..8d4d765145 100644
--- a/static/include/services/apis/overrides/protos/motion.MoveOnGlobe.md
+++ b/static/include/services/apis/overrides/protos/motion.MoveOnGlobe.md
@@ -16,7 +16,7 @@ You can monitor the progress of the `MoveOnGlobe()` call by querying `GetPlan()`
 {{< alert title="Requirements" color="info" >}}
 To use `MoveOnGlobe()`, your movement sensor must be able to measure the GPS location and orientation of the machine.
 
-Make sure the [movement sensor](/operate/reference/components/movement-sensor/) you use supports usage of the following methods in its {{< glossary_tooltip term_id="model" text="model's" >}} implementation of the [movement sensor API](/dev/reference/apis/components/movement-sensor/).
+Make sure the [movement sensor](/operate/reference/components/movement-sensor/) you use supports usage of the following methods in its {{< glossary_tooltip term_id="model" text="model's" >}} implementation of the [movement sensor API](/reference/apis/components/movement-sensor/).
 
 - It must support `GetPosition()` to report the machine's current GPS location.
 - It must **also** support **either** `GetCompassHeading()` or `GetOrientation()` to report which way the machine is facing.
diff --git a/static/include/services/apis/overrides/protos/motion.MoveOnMap.md b/static/include/services/apis/overrides/protos/motion.MoveOnMap.md
index e1adde61d9..333f9350dc 100644
--- a/static/include/services/apis/overrides/protos/motion.MoveOnMap.md
+++ b/static/include/services/apis/overrides/protos/motion.MoveOnMap.md
@@ -17,7 +17,7 @@ Use the machine's position reported by the {{< glossary_tooltip term_id="slam" t
 {{< alert title="Requirements" color="info" >}}
 To use `MoveOnMap()`, your [SLAM service](/operate/reference/services/slam/) must implement `GetPointCloudMap()` and `GetPosition()`
 
-Make sure the [SLAM service](/operate/reference/services/slam/) you use alongside this motion service supports the following methods in its {{< glossary_tooltip term_id="model" text="model's" >}} implementation of the [SLAM service API](/dev/reference/apis/services/slam/):
+Make sure the [SLAM service](/operate/reference/services/slam/) you use alongside this motion service supports the following methods in its {{< glossary_tooltip term_id="model" text="model's" >}} implementation of the [SLAM service API](/reference/apis/services/slam/):
 
 - It must support `GetPointCloudMap()` to report the SLAM map as a pointcloud.
 - It must support `GetPosition()` to report the machine's current location on the SLAM map.
diff --git a/static/include/services/apis/overrides/protos/motion.StopPlan.md b/static/include/services/apis/overrides/protos/motion.StopPlan.md
index a48fe4e831..c826dd78f3 100644
--- a/static/include/services/apis/overrides/protos/motion.StopPlan.md
+++ b/static/include/services/apis/overrides/protos/motion.StopPlan.md
@@ -1 +1 @@
-Stop a [base](/operate/reference/components/base/) component being moved by an in progress [`MoveOnGlobe`](/dev/reference/apis/services/motion/#moveonglobe) or [`MoveOnMap`](/dev/reference/apis/services/motion/#moveonmap) call.
+Stop a [base](/operate/reference/components/base/) component being moved by an in progress [`MoveOnGlobe`](/reference/apis/services/motion/#moveonglobe) or [`MoveOnMap`](/reference/apis/services/motion/#moveonmap) call.
diff --git a/static/include/services/apis/overrides/protos/navigation.DoCommand.md b/static/include/services/apis/overrides/protos/navigation.DoCommand.md
index 3372a733dc..e90a6f9ab0 100644
--- a/static/include/services/apis/overrides/protos/navigation.DoCommand.md
+++ b/static/include/services/apis/overrides/protos/navigation.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the service API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own navigation service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own navigation service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/services/apis/overrides/protos/slam.DoCommand.md b/static/include/services/apis/overrides/protos/slam.DoCommand.md
index 5870206d57..566db6862e 100644
--- a/static/include/services/apis/overrides/protos/slam.DoCommand.md
+++ b/static/include/services/apis/overrides/protos/slam.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the service API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own SLAM service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own SLAM service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/services/apis/overrides/protos/vision.DoCommand.md b/static/include/services/apis/overrides/protos/vision.DoCommand.md
index 90eddcf335..57577674a1 100644
--- a/static/include/services/apis/overrides/protos/vision.DoCommand.md
+++ b/static/include/services/apis/overrides/protos/vision.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the service API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own vision service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own vision service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/include/services/apis/overrides/protos/vision.GetClassifications.md b/static/include/services/apis/overrides/protos/vision.GetClassifications.md
index 46f8a1a328..a487f064b9 100644
--- a/static/include/services/apis/overrides/protos/vision.GetClassifications.md
+++ b/static/include/services/apis/overrides/protos/vision.GetClassifications.md
@@ -1 +1 @@
-Get a list of classifications from a given image using a configured [classifier](/dev/reference/apis/services/vision/#classifications).
+Get a list of classifications from a given image using a configured [classifier](/reference/apis/services/vision/#classifications).
diff --git a/static/include/services/apis/overrides/protos/vision.GetClassificationsFromCamera.md b/static/include/services/apis/overrides/protos/vision.GetClassificationsFromCamera.md
index 663b37a125..54cf928a68 100644
--- a/static/include/services/apis/overrides/protos/vision.GetClassificationsFromCamera.md
+++ b/static/include/services/apis/overrides/protos/vision.GetClassificationsFromCamera.md
@@ -1 +1 @@
-Get a list of classifications from the next image from a specified camera using a configured [classifier](/dev/reference/apis/services/vision/#classifications).
+Get a list of classifications from the next image from a specified camera using a configured [classifier](/reference/apis/services/vision/#classifications).
diff --git a/static/include/services/apis/overrides/protos/vision.GetDetections.md b/static/include/services/apis/overrides/protos/vision.GetDetections.md
index 63d3e29b42..2eb90d4422 100644
--- a/static/include/services/apis/overrides/protos/vision.GetDetections.md
+++ b/static/include/services/apis/overrides/protos/vision.GetDetections.md
@@ -1 +1 @@
-Get a list of detections from a given image using a configured [detector](/dev/reference/apis/services/vision/#detections).
+Get a list of detections from a given image using a configured [detector](/reference/apis/services/vision/#detections).
diff --git a/static/include/services/apis/overrides/protos/vision.GetDetectionsFromCamera.md b/static/include/services/apis/overrides/protos/vision.GetDetectionsFromCamera.md
index 4fcbb7aa05..6c97e3f25a 100644
--- a/static/include/services/apis/overrides/protos/vision.GetDetectionsFromCamera.md
+++ b/static/include/services/apis/overrides/protos/vision.GetDetectionsFromCamera.md
@@ -1 +1 @@
-Get a list of detections from the next image from a specified camera using a configured [detector](/dev/reference/apis/services/vision/#detections).
+Get a list of detections from the next image from a specified camera using a configured [detector](/reference/apis/services/vision/#detections).
diff --git a/static/include/services/apis/overrides/protos/vision.GetObjectPointClouds.md b/static/include/services/apis/overrides/protos/vision.GetObjectPointClouds.md
index baba74720c..9c81af79c8 100644
--- a/static/include/services/apis/overrides/protos/vision.GetObjectPointClouds.md
+++ b/static/include/services/apis/overrides/protos/vision.GetObjectPointClouds.md
@@ -1 +1 @@
-Get a list of 3D point cloud objects and associated metadata in the latest picture from a 3D camera (using a specified [segmenter](/dev/reference/apis/services/vision/#segmentations)).
+Get a list of 3D point cloud objects and associated metadata in the latest picture from a 3D camera (using a specified [segmenter](/reference/apis/services/vision/#segmentations)).
diff --git a/static/include/services/apis/overrides/protos/world_state_store.DoCommand.md b/static/include/services/apis/overrides/protos/world_state_store.DoCommand.md
index 90eddcf335..57577674a1 100644
--- a/static/include/services/apis/overrides/protos/world_state_store.DoCommand.md
+++ b/static/include/services/apis/overrides/protos/world_state_store.DoCommand.md
@@ -1,4 +1,4 @@
 Execute model-specific commands that are not otherwise defined by the service API.
 Most models do not implement `DoCommand`.
 Any available model-specific commands should be covered in the model's documentation.
-If you are implementing your own vision service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/dev/reference/sdks/docommand/).
+If you are implementing your own vision service and want to add features that have no corresponding built-in API method, you can implement them with [`DoCommand`](/reference/sdks/docommand/).
diff --git a/static/what-is-viam-technical.svg b/static/what-is-viam-technical.svg
new file mode 100644
index 0000000000..6679912997
--- /dev/null
+++ b/static/what-is-viam-technical.svg
@@ -0,0 +1,172 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 693 570" font-family="'Inter', 'Helvetica Neue', Arial, sans-serif">
+  <defs>
+    <style>
+      .layer-label { font-size: 11px; font-weight: 600; letter-spacing: 0.05em; text-transform: uppercase; }
+      .box-label { font-size: 13px; font-weight: 600; }
+      .arrow-label { font-size: 10px; font-style: italic; }
+    </style>
+  </defs>
+
+  <!-- ==================== YOUR CODE SDK (left side) ==================== -->
+  <rect x="0" y="102" width="110" height="175" rx="6" fill="#fff" stroke="#e0e0e0" stroke-width="1.5"/>
+  <text x="55" y="122" text-anchor="middle" class="box-label" fill="#252525">Code Anywhere</text>
+  <line x1="10" y1="130" x2="100" y2="130" stroke="#e0e0e0" stroke-width="0.5"/>
+  <text x="55" y="148" text-anchor="middle" style="font-size:10px; fill:#808080">write code, test,</text>
+  <text x="55" y="164" text-anchor="middle" style="font-size:10px; fill:#808080">and debug from</text>
+  <text x="55" y="180" text-anchor="middle" style="font-size:10px; fill:#808080">any computer</text>
+  <line x1="10" y1="190" x2="100" y2="190" stroke="#e0e0e0" stroke-width="0.5"/>
+  <text x="55" y="208" text-anchor="middle" style="font-size:10px; fill:#808080">execute against</text>
+  <text x="55" y="224" text-anchor="middle" style="font-size:10px; fill:#808080">your robot remotely</text>
+  <line x1="10" y1="234" x2="100" y2="234" stroke="#e0e0e0" stroke-width="0.5"/>
+  <text x="55" y="252" text-anchor="middle" style="font-size:10px; fill:#808080">Python · Go</text>
+  <text x="55" y="268" text-anchor="middle" style="font-size:10px; fill:#808080">TS · C++ · Flutter</text>
+
+  <!-- Arrow from SDK top, curving right to app.viam.com -->
+  <path d="M55,102 L55,67 Q55,52 70,52 L120,52" fill="none" stroke="#252525" stroke-width="1.2"/>
+  <polygon points="117,48 126,52 117,56" fill="#252525"/>
+  <text x="85" y="30" text-anchor="middle" style="font-size:10px; fill:#252525">WebRTC signaling</text>
+
+  <!-- Arrow from SDK bottom, curving right to YOUR MACHINE -->
+  <path d="M55,277 L55,282 Q55,297 70,297 L120,297" fill="none" stroke="#252525" stroke-width="1.2"/>
+  <polygon points="117,293 126,297 117,301" fill="#252525"/>
+  <text x="88" y="320" text-anchor="middle" style="font-size:10px; fill:#252525">WebRTC / gRPC</text>
+
+  <!-- ==================== CLOUD LAYER ==================== -->
+  <rect x="130" y="2" width="558" height="105" rx="6" fill="#f7f6f3" stroke="#252525" stroke-width="1.5"/>
+  <text x="147" y="24" class="layer-label" fill="#252525">app.viam.com</text>
+
+  <!-- Cloud boxes -->
+  <rect x="142" y="34" width="105" height="60" rx="4" fill="#fff" stroke="#e0e0e0" stroke-width="1"/>
+  <text x="194.5" y="54" text-anchor="middle" class="box-label" fill="#252525">Registry</text>
+  <text x="194.5" y="70" text-anchor="middle" style="font-size:10px; fill:#808080">modules · models</text>
+  <text x="194.5" y="84" text-anchor="middle" style="font-size:10px; fill:#808080">training scripts</text>
+
+  <rect x="255" y="34" width="85" height="60" rx="4" fill="#fff" stroke="#e0e0e0" stroke-width="1"/>
+  <text x="297.5" y="54" text-anchor="middle" class="box-label" fill="#252525">Data</text>
+  <text x="297.5" y="70" text-anchor="middle" style="font-size:10px; fill:#808080">storage · query</text>
+  <text x="297.5" y="84" text-anchor="middle" style="font-size:10px; fill:#808080">export</text>
+
+  <rect x="348" y="34" width="85" height="60" rx="4" fill="#fff" stroke="#e0e0e0" stroke-width="1"/>
+  <text x="390.5" y="54" text-anchor="middle" class="box-label" fill="#252525">ML</text>
+  <text x="390.5" y="70" text-anchor="middle" style="font-size:10px; fill:#808080">datasets · training</text>
+  <text x="390.5" y="84" text-anchor="middle" style="font-size:10px; fill:#808080">models</text>
+
+  <rect x="441" y="34" width="125" height="60" rx="4" fill="#fff" stroke="#e0e0e0" stroke-width="1"/>
+  <text x="503.5" y="54" text-anchor="middle" class="box-label" fill="#252525">Fleet Management</text>
+  <text x="503.5" y="70" text-anchor="middle" style="font-size:10px; fill:#808080">config · deploys</text>
+  <text x="503.5" y="84" text-anchor="middle" style="font-size:10px; fill:#808080">monitoring</text>
+
+  <rect x="574" y="34" width="102" height="60" rx="4" fill="#fff" stroke="#e0e0e0" stroke-width="1"/>
+  <text x="625" y="54" text-anchor="middle" class="box-label" fill="#252525">Apps</text>
+  <text x="625" y="70" text-anchor="middle" style="font-size:10px; fill:#808080">auth · billing</text>
+  <text x="625" y="84" text-anchor="middle" style="font-size:10px; fill:#808080">dashboards</text>
+
+  <!-- ==================== ARROWS: Cloud ↔ Machine ==================== -->
+  <line x1="319" y1="112" x2="319" y2="138" stroke="#252525" stroke-width="1.2" stroke-dasharray="4,3"/>
+  <polygon points="315,136 319,143 323,136" fill="#252525"/>
+  <text x="331" y="130" class="arrow-label" fill="#252525">config · modules · ML models</text>
+
+  <line x1="499" y1="143" x2="499" y2="117" stroke="#252525" stroke-width="1.2" stroke-dasharray="4,3"/>
+  <polygon points="495,119 499,112 503,119" fill="#252525"/>
+  <text x="511" y="130" class="arrow-label" fill="#252525">data · logs · machine status</text>
+
+  <!-- ==================== YOUR MACHINE boundary ==================== -->
+  <rect x="130" y="145" width="558" height="415" rx="10" fill="none" stroke="#252525" stroke-width="1.5"/>
+  <text x="147" y="165" style="font-size:13px; font-weight:700; fill:#252525; letter-spacing:0.03em">YOUR ROBOT</text>
+
+  <!-- ==================== COMPUTE LAYER ==================== -->
+  <rect x="138" y="175" width="542" height="250" rx="6" fill="#fff" stroke="#e0e0e0" stroke-width="1.5"/>
+  <text x="155" y="197" class="layer-label" fill="#252525">Compute</text>
+
+  <!-- viam-agent container -->
+  <rect x="146" y="207" width="526" height="208" rx="5" fill="#f7f6f3" stroke="#d0d0d0" stroke-width="1"/>
+  <rect x="154" y="213" width="90" height="20" rx="10" fill="#252525"/>
+  <text x="199" y="227" text-anchor="middle" style="font-size:10px; font-weight:600; fill:#fff">viam-agent</text>
+  <text x="258" y="227" style="font-size:10px; fill:#808080">first-boot setup · networking · supervises viam-server</text>
+
+  <!-- viam-server container -->
+  <rect x="154" y="240" width="510" height="167" rx="4" fill="#fff" stroke="#d0d0d0" stroke-width="1"/>
+  <rect x="162" y="246" width="96" height="20" rx="10" fill="#252525"/>
+  <text x="210" y="260" text-anchor="middle" style="font-size:10px; font-weight:600; fill:#fff">viam-server</text>
+  <text x="272" y="260" style="font-size:10px; fill:#808080">applies config updates · manages modules</text>
+
+  <!-- Hardware Drivers: 110px wide -->
+  <rect x="159" y="274" width="110" height="123" rx="4" fill="#f7f6f3" stroke="#e0e0e0" stroke-width="1"/>
+  <text x="214" y="294" text-anchor="middle" class="box-label" fill="#252525">Hardware</text>
+  <text x="214" y="308" text-anchor="middle" class="box-label" fill="#252525">Drivers</text>
+  <line x1="169" y1="316" x2="259" y2="316" stroke="#e0e0e0" stroke-width="0.5"/>
+  <text x="214" y="334" text-anchor="middle" style="font-size:10px; fill:#808080">camera · motor</text>
+  <text x="214" y="350" text-anchor="middle" style="font-size:10px; fill:#808080">arm · sensor</text>
+  <text x="214" y="366" text-anchor="middle" style="font-size:10px; fill:#808080">board · base ...</text>
+  <text x="214" y="390" text-anchor="middle" style="font-size:9px; fill:#808080; font-style:italic">modules from Registry</text>
+
+  <!-- Built-in Services: 122px wide -->
+  <rect x="277" y="274" width="122" height="123" rx="4" fill="#f7f6f3" stroke="#e0e0e0" stroke-width="1"/>
+  <text x="338" y="294" text-anchor="middle" class="box-label" fill="#252525">Built-in</text>
+  <text x="338" y="308" text-anchor="middle" class="box-label" fill="#252525">Services</text>
+  <line x1="287" y1="316" x2="389" y2="316" stroke="#e0e0e0" stroke-width="0.5"/>
+  <text x="338" y="334" text-anchor="middle" style="font-size:10px; fill:#808080">data capture &amp; sync</text>
+  <text x="338" y="350" text-anchor="middle" style="font-size:10px; fill:#808080">motion planning</text>
+  <text x="338" y="366" text-anchor="middle" style="font-size:10px; fill:#808080">computer vision</text>
+  <text x="338" y="390" text-anchor="middle" style="font-size:9px; fill:#808080; font-style:italic">shipped with viam-server</text>
+
+  <!-- Software Integrations: 122px wide -->
+  <rect x="407" y="274" width="122" height="123" rx="4" fill="#f7f6f3" stroke="#e0e0e0" stroke-width="1"/>
+  <text x="468" y="294" text-anchor="middle" class="box-label" fill="#252525">Software</text>
+  <text x="468" y="308" text-anchor="middle" class="box-label" fill="#252525">Integrations</text>
+  <line x1="417" y1="316" x2="519" y2="316" stroke="#e0e0e0" stroke-width="0.5"/>
+  <text x="468" y="338" text-anchor="middle" style="font-size:10px; fill:#808080">software for a wide</text>
+  <text x="468" y="354" text-anchor="middle" style="font-size:10px; fill:#808080">variety of automation</text>
+  <text x="468" y="370" text-anchor="middle" style="font-size:10px; fill:#808080">applications</text>
+  <text x="468" y="390" text-anchor="middle" style="font-size:9px; fill:#808080; font-style:italic">modules from Registry</text>
+
+  <!-- Your Code (Modules): 122px wide -->
+  <rect x="537" y="274" width="122" height="123" rx="4" fill="#f7f6f3" stroke="#e0e0e0" stroke-width="1"/>
+  <text x="598" y="294" text-anchor="middle" class="box-label" fill="#252525">Your Code</text>
+  <text x="598" y="308" text-anchor="middle" class="box-label" fill="#252525">(as Modules)</text>
+  <line x1="547" y1="316" x2="649" y2="316" stroke="#e0e0e0" stroke-width="0.5"/>
+  <text x="598" y="334" text-anchor="middle" style="font-size:10px; fill:#808080">control logic</text>
+  <text x="598" y="350" text-anchor="middle" style="font-size:10px; fill:#808080">custom drivers</text>
+  <text x="598" y="366" text-anchor="middle" style="font-size:10px; fill:#808080">business logic</text>
+  <text x="598" y="390" text-anchor="middle" style="font-size:9px; fill:#808080; font-style:italic">deploy via Registry</text>
+
+  <!-- ==================== ARROWS: Compute ↔ Peripherals ==================== -->
+  <line x1="420" y1="428" x2="420" y2="465" stroke="#252525" stroke-width="1.2"/>
+  <polygon points="416,461 420,469 424,461" fill="#252525"/>
+  <text x="432" y="442" style="font-size:10px; fill:#808080">USB · GPIO · Ethernet · Serial · CAN</text>
+  <text x="432" y="456" class="arrow-label" fill="#252525">consistent APIs across all</text>
+
+  <!-- ==================== HARDWARE LAYER ==================== -->
+  <rect x="138" y="470" width="542" height="80" rx="6" fill="#fff" stroke="#d0d0d0" stroke-width="1.5"/>
+  <text x="155" y="490" class="layer-label" fill="#252525">Hardware</text>
+
+  <!-- Hardware items: left-aligned with HARDWARE label -->
+  <g transform="translate(155, 498)">
+    <rect width="72" height="36" rx="4" fill="#f7f6f3" stroke="#d0d0d0" stroke-width="1"/>
+    <text x="36" y="22" text-anchor="middle" style="font-size:11px; fill:#252525">Cameras</text>
+  </g>
+  <g transform="translate(233, 498)">
+    <rect width="68" height="36" rx="4" fill="#f7f6f3" stroke="#d0d0d0" stroke-width="1"/>
+    <text x="34" y="22" text-anchor="middle" style="font-size:11px; fill:#252525">Motors</text>
+  </g>
+  <g transform="translate(307, 498)">
+    <rect width="60" height="36" rx="4" fill="#f7f6f3" stroke="#d0d0d0" stroke-width="1"/>
+    <text x="30" y="22" text-anchor="middle" style="font-size:11px; fill:#252525">Arms</text>
+  </g>
+  <g transform="translate(373, 498)">
+    <rect width="72" height="36" rx="4" fill="#f7f6f3" stroke="#d0d0d0" stroke-width="1"/>
+    <text x="36" y="22" text-anchor="middle" style="font-size:11px; fill:#252525">Sensors</text>
+  </g>
+  <g transform="translate(451, 498)">
+    <rect width="68" height="36" rx="4" fill="#f7f6f3" stroke="#d0d0d0" stroke-width="1"/>
+    <text x="34" y="22" text-anchor="middle" style="font-size:11px; fill:#252525">Boards</text>
+  </g>
+  <g transform="translate(525, 498)">
+    <rect width="75" height="36" rx="4" fill="#f7f6f3" stroke="#d0d0d0" stroke-width="1"/>
+    <text x="37" y="22" text-anchor="middle" style="font-size:11px; fill:#252525">Grippers</text>
+  </g>
+  <g transform="translate(606, 498)">
+    <rect width="60" height="36" rx="4" fill="#f7f6f3" stroke="#808080" stroke-width="1" stroke-dasharray="4,2"/>
+    <text x="30" y="22" text-anchor="middle" style="font-size:11px; fill:#808080">More</text>
+  </g>
+</svg>