diff --git a/src/extension.ts b/src/extension.ts
index 2703e1c..3ec7dc1 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -12,6 +12,7 @@
 import { LoggingViewProvider } from './logging/view_provider';
 import { ToolFinder } from './tool_finder';
 import { Ffx } from './ffx';
+import { Fx } from './fx';
 import * as logger from './logger';
 import { TargetStatusBarItem } from './target_status_bar_item';
 import { FuchsiaDevice } from './ffx';
@@ -29,10 +30,15 @@
    */
   ffx: Ffx;
 
-  constructor(ctx: vscode.ExtensionContext) {
+  /**
+   * a handle to interact with fx
+   */
+  fx: Fx;
 
+  constructor(ctx: vscode.ExtensionContext) {
     const toolFinder = new ToolFinder();
     this.ffx = toolFinder.ffx;
+    this.fx = toolFinder.fx;
   }
 }
 
diff --git a/src/ffx.ts b/src/ffx.ts
index 87f2662..2a54728 100644
--- a/src/ffx.ts
+++ b/src/ffx.ts
@@ -8,6 +8,7 @@
 // @ts-ignore: no @types/jsonparse available.
 import JsonParser from 'jsonparse';
 import { ToolFinder } from './tool_finder';
+import { JsonStreamProcess } from './process';
 
 /**
  * FuchsiaDevice represents the object returned from `ffx target list`.
@@ -531,44 +532,3 @@
 }
 
 export type FfxLog = JsonStreamProcess;
-
-/**
- * A stream of JSON Data coming from a process.
- */
-export class JsonStreamProcess {
-  private parser: JsonParser;
-
-  constructor(
-    private process: ChildProcessWithoutNullStreams | undefined,
-    private onData: (data: Object) => void,
-    private onError: (data: string) => void,
-  ) {
-    this.parser = new JsonParser();
-    this.process?.stdout.on('data', (chunk) => {
-      this.parser.write(chunk);
-    });
-    this.process?.stderr.on('data', this.onError);
-    let self = this;
-    this.parser.onValue = function (value: Object) {
-      if (this.stack.length === 0) {
-        self.onData(value);
-      }
-    };
-  }
-
-  /**
-   * Kills the underlying process and all its children.
-   */
-  public stop() {
-    const pid = this.process?.pid;
-    if (pid) {
-      try {
-        // This handles the in-tree use case where `ffx` launches a subprocess `fx ffx`.
-        process.kill(-pid);
-      } catch {
-        // If the process with the given `pid` didn't exist, this error will rise, which we can
-        // just swallow.
-      }
-    }
-  }
-}
diff --git a/src/fx.ts b/src/fx.ts
new file mode 100644
index 0000000..4f726fa
--- /dev/null
+++ b/src/fx.ts
@@ -0,0 +1,32 @@
+// Copyright 2024 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import { ChildProcessWithoutNullStreams, spawn } from 'child_process';
+import { DataStreamProcess } from './process';
+
+export class Fx {
+  constructor(public fuchsiaDir: string | undefined) {
+  }
+
+  public runStreaming(args: string[]): ChildProcessWithoutNullStreams | undefined {
+    if (!this.fuchsiaDir) {
+      return;
+    }
+    let env = { ...process.env };
+    env['PATH'] = `${this.fuchsiaDir}/.jiri_root/bin:${env.PATH}`;
+    const options = { detached: true, cwd: this.fuchsiaDir, env };
+    return spawn('fx', args, options);
+  }
+
+  public runAsync(
+    args: string[],
+    onData: (data: Buffer) => void,
+    onError: (data: Buffer) => void): DataStreamProcess | undefined {
+    const process = this.runStreaming(args);
+    if (!process) {
+      return;
+    }
+    return new DataStreamProcess(process, onData, onError);
+  }
+}
diff --git a/src/process.ts b/src/process.ts
new file mode 100644
index 0000000..e7d19f1
--- /dev/null
+++ b/src/process.ts
@@ -0,0 +1,81 @@
+// Copyright 2024 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import { ChildProcessWithoutNullStreams } from 'child_process';
+// @ts-ignore: no @types/jsonparse available.
+import JsonParser from 'jsonparse';
+
+/**
+ * A stream of Data coming from a process.
+ */
+export class DataStreamProcess {
+  constructor(
+    private process: ChildProcessWithoutNullStreams,
+    onData: (data: Buffer) => void,
+    onError: (data: Buffer) => void,
+  ) {
+    this.process.stdout.on('data', onData);
+    this.process.stderr.on('data', onError);
+  }
+
+  /**
+   * A future that resolves when the process exits.
+   */
+  public get exitCode(): Promise<number | null> {
+    return new Promise(resolve => {
+      this.process.on('exit', resolve);
+    });
+  }
+
+  /**
+   * Kills the underlying process and all its children.
+   */
+  public stop() {
+    const pid = this.process?.pid;
+    if (pid) {
+      try {
+        // This handles the in-tree use case where `ffx` launches a subprocess `fx ffx`.
+        process.kill(-pid);
+      } catch {
+        // If the process with the given `pid` didn't exist, this error will rise, which we can
+        // just swallow.
+      }
+    }
+  }
+}
+
+/**
+ * A stream of JSON Data coming from a process.
+ */
+export class JsonStreamProcess {
+  private process: DataStreamProcess | undefined;
+  private parser: JsonParser;
+
+  constructor(
+    process: ChildProcessWithoutNullStreams | undefined,
+    private onData: (data: Object) => void,
+    onError: (data: Buffer) => void,
+  ) {
+    this.parser = new JsonParser();
+    if (process) {
+      this.process = new DataStreamProcess(process, (chunk) => {
+        this.parser.write(chunk);
+      }, onError);
+
+    }
+    let self = this;
+    this.parser.onValue = function (value: Object) {
+      if (this.stack.length === 0) {
+        self.onData(value);
+      }
+    };
+  }
+
+  /**
+   * Kills the underlying process and all its children.
+   */
+  public stop() {
+    this.process?.stop();
+  }
+}
diff --git a/src/test/suite/logging/view_provider.test.ts b/src/test/suite/logging/view_provider.test.ts
index f190d8f..edb531f 100644
--- a/src/test/suite/logging/view_provider.test.ts
+++ b/src/test/suite/logging/view_provider.test.ts
@@ -9,7 +9,8 @@
 import { createSandbox, SinonSandbox, SinonStubbedInstance } from 'sinon';
 
 import { LoggingViewProvider, TOGGLE_LOG_VIEW_COMMAND } from '../../../logging/view_provider';
