diff --git a/android/module.go b/android/module.go
index 2bcc7a8..0bd64ed 100644
--- a/android/module.go
+++ b/android/module.go
@@ -2732,7 +2732,6 @@
 // Modules can implement HostToolProvider and return a valid OptionalPath from HostToolPath() to
 // specify that they can be used as a tool by a genrule module.
 type HostToolProvider interface {
-	Module
 	// HostToolPath returns the path to the host tool for the module if it is one, or an invalid
 	// OptionalPath.
 	HostToolPath() OptionalPath
diff --git a/android/rule_builder.go b/android/rule_builder.go
index 84501fe..e2d8187 100644
--- a/android/rule_builder.go
+++ b/android/rule_builder.go
@@ -32,7 +32,6 @@
 
 const sboxSandboxBaseDir = "__SBOX_SANDBOX_DIR__"
 const sboxOutSubDir = "out"
-const sboxToolsSubDir = "tools"
 const sboxOutDir = sboxSandboxBaseDir + "/" + sboxOutSubDir
 
 // RuleBuilder provides an alternative to ModuleContext.Rule and ModuleContext.Build to add a command line to the build
@@ -49,7 +48,6 @@
 	highmem          bool
 	remoteable       RemoteRuleSupports
 	outDir           WritablePath
-	sboxTools        bool
 	sboxManifestPath WritablePath
 	missingDeps      []string
 }
@@ -142,19 +140,6 @@
 	return r
 }
 
-// SandboxTools enables tool sandboxing for the rule by copying any referenced tools into the
-// sandbox.
-func (r *RuleBuilder) SandboxTools() *RuleBuilder {
-	if !r.sbox {
-		panic("SandboxTools() must be called after Sbox()")
-	}
-	if len(r.commands) > 0 {
-		panic("SandboxTools() may not be called after Command()")
-	}
-	r.sboxTools = true
-	return r
-}
-
 // Install associates an output of the rule with an install location, which can be retrieved later using
 // RuleBuilder.Installs.
 func (r *RuleBuilder) Install(from Path, to string) {
@@ -483,29 +468,8 @@
 			manifest.OutputDepfile = proto.String(depFile.String())
 		}
 
-		// If sandboxing tools is enabled, add copy rules to the manifest to copy each tool
-		// into the sbox directory.
-		if r.sboxTools {
-			for _, tool := range tools {
-				command.CopyBefore = append(command.CopyBefore, &sbox_proto.Copy{
-					From: proto.String(tool.String()),
-					To:   proto.String(sboxPathForToolRel(r.ctx, tool)),
-				})
-			}
-			for _, c := range r.commands {
-				for _, tool := range c.packagedTools {
-					command.CopyBefore = append(command.CopyBefore, &sbox_proto.Copy{
-						From:       proto.String(tool.srcPath.String()),
-						To:         proto.String(sboxPathForPackagedToolRel(tool)),
-						Executable: proto.Bool(tool.executable),
-					})
-					tools = append(tools, tool.srcPath)
-				}
-			}
-		}
-
 		// Add copy rules to the manifest to copy each output file from the sbox directory.
-		// to the output directory after running the commands.
+		// to the output directory.
 		sboxOutputs := make([]string, len(outputs))
 		for i, output := range outputs {
 			rel := Rel(r.ctx, r.outDir.String(), output.String())
@@ -618,7 +582,6 @@
 	symlinkOutputs WritablePaths
 	depFiles       WritablePaths
 	tools          Paths
-	packagedTools  []PackagingSpec
 	rspFileInputs  Paths
 
 	// spans [start,end) of the command that should not be ninja escaped
@@ -662,79 +625,6 @@
 	return path.String()
 }
 
