diff --git a/src/main/java/com/android/tools/r8/BaseCompilerCommand.java b/src/main/java/com/android/tools/r8/BaseCompilerCommand.java
index 51bacdc..0b76de3 100644
--- a/src/main/java/com/android/tools/r8/BaseCompilerCommand.java
+++ b/src/main/java/com/android/tools/r8/BaseCompilerCommand.java
@@ -920,5 +920,9 @@
     ClassConflictResolver getClassConflictResolver() {
       return classConflictResolver;
     }
+
+    boolean hasNativeMultidex() {
+      return isMinApiLevelSet() && getMinApiLevel() >= AndroidApiLevel.L.getLevel();
+    }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/R8Assistant.java b/src/main/java/com/android/tools/r8/R8Assistant.java
new file mode 100644
index 0000000..2e26ebe
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/R8Assistant.java
@@ -0,0 +1,80 @@
+// Copyright (c) 2025, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8;
+
+import static com.android.tools.r8.utils.ExceptionUtils.unwrapExecutionException;
+
+import com.android.tools.r8.assistant.ReflectiveInstrumentation;
+import com.android.tools.r8.dex.ApplicationReader;
+import com.android.tools.r8.dex.ApplicationWriter;
+import com.android.tools.r8.graph.AppInfo;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.LazyLoadedDexApplication;
+import com.android.tools.r8.ir.conversion.PrimaryD8L8IRConverter;
+import com.android.tools.r8.keepanno.annotations.KeepForApi;
+import com.android.tools.r8.synthesis.SyntheticFinalization;
+import com.android.tools.r8.synthesis.SyntheticItems.GlobalSyntheticsStrategy;
+import com.android.tools.r8.utils.ExceptionUtils;
+import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.ThreadUtils;
+import com.android.tools.r8.utils.Timing;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+
+/**
+ * This is an experimental API for injecting reflective identification callbacks into dex code. This
+ * API is subject to change.
+ */
+@KeepForApi
+public class R8Assistant {
+
+  public static void run(R8AssistantCommand command) throws CompilationFailedException {
+    InternalOptions options = command.getInternalOptions();
+    ExceptionUtils.withCompilationHandler(
+        options.reporter,
+        () -> runInternal(command, options, ThreadUtils.getExecutorService(options)));
+  }
+
+  public static void run(R8AssistantCommand command, ExecutorService executor)
+      throws CompilationFailedException {
+    InternalOptions options = command.getInternalOptions();
+    ExceptionUtils.withD8CompilationHandler(
+        command.getReporter(),
+        () -> {
+          runInternal(command, options, executor);
+        });
+  }
+
+  static void runInternal(
+      R8AssistantCommand command, InternalOptions options, ExecutorService executorService)
+      throws IOException {
+    Timing timing = new Timing("R8 Assistant " + Version.LABEL);
+    try {
+      ApplicationReader applicationReader =
+          new ApplicationReader(command.getInputApp(), options, timing);
+      LazyLoadedDexApplication app = applicationReader.read(executorService);
+      assert !command.getInputApp().hasMainDexList();
+      AppInfo appInfo =
+          AppInfo.createInitialAppInfo(app, GlobalSyntheticsStrategy.forSingleOutputMode());
+      AppView<AppInfo> appView = AppView.createForD8(appInfo);
+      PrimaryD8L8IRConverter converter = new PrimaryD8L8IRConverter(appView, timing);
+      ReflectiveInstrumentation reflectiveInstrumentation =
+          new ReflectiveInstrumentation(appView, converter, timing);
+      reflectiveInstrumentation.instrumentClasses();
+      // Convert cf classes
+      converter.convert(appView, executorService);
+      SyntheticFinalization.finalize(appView, timing, executorService);
+      ApplicationWriter writer = ApplicationWriter.create(appView, options.getMarker());
+      writer.write(executorService);
+    } catch (ExecutionException e) {
+      throw unwrapExecutionException(e);
+    } finally {
+      options.signalFinishedToConsumers();
+      if (options.isPrintTimesReportingEnabled()) {
+        timing.report();
+      }
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/R8AssistantCommand.java b/src/main/java/com/android/tools/r8/R8AssistantCommand.java
new file mode 100644
index 0000000..f5dba70
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/R8AssistantCommand.java
@@ -0,0 +1,144 @@
+// Copyright (c) 2025, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8;
+
+import com.android.tools.r8.assistant.ClassInjectionHelper;
+import com.android.tools.r8.assistant.runtime.ReflectiveOperationReceiver;
+import com.android.tools.r8.assistant.runtime.ReflectiveOracle;
+import com.android.tools.r8.assistant.runtime.ReflectiveOracle.ReflectiveOperationLogger;
+import com.android.tools.r8.assistant.runtime.ReflectiveOracle.Stack;
+import com.android.tools.r8.dex.Marker;
+import com.android.tools.r8.dex.Marker.Backend;
+import com.android.tools.r8.dex.Marker.Tool;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.keepanno.annotations.KeepForApi;
+import com.android.tools.r8.origin.SynthesizedOrigin;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.DumpInputFlags;
+import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.InternalOptions.DesugarState;
+import com.android.tools.r8.utils.Reporter;
+import com.android.tools.r8.utils.ThreadUtils;
+import java.util.Collections;
+
+/**
+ * This is an experimental API for injecting reflective identification callbacks into dex code. This
+ * API is subject to change.
+ */
+@KeepForApi
+public class R8AssistantCommand extends BaseCompilerCommand {
+
+  public R8AssistantCommand(
+      AndroidApp app,
+      CompilationMode mode,
+      ProgramConsumer programConsumer,
+      int minApiLevel,
+      Reporter reporter) {
+    super(
+        app,
+        mode,
+        programConsumer,
+        StringConsumer.emptyConsumer(),
+        minApiLevel,
+        reporter,
+        DesugarState.ON,
+        false,
+        false,
+        (a, b) -> true,
+        Collections.emptyList(),
+        Collections.emptyList(),
+        ThreadUtils.NOT_SPECIFIED,
+        DumpInputFlags.noDump(),
+        null,
+        null,
+        false,
+        Collections.emptyList(),
+        Collections.emptyList(),
+        null,
+        null);
+  }
+
+  public static Builder builder(DiagnosticsHandler reporter) {
+    return new Builder(reporter);
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  @Override
+  InternalOptions getInternalOptions() {
+    DexItemFactory factory = new DexItemFactory();
+    InternalOptions options = new InternalOptions(factory, getReporter());
+    options.setMinApiLevel(AndroidApiLevel.getAndroidApiLevel(getMinApiLevel()));
+    options.passthroughDexCode = true;
+    options.tool = Tool.R8Assistant;
+    Marker marker = new Marker(Tool.R8Assistant);
+    marker.setBackend(Backend.DEX);
+    marker.setMinApi(getMinApiLevel());
+    options.setMarker(marker);
+    options.programConsumer = getProgramConsumer();
+    return options;
+  }
+
+  /**
+   * This is an experimental API for injecting reflective identification callbacks into dex code.
+   * This API is subject to change.
+   */
+  @KeepForApi
+  public static class Builder extends BaseCompilerCommand.Builder<R8AssistantCommand, Builder> {
+
+    private Builder() {
+      this(new DiagnosticsHandler() {});
+    }
+
+    @Override
+    void validate() {
+      if (!(getProgramConsumer() instanceof DexIndexedConsumer)) {
+        getReporter().error("R8 assistant does not support CF output.");
+      }
+      if (!hasNativeMultidex()) {
+        getReporter().error("R8 assistant requires min api >= 21");
+      }
+    }
+
+    @Override
+    CompilationMode defaultCompilationMode() {
+      return CompilationMode.RELEASE;
+    }
+
+    private Builder(DiagnosticsHandler diagnosticsHandler) {
+      super(diagnosticsHandler);
+    }
+
+    @Override
+    Builder self() {
+      return this;
+    }
+
+    @Override
+    R8AssistantCommand makeCommand() {
+      ClassInjectionHelper injectionHelper = new ClassInjectionHelper(getReporter());
+      String reason = "Reflective instrumentation";
+      addClassProgramData(
+          injectionHelper.getClassBytes(ReflectiveOracle.class),
+          new SynthesizedOrigin(reason, ReflectiveOracle.class));
+      addClassProgramData(
+          injectionHelper.getClassBytes(Stack.class), new SynthesizedOrigin(reason, Stack.class));
+      addClassProgramData(
+          injectionHelper.getClassBytes(ReflectiveOperationReceiver.class),
+          new SynthesizedOrigin(reason, ReflectiveOperationReceiver.class));
+      addClassProgramData(
+          injectionHelper.getClassBytes(ReflectiveOperationLogger.class),
+          new SynthesizedOrigin(reason, ReflectiveOperationLogger.class));
+      return new R8AssistantCommand(
+          getAppBuilder().build(),
+          getMode(),
+          getProgramConsumer(),
+          getMinApiLevel(),
+          getReporter());
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/R8Command.java b/src/main/java/com/android/tools/r8/R8Command.java
index 42672c6..77778d0 100644
--- a/src/main/java/com/android/tools/r8/R8Command.java
+++ b/src/main/java/com/android/tools/r8/R8Command.java
@@ -782,10 +782,6 @@
       return !mainDexRules.isEmpty();
     }
 
-    private boolean hasNativeMultidex() {
-      return isMinApiLevelSet() && getMinApiLevel() >= AndroidApiLevel.L.getLevel();
-    }
-
     private static void verifyResourceSplitOrProgramSplit(FeatureSplit featureSplit) {
       assert featureSplit.getProgramConsumer() instanceof DexIndexedConsumer
           || featureSplit.getAndroidResourceProvider() != null;
diff --git a/src/main/java/com/android/tools/r8/assistant/ClassInjectionHelper.java b/src/main/java/com/android/tools/r8/assistant/ClassInjectionHelper.java
new file mode 100644
index 0000000..0698cc0
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/assistant/ClassInjectionHelper.java
@@ -0,0 +1,37 @@
+// Copyright (c) 2025, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.assistant;
+
+import com.android.tools.r8.R8Assistant;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.ExceptionDiagnostic;
+import com.android.tools.r8.utils.Reporter;
+import com.android.tools.r8.utils.StringDiagnostic;
+import com.google.common.io.ByteStreams;
+import java.io.IOException;
+import java.io.InputStream;
+
+public class ClassInjectionHelper {
+
+  private final Reporter reporter;
+
+  public ClassInjectionHelper(Reporter reporter) {
+    this.reporter = reporter;
+  }
+
+  public byte[] getClassBytes(Class<?> clazz) {
+    String classFilePath = DescriptorUtils.getPathFromJavaType(clazz);
+    try (InputStream inputStream =
+        R8Assistant.class.getClassLoader().getResourceAsStream(classFilePath)) {
+      if (inputStream == null) {
+        reporter.error(new StringDiagnostic("Could not open class file: " + classFilePath));
+        return null;
+      }
+      return ByteStreams.toByteArray(inputStream);
+    } catch (IOException e) {
+      reporter.error(new ExceptionDiagnostic(e));
+      return null;
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/assistant/ReflectiveInstrumentation.java b/src/main/java/com/android/tools/r8/assistant/ReflectiveInstrumentation.java
new file mode 100644
index 0000000..1df0015
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/assistant/ReflectiveInstrumentation.java
@@ -0,0 +1,132 @@
+// Copyright (c) 2025, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.assistant;
+
+import com.android.tools.r8.assistant.runtime.ReflectiveOracle;
+import com.android.tools.r8.graph.AppInfo;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.code.BasicBlockInstructionListIterator;
+import com.android.tools.r8.ir.code.BasicBlockIterator;
+import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.ir.code.InvokeStatic;
+import com.android.tools.r8.ir.code.InvokeVirtual;
+import com.android.tools.r8.ir.conversion.PrimaryD8L8IRConverter;
+import com.android.tools.r8.ir.optimize.info.OptimizationFeedback;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.Timing;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+
+public class ReflectiveInstrumentation {
+
+  private final AppView<AppInfo> appView;
+  private final PrimaryD8L8IRConverter converter;
+  private final DexItemFactory dexItemFactory;
+  private final Timing timing;
+  private final DexType reflectiveOracleType;
+
+  public ReflectiveInstrumentation(
+      AppView<AppInfo> appView, PrimaryD8L8IRConverter converter, Timing timing) {
+    this.appView = appView;
+    this.dexItemFactory = appView.dexItemFactory();
+    this.converter = converter;
+    this.timing = timing;
+    this.reflectiveOracleType =
+        dexItemFactory.createType(DescriptorUtils.javaClassToDescriptor(ReflectiveOracle.class));
+  }
+
+  // TODO(b/394013779): Do this in parallel.
+  public void instrumentClasses() {
+    ImmutableMap<DexMethod, DexMethod> instrumentedMethodsAndTargets =
+        getInstrumentedMethodsAndTargets();
+    for (DexProgramClass clazz : appView.appInfo().classes()) {
+      clazz.forEachProgramMethodMatching(
+          method -> method.hasCode() && method.getCode().isDexCode(),
+          method -> {
+            boolean changed = false;
+            // TODO(b/394016252): Consider using UseRegistry for determining that we need IR.
+            IRCode irCode = method.buildIR(appView);
+            BasicBlockIterator blockIterator = irCode.listIterator();
+            while (blockIterator.hasNext()) {
+              BasicBlockInstructionListIterator instructionIterator =
+                  blockIterator.next().listIterator();
+              while (instructionIterator.hasNext()) {
+                Instruction instruction = instructionIterator.next();
+                if (!instruction.isInvokeVirtual()) {
+                  continue;
+                }
+                InvokeVirtual invokeVirtual = instruction.asInvokeVirtual();
+                DexMethod invokedMethod = invokeVirtual.getInvokedMethod();
+                DexMethod toInstrumentCallTo = instrumentedMethodsAndTargets.get(invokedMethod);
+                if (toInstrumentCallTo != null) {
+                  insertCallToMethod(
+                      toInstrumentCallTo,
+                      irCode,
+                      blockIterator,
+                      instructionIterator,
+                      invokeVirtual);
+                  changed = true;
+                }
+              }
+            }
+            if (changed) {
+              converter.removeDeadCodeAndFinalizeIR(
+                  irCode, OptimizationFeedback.getIgnoreFeedback(), timing);
+            }
+          });
+    }
+  }
+
+  private ImmutableMap<DexMethod, DexMethod> getInstrumentedMethodsAndTargets() {
+    return ImmutableMap.of(
+        dexItemFactory.classMethods.newInstance,
+        getMethodReferenceWithClassParameter("onClassNewInstance"),
+        dexItemFactory.classMethods.getDeclaredMethod,
+        getMethodReferenceWithClassMethodNameAndParameters("onClassGetDeclaredMethod"));
+  }
+
+  private DexMethod getMethodReferenceWithClassParameter(String name) {
+    return dexItemFactory.createMethod(
+        reflectiveOracleType,
+        dexItemFactory.createProto(dexItemFactory.voidType, dexItemFactory.classType),
+        name);
+  }
+
+  private DexMethod getMethodReferenceWithClassMethodNameAndParameters(String name) {
+    return dexItemFactory.createMethod(
+        reflectiveOracleType,
+        dexItemFactory.createProto(
+            dexItemFactory.voidType,
+            dexItemFactory.classType,
+            dexItemFactory.stringType,
+            dexItemFactory.classArrayType),
+        name);
+  }
+
+  private void insertCallToMethod(
+      DexMethod method,
+      IRCode code,
+      BasicBlockIterator blockIterator,
+      BasicBlockInstructionListIterator instructionIterator,
+      InvokeVirtual invoke) {
+    InvokeStatic invokeStatic =
+        InvokeStatic.builder()
+            .setMethod(method)
+            .setArguments(invoke.inValues())
+            // Same position so that the stack trace has the correct line number.
+            .setPosition(invoke)
+            .build();
+    instructionIterator.previous();
+    instructionIterator.addPossiblyThrowingInstructionsToPossiblyThrowingBlock(
+        code, blockIterator, ImmutableList.of(invokeStatic), appView.options());
+    if (instructionIterator.hasNext()) {
+      instructionIterator.next();
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/assistant/runtime/ReflectiveOperationReceiver.java b/src/main/java/com/android/tools/r8/assistant/runtime/ReflectiveOperationReceiver.java
new file mode 100644
index 0000000..62def20
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/assistant/runtime/ReflectiveOperationReceiver.java
@@ -0,0 +1,19 @@
+// Copyright (c) 2025, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.assistant.runtime;
+
+import com.android.tools.r8.assistant.runtime.ReflectiveOracle.Stack;
+import com.android.tools.r8.keepanno.annotations.KeepForApi;
+
+@KeepForApi
+public interface ReflectiveOperationReceiver {
+
+  default boolean requiresStackInformation() {
+    return false;
+  }
+
+  void onClassNewInstance(Stack stack, Class<?> clazz);
+
+  void onClassGetDeclaredMethod(Stack stack, Class<?> clazz, String method, Class<?>... parameters);
+}
diff --git a/src/main/java/com/android/tools/r8/assistant/runtime/ReflectiveOracle.java b/src/main/java/com/android/tools/r8/assistant/runtime/ReflectiveOracle.java
new file mode 100644
index 0000000..9f38551
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/assistant/runtime/ReflectiveOracle.java
@@ -0,0 +1,85 @@
+// Copyright (c) 2025, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.assistant.runtime;
+
+import com.android.tools.r8.keepanno.annotations.KeepForApi;
+import java.util.Arrays;
+
+@KeepForApi
+public class ReflectiveOracle {
+
+  private static Object instanceLock = new Object();
+  private static volatile ReflectiveOperationReceiver INSTANCE;
+
+  private static ReflectiveOperationReceiver getInstance() {
+    if (INSTANCE == null) {
+      // TODO(b/393249304): Support injecting alternative receiver.
+      synchronized (instanceLock) {
+        if (INSTANCE == null) {
+          INSTANCE = new ReflectiveOperationLogger();
+        }
+      }
+    }
+    return INSTANCE;
+  }
+
+  public static class Stack {
+
+    private final StackTraceElement[] stackTraceElements;
+
+    private Stack(StackTraceElement[] stackTraceElements) {
+      this.stackTraceElements = stackTraceElements;
+    }
+
+    static Stack createStack() {
+      assert INSTANCE != null;
+      if (INSTANCE.requiresStackInformation()) {
+        StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
+        return new Stack(Arrays.copyOfRange(stackTrace, 2, stackTrace.length));
+      }
+      return new Stack(null);
+    }
+
+    public StackTraceElement[] getStackTraceElements() {
+      return stackTraceElements;
+    }
+
+    public String toStringStackTrace() {
+      if (stackTraceElements == null) {
+        return "Stack extraction not enabled.";
+      }
+      StringBuilder sb = new StringBuilder();
+      for (StackTraceElement element : stackTraceElements) {
+        sb.append(" at ").append(element).append("\n");
+      }
+      return sb.toString();
+    }
+  }
+
+  public static void onClassNewInstance(Class<?> clazz) {
+    getInstance().onClassNewInstance(Stack.createStack(), clazz);
+  }
+
+  public static void onClassGetDeclaredMethod(Class<?> clazz, String name, Class<?>... parameters) {
+    getInstance().onClassGetDeclaredMethod(Stack.createStack(), clazz, name, parameters);
+  }
+
+  public static class ReflectiveOperationLogger implements ReflectiveOperationReceiver {
+    @Override
+    public void onClassNewInstance(Stack stack, Class<?> clazz) {
+      System.out.println("Reflectively created new instance of " + clazz.getName());
+    }
+
+    @Override
+    public void onClassGetDeclaredMethod(
+        Stack stack, Class<?> clazz, String method, Class<?>... parameters) {
+      System.out.println("Reflectively got declared method " + method + " on " + clazz.getName());
+    }
+
+    @Override
+    public boolean requiresStackInformation() {
+      return true;
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/dex/Marker.java b/src/main/java/com/android/tools/r8/dex/Marker.java
index f7414d9..1b03ca6 100644
--- a/src/main/java/com/android/tools/r8/dex/Marker.java
+++ b/src/main/java/com/android/tools/r8/dex/Marker.java
@@ -36,7 +36,8 @@
     R8,
     R8Partial,
     Relocator,
-    TraceReferences;
+    TraceReferences,
+    R8Assistant;
 
     public static Tool[] valuesR8andD8() {
       return new Tool[] {Tool.D8, Tool.R8};
@@ -55,6 +56,7 @@
   private static final String R8_PARTIAL_PREFIX = PREFIX + Tool.R8Partial + "{";
   private static final String L8_PREFIX = PREFIX + Tool.L8 + "{";
   private static final String RELOCATOR_PREFIX = PREFIX + Tool.Relocator + "{";
+  private static final String R8_ASSISTANT_PREFIX = PREFIX + Tool.R8Assistant + "{";
 
   private final JsonObject jsonObject;
   private final Tool tool;
@@ -183,6 +185,7 @@
       case D8:
       case L8:
       case R8:
+      case R8Assistant:
         // Before adding backend we would always compile to dex if min-api was specified.
         // This is not fully true for D8 which had a window from aug to oct 2020 where the min-api
         // was added for CF builds too. However, that was (and still is) only used internally and
@@ -298,6 +301,9 @@
       if (str.startsWith(RELOCATOR_PREFIX)) {
         return internalParse(Tool.Relocator, str.substring(RELOCATOR_PREFIX.length() - 1));
       }
+      if (str.startsWith(R8_ASSISTANT_PREFIX)) {
+        return internalParse(Tool.R8Assistant, str.substring(R8_ASSISTANT_PREFIX.length() - 1));
+      }
     }
     return null;
   }
diff --git a/src/test/java/com/android/tools/r8/assistant/R8AssistentReflectiveInstrumentationTest.java b/src/test/java/com/android/tools/r8/assistant/R8AssistentReflectiveInstrumentationTest.java
new file mode 100644
index 0000000..be0c3e2
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/assistant/R8AssistentReflectiveInstrumentationTest.java
@@ -0,0 +1,110 @@
+// Copyright (c) 2025, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.assistant;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.OutputMode;
+import com.android.tools.r8.R8Assistant;
+import com.android.tools.r8.R8AssistantCommand;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.io.IOException;
+import java.nio.file.Path;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class R8AssistentReflectiveInstrumentationTest extends TestBase {
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withNativeMultidexDexRuntimes().withMaximumApiLevel().build();
+  }
+
+  @Test
+  public void testInstrumentation() throws Exception {
+    Path d8Compilation =
+        testForD8(parameters.getBackend())
+            .addInnerClasses(getClass())
+            .setMinApi(parameters)
+            .compile()
+            .inspect(codeInspector -> inspectStaticCallsInReflectOn(0, codeInspector))
+            .writeToZip();
+    R8AssistantCommand.Builder builder = R8AssistantCommand.builder();
+    Path outputPath = temp.newFile("instrumented.jar").toPath();
+    // TODO(b/393265921): Add testForR8Assistant and avoid building up the command here
+    R8AssistantCommand command =
+        builder
+            .addProgramFiles(d8Compilation)
+            .setMinApiLevel(parameters.getApiLevel().getLevel())
+            .setOutput(outputPath, OutputMode.DexIndexed)
+            .build();
+    R8Assistant.run(command);
+    inspectStaticCallsInReflectOn(outputPath, 2);
+
+    String artOutput =
+        ToolHelper.runArtNoVerificationErrors(
+            outputPath.toString(),
+            TestClass.class
+                .getName()); // For now, just test that the printed logs are what we expect
+    String expectedNewInstanceString =
+        "Reflectively created new instance of " + Bar.class.getName();
+    assertThat(artOutput, containsString(expectedNewInstanceString));
+    String expectedGetDeclaredMethod =
+        "Reflectively got declared method callMe on " + Bar.class.getName();
+    assertThat(artOutput, containsString(expectedGetDeclaredMethod));
+  }
+
+  private static void inspectStaticCallsInReflectOn(Path outputPath, int count) throws IOException {
+    CodeInspector inspector = new CodeInspector(outputPath);
+    inspectStaticCallsInReflectOn(count, inspector);
+  }
+
+  private static void inspectStaticCallsInReflectOn(int count, CodeInspector inspector) {
+    ClassSubject testClass = inspector.clazz(TestClass.class);
+    assertThat(testClass, isPresent());
+    MethodSubject reflectOn = testClass.uniqueMethodWithOriginalName("reflectOn");
+    assertThat(reflectOn, isPresent());
+    long codeCount =
+        reflectOn.streamInstructions().filter(InstructionSubject::isInvokeStatic).count();
+    assertEquals(count, codeCount);
+  }
+
+  static class TestClass {
+    public static void main(String[] args) {
+      reflectOn(System.currentTimeMillis() == 0 ? Foo.class : Bar.class);
+    }
+
+    public static void reflectOn(Class<?> clazz) {
+      try {
+        clazz.newInstance();
+        clazz.getDeclaredMethod("callMe");
+
+      } catch (InstantiationException | IllegalAccessException | NoSuchMethodException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  public static class Foo {}
+
+  public static class Bar {
+    public void callMe() {}
+  }
+}