-import { Ffx, FuchsiaDevice, JsonStreamProcess } from '../../../ffx';
+import { Ffx, FuchsiaDevice } from '../../../ffx';
+import { JsonStreamProcess } from '../../../process';
 import { StubbedSpawn } from '../utils';
 import { ChildProcessWithoutNullStreams } from 'child_process';
 
diff --git a/src/testing/controller.ts b/src/testing/controller.ts
index 86f89b2..82da7cb 100644
--- a/src/testing/controller.ts
+++ b/src/testing/controller.ts
@@ -8,6 +8,7 @@
   TestItem,
 } from 'vscode';
 import { Setup } from '../extension';
+import { Fx } from '../fx';
 
 /**
  * register the test controller and related commands
@@ -21,14 +22,20 @@
       await discoverTests(controller);
     }
   };
+
+  controller.createRunProfile(
+    'Run',
+    vscode.TestRunProfileKind.Run,
+    (request, token) => {
+      void runTest(controller, setup.fx, request, token);
+    }
+  );
 }
 
 class FuchsiaTestData {
   constructor(
     readonly label: string,
     readonly name: string,
-    readonly packageLabel: string,
-    readonly packageUrl: string,
   ) { }
 
   get prettyName() {
@@ -45,10 +52,6 @@
     return prettyName;
   }
 
-  get uri() {
-    return vscode.Uri.parse(this.packageUrl);
-  }
-
   static fromJSON(object: any): FuchsiaTestData | null {
     const label = object['label'];
     if (typeof label !== 'string') {
@@ -58,25 +61,11 @@
     if (typeof name !== 'string') {
       return null;
     }
-    const packageLabel = object['package_label'];
-    if (typeof packageLabel !== 'string') {
-      return null;
-    }
-    const packageUrl = object['package_url'];
-    if (typeof packageUrl !== 'string') {
-      return null;
-    }
-    return new FuchsiaTestData(label, name, packageLabel, packageUrl);
+    return new FuchsiaTestData(label, name);
   }
 }
 
 /**
- * test data associated with each test item
- * The VS Code docs recommend this approach rather than trying to subclass TestItem.
- */
-const testDataMap = new WeakMap<vscode.TestItem, FuchsiaTestData>();
-
-/**
  * search the workspace for Fuchsia tests
  * We look at the `.fx-build-dir` file to find the build directory. Inside the build
  * directory, we look for the `tests.json` file.
@@ -88,7 +77,13 @@
 
   return await Promise.all(
     vscode.workspace.workspaceFolders.map(async (workspaceFolder: vscode.WorkspaceFolder) => {
+      /**
+       * read test items from the given test.json file.
+       */
       async function scanTestsJson(uri: vscode.Uri) {
+        // Remove the old items.
+        controller.items.forEach(item => controller.items.delete(item.id));
+
         const bytes = await vscode.workspace.fs.readFile(uri);
         const content = new TextDecoder().decode(bytes);
         const tests = JSON.parse(content);
@@ -104,13 +99,15 @@
           if (controller.items.get(testData.name)) {
             continue;
           }
-          const testItem = controller.createTestItem(testData.name, testData.prettyName,
-            testData.uri);
-          testDataMap.set(testItem, testData);
+          // TODO: Compute the URI of the test from the test label and the workspace folder.
+          const testItem = controller.createTestItem(testData.name, testData.prettyName);
           controller.items.add(testItem);
         }
       }
 