-// SboxPathForTool takes a path to a tool, which may be an output file or a source file, and returns
-// the corresponding path for the tool in the sbox sandbox.  It assumes that sandboxing and tool
-// sandboxing are enabled.
-func SboxPathForTool(ctx BuilderContext, path Path) string {
-	return filepath.Join(sboxSandboxBaseDir, sboxPathForToolRel(ctx, path))
-}
-
-func sboxPathForToolRel(ctx BuilderContext, path Path) string {
-	// Errors will be handled in RuleBuilder.Build where we have a context to report them
-	relOut, isRelOut, _ := maybeRelErr(PathForOutput(ctx, "host", ctx.Config().PrebuiltOS()).String(), path.String())
-	if isRelOut {
-		// The tool is in the output directory, it will be copied to __SBOX_OUT_DIR__/tools/out
-		return filepath.Join(sboxToolsSubDir, "out", relOut)
-	}
-	// The tool is in the source directory, it will be copied to __SBOX_OUT_DIR__/tools/src
-	return filepath.Join(sboxToolsSubDir, "src", path.String())
-}
-
-// SboxPathForPackagedTool takes a PackageSpec for a tool and returns the corresponding path for the
-// tool after copying it into the sandbox.  This can be used  on the RuleBuilder command line to
-// reference the tool.
-func SboxPathForPackagedTool(spec PackagingSpec) string {
-	return filepath.Join(sboxSandboxBaseDir, sboxPathForPackagedToolRel(spec))
-}
-
-func sboxPathForPackagedToolRel(spec PackagingSpec) string {
-	return filepath.Join(sboxToolsSubDir, "out", spec.relPathInPackage)
-}
-
-// PathForTool takes a path to a tool, which may be an output file or a source file, and returns
-// the corresponding path for the tool in the sbox sandbox if sbox is enabled, or the original path
-// if it is not.  This can be used  on the RuleBuilder command line to reference the tool.
-func (c *RuleBuilderCommand) PathForTool(path Path) string {
-	if c.rule.sbox && c.rule.sboxTools {
-		return filepath.Join(sboxSandboxBaseDir, sboxPathForToolRel(c.rule.ctx, path))
-	}
-	return path.String()
-}
-
-// PackagedTool adds the specified tool path to the command line.  It can only be used with tool
-// sandboxing enabled by SandboxTools(), and will copy the tool into the sandbox.
-func (c *RuleBuilderCommand) PackagedTool(spec PackagingSpec) *RuleBuilderCommand {
-	if !c.rule.sboxTools {
-		panic("PackagedTool() requires SandboxTools()")
-	}
-
-	c.packagedTools = append(c.packagedTools, spec)
-	c.Text(sboxPathForPackagedToolRel(spec))
-	return c
-}
-
-// ImplicitPackagedTool copies the specified tool into the sandbox without modifying the command
-// line.  It can only be used with tool sandboxing enabled by SandboxTools().
-func (c *RuleBuilderCommand) ImplicitPackagedTool(spec PackagingSpec) *RuleBuilderCommand {
-	if !c.rule.sboxTools {
-		panic("ImplicitPackagedTool() requires SandboxTools()")
-	}
-
-	c.packagedTools = append(c.packagedTools, spec)
-	return c
-}
-
-// ImplicitPackagedTools copies the specified tools into the sandbox without modifying the command
-// line.  It can only be used with tool sandboxing enabled by SandboxTools().
-func (c *RuleBuilderCommand) ImplicitPackagedTools(specs []PackagingSpec) *RuleBuilderCommand {
-	if !c.rule.sboxTools {
-		panic("ImplicitPackagedTools() requires SandboxTools()")
-	}
-
-	c.packagedTools = append(c.packagedTools, specs...)
-	return c
-}
-
 // Text adds the specified raw text to the command line.  The text should not contain input or output paths or the
 // rule will not have them listed in its dependencies or outputs.
 func (c *RuleBuilderCommand) Text(text string) *RuleBuilderCommand {
@@ -803,19 +693,7 @@
 // RuleBuilder.Tools.
 func (c *RuleBuilderCommand) Tool(path Path) *RuleBuilderCommand {
 	c.tools = append(c.tools, path)
-	return c.Text(c.PathForTool(path))
-}
-
-// Tool adds the specified tool path to the dependencies returned by RuleBuilder.Tools.
-func (c *RuleBuilderCommand) ImplicitTool(path Path) *RuleBuilderCommand {
-	c.tools = append(c.tools, path)
-	return c
-}
-
-// Tool adds the specified tool path to the dependencies returned by RuleBuilder.Tools.
-func (c *RuleBuilderCommand) ImplicitTools(paths Paths) *RuleBuilderCommand {
-	c.tools = append(c.tools, paths...)
-	return c
+	return c.Text(path.String())
 }
 
 // BuiltTool adds the specified tool path that was built using a host Soong module to the command line.  The path will
diff --git a/android/rule_builder_test.go b/android/rule_builder_test.go
index 06ea124..e676e4a 100644
--- a/android/rule_builder_test.go
+++ b/android/rule_builder_test.go
@@ -436,44 +436,6 @@
 			t.Errorf("\nwant rule.depFileMergerCmd() = %#v\n                   got %#v", w, g)
 		}
 	})
