diff --git a/README.md b/README.md
index 590458a..1fb21f0 100644
--- a/README.md
+++ b/README.md
@@ -241,6 +241,50 @@ Create an API key from the [Kernel dashboard](https://dashboard.onkernel.com).
 
 - `kernel browsers extensions upload <id or persistent id> <extension-path>...` - Ad-hoc upload of one or more unpacked extensions to a running browser instance.
 
+### Browser Computer Controls
+
+- `kernel browsers computer click-mouse <id or persistent id>` - Click mouse at coordinates
+  - `--x <coordinate>` - X coordinate (required)
+  - `--y <coordinate>` - Y coordinate (required)
+  - `--num-clicks <n>` - Number of clicks (default: 1)
+  - `--button <button>` - Mouse button: left, right, middle, back, forward (default: left)
+  - `--click-type <type>` - Click type: down, up, click (default: click)
+  - `--hold-key <key>` - Modifier keys to hold (repeatable)
+- `kernel browsers computer move-mouse <id or persistent id>` - Move mouse to coordinates
+  - `--x <coordinate>` - X coordinate (required)
+  - `--y <coordinate>` - Y coordinate (required)
+  - `--hold-key <key>` - Modifier keys to hold (repeatable)
+- `kernel browsers computer screenshot <id or persistent id>` - Capture a screenshot
+  - `--to <path>` - Output file path for the PNG image (required)
+  - `--x <coordinate>` - Top-left X for region capture (optional)
+  - `--y <coordinate>` - Top-left Y for region capture (optional)
+  - `--width <pixels>` - Region width (optional)
+  - `--height <pixels>` - Region height (optional)
+- `kernel browsers computer type <id or persistent id>` - Type text on the browser instance
+
+  - `--text <text>` - Text to type (required)
+  - `--delay <ms>` - Delay in milliseconds between keystrokes (optional)
+
+- `kernel browsers computer press-key <id or persistent id>` - Press one or more keys
+
+  - `--key <key>` - Key symbols to press (repeatable)
+  - `--duration <ms>` - Duration to hold keys down in ms (0=tap)
+  - `--hold-key <key>` - Modifier keys to hold (repeatable)
+
+- `kernel browsers computer scroll <id or persistent id>` - Scroll the mouse wheel
+
+  - `--x <coordinate>` - X coordinate (required)
+  - `--y <coordinate>` - Y coordinate (required)
+  - `--delta-x <pixels>` - Horizontal scroll amount (+right, -left)
+  - `--delta-y <pixels>` - Vertical scroll amount (+down, -up)
+  - `--hold-key <key>` - Modifier keys to hold (repeatable)
+
+- `kernel browsers computer drag-mouse <id or persistent id>` - Drag the mouse along a path
+  - `--point <x,y>` - Add a point as x,y (repeatable)
+  - `--delay <ms>` - Delay before dragging starts in ms
+  - `--button <button>` - Mouse button: left, middle, right (default: left)
+  - `--hold-key <key>` - Modifier keys to hold (repeatable)
+
 ### Extension Management
 
 - `kernel extensions list` - List all uploaded extensions
@@ -330,6 +374,27 @@ kernel browsers fs upload my-browser --file "local.txt:remote.txt" --dest-dir "/
 
 # List files in a directory
 kernel browsers fs list-files my-browser --path "/tmp"
+
+# Click the mouse at coordinates (100, 200)
+kernel browsers computer click-mouse my-browser --x 100 --y 200
+
+# Double-click the right mouse button
+kernel browsers computer click-mouse my-browser --x 100 --y 200 --num-clicks 2 --button right
+
+# Move the mouse to coordinates (500, 300)
+kernel browsers computer move-mouse my-browser --x 500 --y 300
+
+# Take a full screenshot
+kernel browsers computer screenshot my-browser --to screenshot.png
+
+# Take a screenshot of a specific region
+kernel browsers computer screenshot my-browser --to region.png --x 0 --y 0 --width 800 --height 600
+
+# Type text in the browser
+kernel browsers computer type my-browser --text "Hello, World!"
+
+# Type text with a 100ms delay between keystrokes
+kernel browsers computer type my-browser --text "Slow typing..." --delay 100
 ```
 
 ### Extension management
diff --git a/cmd/browsers.go b/cmd/browsers.go
index 12bd580..ece0aa0 100644
--- a/cmd/browsers.go
+++ b/cmd/browsers.go
@@ -73,6 +73,17 @@ type BrowserLogService interface {
 	StreamStreaming(ctx context.Context, id string, query kernel.BrowserLogStreamParams, opts ...option.RequestOption) (stream *ssestream.Stream[shared.LogEvent])
 }
 
+// BrowserComputerService defines the subset we use for OS-level mouse & screen.
+type BrowserComputerService interface {
+	CaptureScreenshot(ctx context.Context, id string, body kernel.BrowserComputerCaptureScreenshotParams, opts ...option.RequestOption) (res *http.Response, err error)
+	ClickMouse(ctx context.Context, id string, body kernel.BrowserComputerClickMouseParams, opts ...option.RequestOption) (err error)
+	DragMouse(ctx context.Context, id string, body kernel.BrowserComputerDragMouseParams, opts ...option.RequestOption) (err error)
+	MoveMouse(ctx context.Context, id string, body kernel.BrowserComputerMoveMouseParams, opts ...option.RequestOption) (err error)
+	PressKey(ctx context.Context, id string, body kernel.BrowserComputerPressKeyParams, opts ...option.RequestOption) (err error)
+	Scroll(ctx context.Context, id string, body kernel.BrowserComputerScrollParams, opts ...option.RequestOption) (err error)
+	TypeText(ctx context.Context, id string, body kernel.BrowserComputerTypeTextParams, opts ...option.RequestOption) (err error)
+}
+
 // BoolFlag captures whether a boolean flag was set explicitly and its value.
 type BoolFlag struct {
 	Set   bool
@@ -160,6 +171,7 @@ type BrowsersCmd struct {
 	fs       BrowserFSService
 	process  BrowserProcessService
 	logs     BrowserLogService
+	computer BrowserComputerService
 }
 
 type BrowsersListInput struct {
@@ -487,6 +499,290 @@ func (b BrowsersCmd) LogsStream(ctx context.Context, in BrowsersLogsStreamInput)
 	return nil
 }
 
+// Computer (mouse/screen)
+type BrowsersComputerClickMouseInput struct {
+	Identifier string
+	X          int64
+	Y          int64
+	NumClicks  int64
+	Button     string
+	ClickType  string
+	HoldKeys   []string
+}
+
+type BrowsersComputerMoveMouseInput struct {
+	Identifier string
+	X          int64
+	Y          int64
+	HoldKeys   []string
+}
+
+type BrowsersComputerScreenshotInput struct {
+	Identifier string
+	X          int64
+	Y          int64
+	Width      int64
+	Height     int64
+	To         string
+	HasRegion  bool
+}
+
+type BrowsersComputerTypeTextInput struct {
+	Identifier string
+	Text       string
+	Delay      int64
+}
+
+type BrowsersComputerPressKeyInput struct {
+	Identifier string
+	Keys       []string
+	Duration   int64
+	HoldKeys   []string
+}
+
+type BrowsersComputerScrollInput struct {
+	Identifier string
+	X          int64
+	Y          int64
+	DeltaX     int64
+	DeltaXSet  bool
+	DeltaY     int64
+	DeltaYSet  bool
+	HoldKeys   []string
+}
+
+type BrowsersComputerDragMouseInput struct {
+	Identifier      string
+	Path            [][]int64
+	Delay           int64
+	StepDelayMs     int64
+	StepsPerSegment int64
+	Button          string
+	HoldKeys        []string
+}
+
+func (b BrowsersCmd) ComputerClickMouse(ctx context.Context, in BrowsersComputerClickMouseInput) error {
+	if b.computer == nil {
+		pterm.Error.Println("computer service not available")
+		return nil
+	}
+	br, err := b.resolveBrowserByIdentifier(ctx, in.Identifier)
+	if err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	if br == nil {
+		pterm.Error.Printf("Browser '%s' not found\n", in.Identifier)
+		return nil
+	}
+	body := kernel.BrowserComputerClickMouseParams{X: in.X, Y: in.Y}
+	if in.NumClicks > 0 {
+		body.NumClicks = kernel.Opt(in.NumClicks)
+	}
+	if in.Button != "" {
+		body.Button = kernel.BrowserComputerClickMouseParamsButton(in.Button)
+	}
+	if in.ClickType != "" {
+		body.ClickType = kernel.BrowserComputerClickMouseParamsClickType(in.ClickType)
+	}
+	if len(in.HoldKeys) > 0 {
+		body.HoldKeys = in.HoldKeys
+	}
+	if err := b.computer.ClickMouse(ctx, br.SessionID, body); err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	pterm.Success.Printf("Clicked mouse at (%d,%d)\n", in.X, in.Y)
+	return nil
+}
+
+func (b BrowsersCmd) ComputerMoveMouse(ctx context.Context, in BrowsersComputerMoveMouseInput) error {
+	if b.computer == nil {
+		pterm.Error.Println("computer service not available")
+		return nil
+	}
+	br, err := b.resolveBrowserByIdentifier(ctx, in.Identifier)
+	if err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	if br == nil {
+		pterm.Error.Printf("Browser '%s' not found\n", in.Identifier)
+		return nil
+	}
+	body := kernel.BrowserComputerMoveMouseParams{X: in.X, Y: in.Y}
+	if len(in.HoldKeys) > 0 {
+		body.HoldKeys = in.HoldKeys
+	}
+	if err := b.computer.MoveMouse(ctx, br.SessionID, body); err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	pterm.Success.Printf("Moved mouse to (%d,%d)\n", in.X, in.Y)
+	return nil
+}
+
+func (b BrowsersCmd) ComputerScreenshot(ctx context.Context, in BrowsersComputerScreenshotInput) error {
+	if b.computer == nil {
+		pterm.Error.Println("computer service not available")
+		return nil
+	}
+	br, err := b.resolveBrowserByIdentifier(ctx, in.Identifier)
+	if err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	if br == nil {
+		pterm.Error.Printf("Browser '%s' not found\n", in.Identifier)
+		return nil
+	}
+	var body kernel.BrowserComputerCaptureScreenshotParams
+	if in.HasRegion {
+		body.Region = kernel.BrowserComputerCaptureScreenshotParamsRegion{X: in.X, Y: in.Y, Width: in.Width, Height: in.Height}
+	}
+	res, err := b.computer.CaptureScreenshot(ctx, br.SessionID, body)
+	if err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	defer res.Body.Close()
+	if in.To == "" {
+		pterm.Error.Println("--to is required to save the screenshot")
+		return nil
+	}
+	f, err := os.Create(in.To)
+	if err != nil {
+		pterm.Error.Printf("Failed to create file: %v\n", err)
+		return nil
+	}
+	defer f.Close()
+	if _, err := io.Copy(f, res.Body); err != nil {
+		pterm.Error.Printf("Failed to write file: %v\n", err)
+		return nil
+	}
+	pterm.Success.Printf("Saved screenshot to %s\n", in.To)
+	return nil
+}
+
+func (b BrowsersCmd) ComputerTypeText(ctx context.Context, in BrowsersComputerTypeTextInput) error {
+	if b.computer == nil {
+		pterm.Error.Println("computer service not available")
+		return nil
+	}
+	br, err := b.resolveBrowserByIdentifier(ctx, in.Identifier)
+	if err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	if br == nil {
+		pterm.Error.Printf("Browser '%s' not found\n", in.Identifier)
+		return nil
+	}
+	body := kernel.BrowserComputerTypeTextParams{Text: in.Text}
+	if in.Delay > 0 {
+		body.Delay = kernel.Opt(in.Delay)
+	}
+	if err := b.computer.TypeText(ctx, br.SessionID, body); err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	pterm.Success.Printf("Typed text: %s\n", in.Text)
+	return nil
+}
+
+func (b BrowsersCmd) ComputerPressKey(ctx context.Context, in BrowsersComputerPressKeyInput) error {
+	if b.computer == nil {
+		pterm.Error.Println("computer service not available")
+		return nil
+	}
+	br, err := b.resolveBrowserByIdentifier(ctx, in.Identifier)
+	if err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	if br == nil {
+		pterm.Error.Printf("Browser '%s' not found\n", in.Identifier)
+		return nil
+	}
+	if len(in.Keys) == 0 {
+		pterm.Error.Println("no keys specified")
+		return nil
+	}
+	body := kernel.BrowserComputerPressKeyParams{Keys: in.Keys}
+	if in.Duration > 0 {
+		body.Duration = kernel.Opt(in.Duration)
+	}
+	if len(in.HoldKeys) > 0 {
+		body.HoldKeys = in.HoldKeys
+	}
+	if err := b.computer.PressKey(ctx, br.SessionID, body); err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	pterm.Success.Printf("Pressed keys: %s\n", strings.Join(in.Keys, ","))
+	return nil
+}
+
+func (b BrowsersCmd) ComputerScroll(ctx context.Context, in BrowsersComputerScrollInput) error {
+	if b.computer == nil {
+		pterm.Error.Println("computer service not available")
+		return nil
+	}
+	br, err := b.resolveBrowserByIdentifier(ctx, in.Identifier)
+	if err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	if br == nil {
+		pterm.Error.Printf("Browser '%s' not found\n", in.Identifier)
+		return nil
+	}
+	body := kernel.BrowserComputerScrollParams{X: in.X, Y: in.Y}
+	if in.DeltaXSet {
+		body.DeltaX = kernel.Opt(in.DeltaX)
+	}
+	if in.DeltaYSet {
+		body.DeltaY = kernel.Opt(in.DeltaY)
+	}
+	if len(in.HoldKeys) > 0 {
+		body.HoldKeys = in.HoldKeys
+	}
+	if err := b.computer.Scroll(ctx, br.SessionID, body); err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	pterm.Success.Printf("Scrolled at (%d,%d)\n", in.X, in.Y)
+	return nil
+}
+
+func (b BrowsersCmd) ComputerDragMouse(ctx context.Context, in BrowsersComputerDragMouseInput) error {
+	if b.computer == nil {
+		pterm.Error.Println("computer service not available")
+		return nil
+	}
+	br, err := b.resolveBrowserByIdentifier(ctx, in.Identifier)
+	if err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	if br == nil {
+		pterm.Error.Printf("Browser '%s' not found\n", in.Identifier)
+		return nil
+	}
+	if len(in.Path) < 2 {
+		pterm.Error.Println("path must include at least two points")
+		return nil
+	}
+	body := kernel.BrowserComputerDragMouseParams{Path: in.Path}
+	if in.Delay > 0 {
+		body.Delay = kernel.Opt(in.Delay)
+	}
+	if in.StepDelayMs > 0 {
+		body.StepDelayMs = kernel.Opt(in.StepDelayMs)
+	}
+	if in.StepsPerSegment > 0 {
+		body.StepsPerSegment = kernel.Opt(in.StepsPerSegment)
+	}
+	if in.Button != "" {
+		body.Button = kernel.BrowserComputerDragMouseParamsButton(in.Button)
+	}
+	if len(in.HoldKeys) > 0 {
+		body.HoldKeys = in.HoldKeys
+	}
+	if err := b.computer.DragMouse(ctx, br.SessionID, body); err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	pterm.Success.Printf("Dragged mouse over %d points\n", len(in.Path))
+	return nil
+}
+
 // Replays
 type BrowsersReplaysListInput struct {
 	Identifier string
@@ -1541,6 +1837,67 @@ func init() {
 	extensionsRoot.AddCommand(extensionsUpload)
 	browsersCmd.AddCommand(extensionsRoot)
 
+	// computer
+	computerRoot := &cobra.Command{Use: "computer", Short: "OS-level mouse & screen controls"}
+	computerClick := &cobra.Command{Use: "click-mouse <id|persistent-id>", Short: "Click mouse at coordinates", Args: cobra.ExactArgs(1), RunE: runBrowsersComputerClickMouse}
+	computerClick.Flags().Int64("x", 0, "X coordinate")
+	computerClick.Flags().Int64("y", 0, "Y coordinate")
+	_ = computerClick.MarkFlagRequired("x")
+	_ = computerClick.MarkFlagRequired("y")
+	computerClick.Flags().Int64("num-clicks", 1, "Number of clicks")
+	computerClick.Flags().String("button", "left", "Mouse button: left,right,middle,back,forward")
+	computerClick.Flags().String("click-type", "click", "Click type: down,up,click")
+	computerClick.Flags().StringSlice("hold-key", []string{}, "Modifier keys to hold (repeatable)")
+
+	computerMove := &cobra.Command{Use: "move-mouse <id|persistent-id>", Short: "Move mouse to coordinates", Args: cobra.ExactArgs(1), RunE: runBrowsersComputerMoveMouse}
+	computerMove.Flags().Int64("x", 0, "X coordinate")
+	computerMove.Flags().Int64("y", 0, "Y coordinate")
+	_ = computerMove.MarkFlagRequired("x")
+	_ = computerMove.MarkFlagRequired("y")
+	computerMove.Flags().StringSlice("hold-key", []string{}, "Modifier keys to hold (repeatable)")
+
+	computerScreenshot := &cobra.Command{Use: "screenshot <id|persistent-id>", Short: "Capture a screenshot (optionally of a region)", Args: cobra.ExactArgs(1), RunE: runBrowsersComputerScreenshot}
+	computerScreenshot.Flags().Int64("x", 0, "Top-left X")
+	computerScreenshot.Flags().Int64("y", 0, "Top-left Y")
+	computerScreenshot.Flags().Int64("width", 0, "Region width")
+	computerScreenshot.Flags().Int64("height", 0, "Region height")
+	computerScreenshot.Flags().String("to", "", "Output file path for the PNG image")
+	_ = computerScreenshot.MarkFlagRequired("to")
+
+	computerType := &cobra.Command{Use: "type <id|persistent-id>", Short: "Type text on the browser instance", Args: cobra.ExactArgs(1), RunE: runBrowsersComputerTypeText}
+	computerType.Flags().String("text", "", "Text to type")
+	_ = computerType.MarkFlagRequired("text")
+	computerType.Flags().Int64("delay", 0, "Delay in milliseconds between keystrokes")
+
+	// computer press-key
+	computerPressKey := &cobra.Command{Use: "press-key <id|persistent-id>", Short: "Press one or more keys", Args: cobra.ExactArgs(1), RunE: runBrowsersComputerPressKey}
+	computerPressKey.Flags().StringSlice("key", []string{}, "Key symbols to press (repeatable)")
+	_ = computerPressKey.MarkFlagRequired("key")
+	computerPressKey.Flags().Int64("duration", 0, "Duration to hold keys down in ms (0=tap)")
+	computerPressKey.Flags().StringSlice("hold-key", []string{}, "Modifier keys to hold (repeatable)")
+
+	// computer scroll
+	computerScroll := &cobra.Command{Use: "scroll <id|persistent-id>", Short: "Scroll the mouse wheel", Args: cobra.ExactArgs(1), RunE: runBrowsersComputerScroll}
+	computerScroll.Flags().Int64("x", 0, "X coordinate")
+	computerScroll.Flags().Int64("y", 0, "Y coordinate")
+	_ = computerScroll.MarkFlagRequired("x")
+	_ = computerScroll.MarkFlagRequired("y")
+	computerScroll.Flags().Int64("delta-x", 0, "Horizontal scroll amount (+right, -left)")
+	computerScroll.Flags().Int64("delta-y", 0, "Vertical scroll amount (+down, -up)")
+	computerScroll.Flags().StringSlice("hold-key", []string{}, "Modifier keys to hold (repeatable)")
+
+	// computer drag-mouse
+	computerDrag := &cobra.Command{Use: "drag-mouse <id|persistent-id>", Short: "Drag the mouse along a path", Args: cobra.ExactArgs(1), RunE: runBrowsersComputerDragMouse}
+	computerDrag.Flags().StringArray("point", []string{}, "Add a point as x,y (repeatable)")
+	computerDrag.Flags().Int64("delay", 0, "Delay before dragging starts in ms")
+	computerDrag.Flags().Int64("step-delay-ms", 0, "Delay between steps while dragging (ms)")
+	computerDrag.Flags().Int64("steps-per-segment", 0, "Number of move steps per path segment")
+	computerDrag.Flags().String("button", "left", "Mouse button: left,middle,right")
+	computerDrag.Flags().StringSlice("hold-key", []string{}, "Modifier keys to hold (repeatable)")
+
+	computerRoot.AddCommand(computerClick, computerMove, computerScreenshot, computerType, computerPressKey, computerScroll, computerDrag)
+	browsersCmd.AddCommand(computerRoot)
+
 	// Add flags for create command
 	browsersCreateCmd.Flags().StringP("persistent-id", "p", "", "Unique identifier for browser session persistence")
 	browsersCreateCmd.Flags().BoolP("stealth", "s", false, "Launch browser in stealth mode to avoid detection")
@@ -1894,6 +2251,124 @@ func runBrowsersExtensionsUpload(cmd *cobra.Command, args []string) error {
 	return b.ExtensionsUpload(cmd.Context(), BrowsersExtensionsUploadInput{Identifier: args[0], ExtensionPaths: args[1:]})
 }
 
+func runBrowsersComputerClickMouse(cmd *cobra.Command, args []string) error {
+	client := getKernelClient(cmd)
+	svc := client.Browsers
+	x, _ := cmd.Flags().GetInt64("x")
+	y, _ := cmd.Flags().GetInt64("y")
+	numClicks, _ := cmd.Flags().GetInt64("num-clicks")
+	button, _ := cmd.Flags().GetString("button")
+	clickType, _ := cmd.Flags().GetString("click-type")
+	holdKeys, _ := cmd.Flags().GetStringSlice("hold-key")
+	b := BrowsersCmd{browsers: &svc, computer: &svc.Computer}
+	return b.ComputerClickMouse(cmd.Context(), BrowsersComputerClickMouseInput{Identifier: args[0], X: x, Y: y, NumClicks: numClicks, Button: button, ClickType: clickType, HoldKeys: holdKeys})
+}
+
+func runBrowsersComputerMoveMouse(cmd *cobra.Command, args []string) error {
+	client := getKernelClient(cmd)
+	svc := client.Browsers
+	x, _ := cmd.Flags().GetInt64("x")
+	y, _ := cmd.Flags().GetInt64("y")
+	holdKeys, _ := cmd.Flags().GetStringSlice("hold-key")
+	b := BrowsersCmd{browsers: &svc, computer: &svc.Computer}
+	return b.ComputerMoveMouse(cmd.Context(), BrowsersComputerMoveMouseInput{Identifier: args[0], X: x, Y: y, HoldKeys: holdKeys})
+}
+
+func runBrowsersComputerScreenshot(cmd *cobra.Command, args []string) error {
+	client := getKernelClient(cmd)
+	svc := client.Browsers
+	x, _ := cmd.Flags().GetInt64("x")
+	y, _ := cmd.Flags().GetInt64("y")
+	w, _ := cmd.Flags().GetInt64("width")
+	h, _ := cmd.Flags().GetInt64("height")
+	to, _ := cmd.Flags().GetString("to")
+	bx := cmd.Flags().Changed("x")
+	by := cmd.Flags().Changed("y")
+	bw := cmd.Flags().Changed("width")
+	bh := cmd.Flags().Changed("height")
+	useRegion := bx || by || bw || bh
+	if useRegion {
+		if !(bx && by && bw && bh) {
+			pterm.Error.Println("if specifying region, you must provide --x, --y, --width, and --height")
+			return nil
+		}
+		if w <= 0 || h <= 0 {
+			pterm.Error.Println("--width and --height must be greater than zero")
+			return nil
+		}
+	}
+	b := BrowsersCmd{browsers: &svc, computer: &svc.Computer}
+	return b.ComputerScreenshot(cmd.Context(), BrowsersComputerScreenshotInput{Identifier: args[0], X: x, Y: y, Width: w, Height: h, To: to, HasRegion: useRegion})
+}
+
+func runBrowsersComputerTypeText(cmd *cobra.Command, args []string) error {
+	client := getKernelClient(cmd)
+	svc := client.Browsers
+	text, _ := cmd.Flags().GetString("text")
+	delay, _ := cmd.Flags().GetInt64("delay")
+	b := BrowsersCmd{browsers: &svc, computer: &svc.Computer}
+	return b.ComputerTypeText(cmd.Context(), BrowsersComputerTypeTextInput{Identifier: args[0], Text: text, Delay: delay})
+}
+
+func runBrowsersComputerPressKey(cmd *cobra.Command, args []string) error {
+	client := getKernelClient(cmd)
+	svc := client.Browsers
+	keys, _ := cmd.Flags().GetStringSlice("key")
+	duration, _ := cmd.Flags().GetInt64("duration")
+	holdKeys, _ := cmd.Flags().GetStringSlice("hold-key")
+	b := BrowsersCmd{browsers: &svc, computer: &svc.Computer}
+	return b.ComputerPressKey(cmd.Context(), BrowsersComputerPressKeyInput{Identifier: args[0], Keys: keys, Duration: duration, HoldKeys: holdKeys})
+}
+
+func runBrowsersComputerScroll(cmd *cobra.Command, args []string) error {
+	client := getKernelClient(cmd)
+	svc := client.Browsers
+	x, _ := cmd.Flags().GetInt64("x")
+	y, _ := cmd.Flags().GetInt64("y")
+	dx, _ := cmd.Flags().GetInt64("delta-x")
+	dy, _ := cmd.Flags().GetInt64("delta-y")
+	dxSet := cmd.Flags().Changed("delta-x")
+	dySet := cmd.Flags().Changed("delta-y")
+	holdKeys, _ := cmd.Flags().GetStringSlice("hold-key")
+	b := BrowsersCmd{browsers: &svc, computer: &svc.Computer}
+	return b.ComputerScroll(cmd.Context(), BrowsersComputerScrollInput{Identifier: args[0], X: x, Y: y, DeltaX: dx, DeltaXSet: dxSet, DeltaY: dy, DeltaYSet: dySet, HoldKeys: holdKeys})
+}
+
+func runBrowsersComputerDragMouse(cmd *cobra.Command, args []string) error {
+	client := getKernelClient(cmd)
+	svc := client.Browsers
+	points, _ := cmd.Flags().GetStringArray("point")
+	delay, _ := cmd.Flags().GetInt64("delay")
+	stepDelayMs, _ := cmd.Flags().GetInt64("step-delay-ms")
+	stepsPerSegment, _ := cmd.Flags().GetInt64("steps-per-segment")
+	button, _ := cmd.Flags().GetString("button")
+	holdKeys, _ := cmd.Flags().GetStringSlice("hold-key")
+
+	// Parse points of form x,y into [][]int64
+	var path [][]int64
+	for _, p := range points {
+		parts := strings.SplitN(p, ",", 2)
+		if len(parts) != 2 {
+			pterm.Error.Printf("invalid --point value: %s (expected x,y)\n", p)
+			return nil
+		}
+		x, err := strconv.ParseInt(strings.TrimSpace(parts[0]), 10, 64)
+		if err != nil {
+			pterm.Error.Printf("invalid x in --point %s: %v\n", p, err)
+			return nil
+		}
+		y, err := strconv.ParseInt(strings.TrimSpace(parts[1]), 10, 64)
+		if err != nil {
+			pterm.Error.Printf("invalid y in --point %s: %v\n", p, err)
+			return nil
+		}
+		path = append(path, []int64{x, y})
+	}
+
+	b := BrowsersCmd{browsers: &svc, computer: &svc.Computer}
+	return b.ComputerDragMouse(cmd.Context(), BrowsersComputerDragMouseInput{Identifier: args[0], Path: path, Delay: delay, StepDelayMs: stepDelayMs, StepsPerSegment: stepsPerSegment, Button: button, HoldKeys: holdKeys})
+}
+
 func truncateURL(url string, maxLen int) string {
 	if len(url) <= maxLen {
 		return url
diff --git a/cmd/browsers_test.go b/cmd/browsers_test.go
index 0f9c4d3..d68e9b8 100644
--- a/cmd/browsers_test.go
+++ b/cmd/browsers_test.go
@@ -523,6 +523,62 @@ func makeStream[T any](vals []T) *ssestream.Stream[T] {
 	return ssestream.NewStream[T](&testDecoder{data: events}, nil)
 }
 
+// --- Fake for Computer ---
+
+type FakeComputerService struct {
+	ClickMouseFunc        func(ctx context.Context, id string, body kernel.BrowserComputerClickMouseParams, opts ...option.RequestOption) error
+	MoveMouseFunc         func(ctx context.Context, id string, body kernel.BrowserComputerMoveMouseParams, opts ...option.RequestOption) error
+	CaptureScreenshotFunc func(ctx context.Context, id string, body kernel.BrowserComputerCaptureScreenshotParams, opts ...option.RequestOption) (*http.Response, error)
+	PressKeyFunc          func(ctx context.Context, id string, body kernel.BrowserComputerPressKeyParams, opts ...option.RequestOption) error
+	ScrollFunc            func(ctx context.Context, id string, body kernel.BrowserComputerScrollParams, opts ...option.RequestOption) error
+	DragMouseFunc         func(ctx context.Context, id string, body kernel.BrowserComputerDragMouseParams, opts ...option.RequestOption) error
+	TypeTextFunc          func(ctx context.Context, id string, body kernel.BrowserComputerTypeTextParams, opts ...option.RequestOption) error
+}
+
+func (f *FakeComputerService) ClickMouse(ctx context.Context, id string, body kernel.BrowserComputerClickMouseParams, opts ...option.RequestOption) error {
+	if f.ClickMouseFunc != nil {
+		return f.ClickMouseFunc(ctx, id, body, opts...)
+	}
+	return nil
+}
+func (f *FakeComputerService) MoveMouse(ctx context.Context, id string, body kernel.BrowserComputerMoveMouseParams, opts ...option.RequestOption) error {
+	if f.MoveMouseFunc != nil {
+		return f.MoveMouseFunc(ctx, id, body, opts...)
+	}
+	return nil
+}
+func (f *FakeComputerService) CaptureScreenshot(ctx context.Context, id string, body kernel.BrowserComputerCaptureScreenshotParams, opts ...option.RequestOption) (*http.Response, error) {
+	if f.CaptureScreenshotFunc != nil {
+		return f.CaptureScreenshotFunc(ctx, id, body, opts...)
+	}
+	return &http.Response{StatusCode: 200, Header: http.Header{"Content-Type": []string{"image/png"}}, Body: io.NopCloser(strings.NewReader("pngdata"))}, nil
+}
+
+func (f *FakeComputerService) PressKey(ctx context.Context, id string, body kernel.BrowserComputerPressKeyParams, opts ...option.RequestOption) error {
+	if f.PressKeyFunc != nil {
+		return f.PressKeyFunc(ctx, id, body, opts...)
+	}
+	return nil
+}
+func (f *FakeComputerService) Scroll(ctx context.Context, id string, body kernel.BrowserComputerScrollParams, opts ...option.RequestOption) error {
+	if f.ScrollFunc != nil {
+		return f.ScrollFunc(ctx, id, body, opts...)
+	}
+	return nil
+}
+func (f *FakeComputerService) DragMouse(ctx context.Context, id string, body kernel.BrowserComputerDragMouseParams, opts ...option.RequestOption) error {
+	if f.DragMouseFunc != nil {
+		return f.DragMouseFunc(ctx, id, body, opts...)
+	}
+	return nil
+}
+func (f *FakeComputerService) TypeText(ctx context.Context, id string, body kernel.BrowserComputerTypeTextParams, opts ...option.RequestOption) error {
+	if f.TypeTextFunc != nil {
+		return f.TypeTextFunc(ctx, id, body, opts...)
+	}
+	return nil
+}
+
 // --- Tests for Logs ---
 
 func TestBrowsersLogsStream_PrintsEvents(t *testing.T) {
@@ -882,6 +938,92 @@ func __writeTempFile(t *testing.T, data string) string {
 	return f.Name()
 }
 
+// --- Tests for Computer ---
+
+func TestBrowsersComputerClickMouse_PrintsSuccess(t *testing.T) {
+	setupStdoutCapture(t)
+	fakeBrowsers := &FakeBrowsersService{ListFunc: func(ctx context.Context, opts ...option.RequestOption) (*[]kernel.BrowserListResponse, error) {
+		rows := []kernel.BrowserListResponse{{SessionID: "id"}}
+		return &rows, nil
+	}}
+	fakeComp := &FakeComputerService{}
+	b := BrowsersCmd{browsers: fakeBrowsers, computer: fakeComp}
+	_ = b.ComputerClickMouse(context.Background(), BrowsersComputerClickMouseInput{Identifier: "id", X: 10, Y: 20, NumClicks: 2, Button: string(kernel.BrowserComputerClickMouseParamsButtonLeft), ClickType: string(kernel.BrowserComputerClickMouseParamsClickTypeClick), HoldKeys: []string{"shift"}})
+	out := outBuf.String()
+	assert.Contains(t, out, "Clicked mouse at (10,20)")
+}
+
+func TestBrowsersComputerMoveMouse_PrintsSuccess(t *testing.T) {
+	setupStdoutCapture(t)
+	fakeBrowsers := &FakeBrowsersService{ListFunc: func(ctx context.Context, opts ...option.RequestOption) (*[]kernel.BrowserListResponse, error) {
+		rows := []kernel.BrowserListResponse{{SessionID: "id"}}
+		return &rows, nil
+	}}
+	fakeComp := &FakeComputerService{}
+	b := BrowsersCmd{browsers: fakeBrowsers, computer: fakeComp}
+	_ = b.ComputerMoveMouse(context.Background(), BrowsersComputerMoveMouseInput{Identifier: "id", X: 5, Y: 6})
+	out := outBuf.String()
+	assert.Contains(t, out, "Moved mouse to (5,6)")
+}
+
+func TestBrowsersComputerScreenshot_SavesFile(t *testing.T) {
+	setupStdoutCapture(t)
+	dir := t.TempDir()
+	outPath := filepath.Join(dir, "shot.png")
+	fakeBrowsers := &FakeBrowsersService{ListFunc: func(ctx context.Context, opts ...option.RequestOption) (*[]kernel.BrowserListResponse, error) {
+		rows := []kernel.BrowserListResponse{{SessionID: "id"}}
+		return &rows, nil
+	}}
+	fakeComp := &FakeComputerService{CaptureScreenshotFunc: func(ctx context.Context, id string, body kernel.BrowserComputerCaptureScreenshotParams, opts ...option.RequestOption) (*http.Response, error) {
+		return &http.Response{StatusCode: 200, Header: http.Header{"Content-Type": []string{"image/png"}}, Body: io.NopCloser(strings.NewReader("pngDATA"))}, nil
+	}}
+	b := BrowsersCmd{browsers: fakeBrowsers, computer: fakeComp}
+	_ = b.ComputerScreenshot(context.Background(), BrowsersComputerScreenshotInput{Identifier: "id", X: 0, Y: 0, Width: 10, Height: 10, To: outPath})
+	data, err := os.ReadFile(outPath)
+	assert.NoError(t, err)
+	assert.Equal(t, "pngDATA", string(data))
+}
+
+func TestBrowsersComputerPressKey_PrintsSuccess(t *testing.T) {
+	setupStdoutCapture(t)
+	fakeBrowsers := &FakeBrowsersService{ListFunc: func(ctx context.Context, opts ...option.RequestOption) (*[]kernel.BrowserListResponse, error) {
+		rows := []kernel.BrowserListResponse{{SessionID: "id"}}
+		return &rows, nil
+	}}
+	fakeComp := &FakeComputerService{}
+	b := BrowsersCmd{browsers: fakeBrowsers, computer: fakeComp}
+	_ = b.ComputerPressKey(context.Background(), BrowsersComputerPressKeyInput{Identifier: "id", Keys: []string{"Return", "Shift"}, Duration: 25, HoldKeys: []string{"Ctrl"}})
+	out := outBuf.String()
+	assert.Contains(t, out, "Pressed keys: Return,Shift")
+}
+
+func TestBrowsersComputerScroll_PrintsSuccess(t *testing.T) {
+	setupStdoutCapture(t)
+	fakeBrowsers := &FakeBrowsersService{ListFunc: func(ctx context.Context, opts ...option.RequestOption) (*[]kernel.BrowserListResponse, error) {
+		rows := []kernel.BrowserListResponse{{SessionID: "id"}}
+		return &rows, nil
+	}}
+	fakeComp := &FakeComputerService{}
+	b := BrowsersCmd{browsers: fakeBrowsers, computer: fakeComp}
+	_ = b.ComputerScroll(context.Background(), BrowsersComputerScrollInput{Identifier: "id", X: 100, Y: 200, DeltaY: 120, DeltaYSet: true})
+	out := outBuf.String()
+	assert.Contains(t, out, "Scrolled at (100,200)")
+}
+
+func TestBrowsersComputerDragMouse_PrintsSuccess(t *testing.T) {
+	setupStdoutCapture(t)
+	fakeBrowsers := &FakeBrowsersService{ListFunc: func(ctx context.Context, opts ...option.RequestOption) (*[]kernel.BrowserListResponse, error) {
+		rows := []kernel.BrowserListResponse{{SessionID: "id"}}
+		return &rows, nil
+	}}
+	fakeComp := &FakeComputerService{}
+	b := BrowsersCmd{browsers: fakeBrowsers, computer: fakeComp}
+	path := [][]int64{{0, 0}, {50, 50}, {100, 100}}
+	_ = b.ComputerDragMouse(context.Background(), BrowsersComputerDragMouseInput{Identifier: "id", Path: path, Delay: 50, Button: string(kernel.BrowserComputerDragMouseParamsButtonLeft)})
+	out := outBuf.String()
+	assert.Contains(t, out, "Dragged mouse over 3 points")
+}
+
 func TestParseViewport_ValidFormats(t *testing.T) {
 	tests := []struct {
 		input       string
diff --git a/cmd/deploy.go b/cmd/deploy.go
index 2fb3385..822c35e 100644
--- a/cmd/deploy.go
+++ b/cmd/deploy.go
@@ -262,7 +262,7 @@ func runDeploy(cmd *cobra.Command, args []string) (err error) {
 		File:              file,
 		Version:           kernel.Opt(version),
 		Force:             kernel.Opt(force),
-		EntrypointRelPath: filepath.Base(resolvedEntrypoint),
+		EntrypointRelPath: kernel.Opt(filepath.Base(resolvedEntrypoint)),
 		EnvVars:           envVars,
 	}, option.WithMaxRetries(0))
 	if err != nil {
diff --git a/go.mod b/go.mod
index af7e804..769b59e 100644
--- a/go.mod
+++ b/go.mod
@@ -8,7 +8,7 @@ require (
 	github.com/charmbracelet/fang v0.2.0
 	github.com/golang-jwt/jwt/v5 v5.2.2
 	github.com/joho/godotenv v1.5.1
-	github.com/onkernel/kernel-go-sdk v0.14.2
+	github.com/onkernel/kernel-go-sdk v0.15.0
 	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c
 	github.com/pterm/pterm v0.12.80
 	github.com/samber/lo v1.51.0
diff --git a/go.sum b/go.sum
index d2a7180..4f3e67f 100644
--- a/go.sum
+++ b/go.sum
@@ -91,8 +91,8 @@ github.com/muesli/mango-pflag v0.1.0 h1:UADqbYgpUyRoBja3g6LUL+3LErjpsOwaC9ywvBWe
 github.com/muesli/mango-pflag v0.1.0/go.mod h1:YEQomTxaCUp8PrbhFh10UfbhbQrM/xJ4i2PB8VTLLW0=
 github.com/muesli/roff v0.1.0 h1:YD0lalCotmYuF5HhZliKWlIx7IEhiXeSfq7hNjFqGF8=
 github.com/muesli/roff v0.1.0/go.mod h1:pjAHQM9hdUUwm/krAfrLGgJkXJ+YuhtsfZ42kieB2Ig=
-github.com/onkernel/kernel-go-sdk v0.14.2 h1:femYawCgMHCeRDlFlhGxOM3KuBUvrZhaGOfWxdn2YUY=
-github.com/onkernel/kernel-go-sdk v0.14.2/go.mod h1:MjUR92i8UPqjrmneyVykae6GuB3GGSmnQtnjf1v74Dc=
+github.com/onkernel/kernel-go-sdk v0.15.0 h1:gLeZixS9bhOy1WuEk/eFogHUBjG6UJKN2l+OJNNdE+4=
+github.com/onkernel/kernel-go-sdk v0.15.0/go.mod h1:MjUR92i8UPqjrmneyVykae6GuB3GGSmnQtnjf1v74Dc=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=