+      /**
+       * watch for a tests.json file in the given build directory.
+       */
       async function scanBuildDir(uri: vscode.Uri) {
         const bytes = await vscode.workspace.fs.readFile(uri);
         const content = new TextDecoder().decode(bytes).trim();
@@ -136,3 +133,80 @@
     })
   );
 }
+
+/**
+ * convert a TestItemCollection into an Iterable<vscode.TestItem>
+ */
+function gatherTestItems(collection: vscode.TestItemCollection): Iterable<vscode.TestItem> {
+  const items: vscode.TestItem[] = [];
+  collection.forEach(item => items.push(item));
+  return items;
+}
+
+/**
+ * prepare the given buffer for display in the test results terminal
+ */
+function formatForTerminal(buffer: Buffer) {
+  let string = new TextDecoder().decode(buffer);
+  return string.replace(/\n/g, '\r\n').replace(/\r\r\n/g, '\r\n');
+}
+
+/**
+ * run the given tests
+ */
+async function runTest(
+  controller: TestController,
+  fx: Fx,
+  request: vscode.TestRunRequest,
+  token: vscode.CancellationToken
+) {
+  const run = controller.createTestRun(request);
+  try {
+    const queue: TestItem[] = [];
+    for (const testItem of request.include ?? gatherTestItems(controller.items)) {
+      if (request.exclude?.includes(testItem)) {
+        continue;
+      }
+      queue.push(testItem);
+      run.enqueued(testItem);
+    }
+
+    /**
+     * append the given buffer to the output for the current test run
+     */
+    function handleOutput(buffer: Buffer) {
+      run.appendOutput(formatForTerminal(buffer));
+    }
+
+    for (const testItem of queue) {
+      run.started(testItem);
+
+      const args = ['test', '--style', '--no-status', '--output', testItem.id];
+      const prettyArgs = `fx ${args.join(' ')}`;
+
+      run.appendOutput(`Running: \x1b[1m${prettyArgs}\x1b[0m\r\n`);
+
+      const testProcess = fx.runAsync(args, handleOutput, handleOutput);
+      if (!testProcess) {
+        const message = new vscode.TestMessage(`Cannot start '${prettyArgs}'`);
+        run.errored(testItem, message);
+        continue;
+      }
+
+      const exitCode = await testProcess.exitCode;
+      if (exitCode === 0) {
+        run.passed(testItem);
+      } else {
+        let message: vscode.TestMessage;
+        if (typeof exitCode === 'number') {
+          message = new vscode.TestMessage(`'${prettyArgs}' exited with code ${exitCode}.`);
+        } else {
+          message = new vscode.TestMessage(`'${prettyArgs}' terminated unexpectedly.`);
+        }
+        run.failed(testItem, message);
+      }
+    }
+  } finally {
+    run.end();
+  }
+}
diff --git a/src/tool_finder.ts b/src/tool_finder.ts
index c2e8c7b..d27e4f5 100644
--- a/src/tool_finder.ts
+++ b/src/tool_finder.ts
@@ -8,6 +8,7 @@
 import * as logger from './logger';
 import * as path from 'path';
 import { Ffx } from './ffx';