-
-	t.Run("sbox tools", func(t *testing.T) {
-		rule := NewRuleBuilder(pctx, ctx).Sbox(PathForOutput(ctx, ""),
-			PathForOutput(ctx, "sbox.textproto")).SandboxTools()
-		addCommands(rule)
-
-		wantCommands := []string{
-			"__SBOX_SANDBOX_DIR__/out/DepFile Flag FlagWithArg=arg FlagWithDepFile=__SBOX_SANDBOX_DIR__/out/depfile FlagWithInput=input FlagWithOutput=__SBOX_SANDBOX_DIR__/out/output Input __SBOX_SANDBOX_DIR__/out/Output __SBOX_SANDBOX_DIR__/out/SymlinkOutput Text __SBOX_SANDBOX_DIR__/tools/src/Tool after command2 old cmd",
-			"command2 __SBOX_SANDBOX_DIR__/out/depfile2 input2 __SBOX_SANDBOX_DIR__/out/output2 __SBOX_SANDBOX_DIR__/tools/src/tool2",
-			"command3 input3 __SBOX_SANDBOX_DIR__/out/output2 __SBOX_SANDBOX_DIR__/out/output3",
-		}
-
-		wantDepMergerCommand := "__SBOX_SANDBOX_DIR__/tools/out/bin/dep_fixer __SBOX_SANDBOX_DIR__/out/DepFile __SBOX_SANDBOX_DIR__/out/depfile __SBOX_SANDBOX_DIR__/out/ImplicitDepFile __SBOX_SANDBOX_DIR__/out/depfile2"
-
-		if g, w := rule.Commands(), wantCommands; !reflect.DeepEqual(g, w) {
-			t.Errorf("\nwant rule.Commands() = %#v\n                   got %#v", w, g)
-		}
-
-		if g, w := rule.Inputs(), wantInputs; !reflect.DeepEqual(w, g) {
-			t.Errorf("\nwant rule.Inputs() = %#v\n                 got %#v", w, g)
-		}
-		if g, w := rule.Outputs(), wantOutputs; !reflect.DeepEqual(w, g) {
-			t.Errorf("\nwant rule.Outputs() = %#v\n                  got %#v", w, g)
-		}
-		if g, w := rule.DepFiles(), wantDepFiles; !reflect.DeepEqual(w, g) {
-			t.Errorf("\nwant rule.DepFiles() = %#v\n                  got %#v", w, g)
-		}
-		if g, w := rule.Tools(), wantTools; !reflect.DeepEqual(w, g) {
-			t.Errorf("\nwant rule.Tools() = %#v\n                got %#v", w, g)
-		}
-		if g, w := rule.OrderOnlys(), wantOrderOnlys; !reflect.DeepEqual(w, g) {
-			t.Errorf("\nwant rule.OrderOnlys() = %#v\n                got %#v", w, g)
-		}
-
-		if g, w := rule.depFileMergerCmd(rule.DepFiles()).String(), wantDepMergerCommand; g != w {
-			t.Errorf("\nwant rule.depFileMergerCmd() = %#v\n                   got %#v", w, g)
-		}
-	})
 }
 
 func testRuleBuilderFactory() Module {