+import { Fx } from './fx';
 
 const CONFIG_ROOT_NAME = 'fuchsia';
 
@@ -18,6 +19,7 @@
 export class ToolFinder {
   private ffxPathInternal: string | undefined;
   private ffxInternal: Ffx;
+  private fxInternal: Fx;
   private readonly onDidUpdateFfxEmitter = new vscode.EventEmitter<{ isInitial: boolean }>();
 
   /**
@@ -30,6 +32,7 @@
   constructor() {
     const cwd = vscode.workspace.workspaceFolders?.map(folder => folder.uri.path)[0];
     this.ffxInternal = new Ffx(cwd, undefined, this);
+    this.fxInternal = new Fx(cwd);
     this.updateFfxPath(true).catch((err) => logger.error('unable to configure initial ffx location', undefined, err));
     vscode.workspace.onDidChangeConfiguration(event => {
       if (event.affectsConfiguration(`${CONFIG_ROOT_NAME}.ffxPath`)) {
@@ -47,6 +50,14 @@
   }
 
   /**
+   * Get the single Fx class instance.
+   * @returns Fx class instance or null of this workspace does not support fx.
+   */
+  public get fx(): Fx {
+    return this.fxInternal;
+  }
+
+  /**
    * For testing: get the path of the ffx binary.
    * @returns the path to the ffx binary.
    */
@@ -85,18 +96,18 @@
   }
 
   /**
-   * Tests if the ffx path exists and if it's an executable.
+   * Tests if the tool path exists and if it's an executable.
    *
-   * @param ffxPath absolute path to the ffx binary.
+   * @param toolPath absolute path to the ffx binary.
    *
    * @throws error if this test fails.
    */
-  async validateFfxPath(ffxPath: string) {
-    if (!(await fs.promises.stat(ffxPath)).isFile()) {
-      throw new Error(`The path for ffx is not a file. path = "${ffxPath}".`);
+  async validateToolPath(toolPath: string) {
+    if (!(await fs.promises.stat(toolPath)).isFile()) {
+      throw new Error(`The path for ffx is not a file. path = "${toolPath}".`);
     }
     // Check if ffx is executable. This has no effect on Windows.
-    await fs.promises.access(ffxPath, fs.constants.X_OK);
+    await fs.promises.access(toolPath, fs.constants.X_OK);
   }
 
   // TODO(fxbug.dev/98459): Handle searching multiple workspace folders.
@@ -115,7 +126,7 @@
     for (const ffxPath of ffxPaths) {
       const fullFfxPath = path.join(workspacePath, ffxPath);
       try {
-        await this.validateFfxPath(fullFfxPath);
+        await this.validateToolPath(fullFfxPath);
         return ffxPath;
       } catch (err) {
         if (err instanceof Error) {
@@ -126,6 +137,17 @@
     throw new Error('Ffx could not be found.');
   }
 
+  async isFuchsiaDir(workspacePath: string): Promise<boolean> {
+    try {
+      const fxPath = path.join('.jiri_root', 'bin', 'fx');
+      const fullFxPath = path.join(workspacePath, fxPath);
+      await this.validateToolPath(fullFxPath);
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+
   /**
    * Update the ffx binary path. This method is generally called when initializing, or when the
    * configuration path settings have changed.
@@ -139,8 +161,13 @@
         throw new Error('Could not get the ffxPath configuration.');
       }
 
-      let ffxPath = '';
+      if (workspacePath && await this.isFuchsiaDir(workspacePath)) {
+        this.fxInternal.fuchsiaDir = workspacePath;
+      } else {
+        this.fxInternal.fuchsiaDir = undefined;
+      }
 
+      let ffxPath = '';
       if (configFfxPath.length === 0) {
         ffxPath = await this.findFfxPath(workspacePath);
         // don't update here -- it's unexpected to change the user's configuration for them, and it
@@ -153,7 +180,7 @@
       }
 
       ffxPath = this.resolveAbsolutePath(ffxPath, workspacePath);
-      await this.validateFfxPath(ffxPath);
+      await this.validateToolPath(ffxPath);
 
       this.ffxPathInternal = ffxPath;
     } catch (err) {