diff --git a/sqlite/sqlite-inspection/build.gradle b/sqlite/sqlite-inspection/build.gradle
index 7f8acbb..be0a598 100644
--- a/sqlite/sqlite-inspection/build.gradle
+++ b/sqlite/sqlite-inspection/build.gradle
@@ -32,6 +32,7 @@
 }
 
 dependencies {
+    api(libs.jspecify)
     api("androidx.annotation:annotation:1.8.1")
     compileOnly(project(":inspection:inspection"))
 
@@ -51,8 +52,6 @@
     // the inspection protocol, which is alpha
     inceptionYear = "2019"
     description = "The implementation of SQLite Inspector."
-    // TODO: b/326456246
-    optOutJSpecify = true
 }
 
 android {
diff --git a/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/DatabaseExtensions.java b/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/DatabaseExtensions.java
index d3d98b9..9bcffcf 100644
--- a/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/DatabaseExtensions.java
+++ b/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/DatabaseExtensions.java
@@ -18,7 +18,7 @@
 
 import android.database.sqlite.SQLiteDatabase;
 
-import androidx.annotation.NonNull;
+import org.jspecify.annotations.NonNull;
 
 import java.io.File;
 import java.util.Objects;
diff --git a/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/DatabaseLockRegistry.java b/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/DatabaseLockRegistry.java
index 3f4b9af..eee1078 100644
--- a/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/DatabaseLockRegistry.java
+++ b/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/DatabaseLockRegistry.java
@@ -20,11 +20,12 @@
 import android.os.CancellationSignal;
 
 import androidx.annotation.GuardedBy;
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;
 import androidx.sqlite.inspection.SqliteInspector.DatabaseConnection;
 
+import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.Nullable;
+
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.Executor;
@@ -48,7 +49,7 @@
     // A dedicated thread required as database transactions are tied to a thread. In order to
     // release a lock, we need to use the same thread as the one we used to establish the lock.
     // Thread names need to start with 'Studio:' as per some framework limitations.
-    @NonNull private final Executor mExecutor =
+    private final @NonNull Executor mExecutor =
             Executors.newSingleThreadExecutor(new ThreadFactory() {
                 @Override
                 public Thread newThread(Runnable r) {
diff --git a/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/DatabaseRegistry.java b/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/DatabaseRegistry.java
index ec47a8f..87e4a3f 100644
--- a/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/DatabaseRegistry.java
+++ b/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/DatabaseRegistry.java
@@ -23,8 +23,9 @@
 import android.util.ArraySet;
 
 import androidx.annotation.GuardedBy;
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
+
+import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.Nullable;
 
 import java.util.HashMap;
 import java.util.Iterator;
@@ -250,8 +251,7 @@
      * Consumer of this method must release the reference when done using it.
      * Thread-safe
      */
-    @Nullable
-    SQLiteDatabase getConnection(int databaseId) {
+    @Nullable SQLiteDatabase getConnection(int databaseId) {
         synchronized (mLock) {
             return getConnectionImpl(databaseId);
         }
diff --git a/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/EntryExitMatchingHookRegistry.java b/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/EntryExitMatchingHookRegistry.java
index 8e6aa48..473c4c1 100644
--- a/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/EntryExitMatchingHookRegistry.java
+++ b/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/EntryExitMatchingHookRegistry.java
@@ -16,12 +16,13 @@
 
 package androidx.sqlite.inspection;
 
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
 import androidx.inspection.ArtTooling.EntryHook;
 import androidx.inspection.ArtTooling.ExitHook;
 import androidx.inspection.InspectorEnvironment;
 
+import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.Nullable;
+
 import java.util.ArrayDeque;
 import java.util.Deque;
 import java.util.List;
@@ -44,9 +45,8 @@
     EntryExitMatchingHookRegistry(InspectorEnvironment environment) {
         mEnvironment = environment;
         mFrameStack = new ThreadLocal<Deque<Frame>>() {
-            @NonNull
             @Override
-            protected Deque<Frame> initialValue() {
+            protected @NonNull Deque<Frame> initialValue() {
                 return new ArrayDeque<>();
             }
         };
diff --git a/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/RoomInvalidationRegistry.java b/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/RoomInvalidationRegistry.java
index 566c732..d987c3f 100644
--- a/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/RoomInvalidationRegistry.java
+++ b/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/RoomInvalidationRegistry.java
@@ -19,10 +19,11 @@
 import android.annotation.SuppressLint;
 import android.util.Log;
 
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
 import androidx.inspection.InspectorEnvironment;
 
+import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.Nullable;
+
 import java.lang.ref.WeakReference;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
@@ -45,14 +46,12 @@
     /**
      * Might be null if application does not ship with Room.
      */
-    @Nullable
-    private final InvalidationTrackerInvoker mInvoker;
+    private final @Nullable InvalidationTrackerInvoker mInvoker;
 
     /**
      * The list of InvalidationTracker instances.
      */
-    @Nullable
-    private List<WeakReference<?>> mInvalidationInstances = null;
+    private @Nullable List<WeakReference<?>> mInvalidationInstances = null;
 
     RoomInvalidationRegistry(InspectorEnvironment environment) {
         mEnvironment = environment;
@@ -85,8 +84,7 @@
         mInvalidationInstances = null;
     }
 
-    @NonNull
-    private List<WeakReference<?>> getInvalidationTrackerInstances() {
+    private @NonNull List<WeakReference<?>> getInvalidationTrackerInstances() {
         List<WeakReference<?>> cached = mInvalidationInstances;
         if (cached != null) {
             return cached;
@@ -105,8 +103,7 @@
         return cached;
     }
 
-    @Nullable
-    private InvalidationTrackerInvoker findInvalidationTrackerClass() {
+    private @Nullable InvalidationTrackerInvoker findInvalidationTrackerClass() {
         try {
             ClassLoader classLoader = RoomInvalidationRegistry.class.getClassLoader();
             if (classLoader != null) {
@@ -124,8 +121,7 @@
      */
     static class InvalidationTrackerInvoker {
         public final Class<?> invalidationTrackerClass;
-        @Nullable
-        private final Method mRefreshMethod;
+        private final @Nullable Method mRefreshMethod;
 
         InvalidationTrackerInvoker(Class<?> invalidationTrackerClass) {
             this.invalidationTrackerClass = invalidationTrackerClass;
diff --git a/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/SqlDelight2Invalidation.java b/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/SqlDelight2Invalidation.java
index 5598d1a..19e6c4e 100644
--- a/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/SqlDelight2Invalidation.java
+++ b/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/SqlDelight2Invalidation.java
@@ -19,9 +19,10 @@
 import android.annotation.SuppressLint;
 import android.util.Log;
 
-import androidx.annotation.NonNull;
 import androidx.inspection.ArtTooling;
 
+import org.jspecify.annotations.NonNull;
+
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.Map;
diff --git a/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/SqlDelightInvalidation.java b/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/SqlDelightInvalidation.java
index e37adfe..a012621 100644
--- a/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/SqlDelightInvalidation.java
+++ b/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/SqlDelightInvalidation.java
@@ -19,9 +19,10 @@
 import android.annotation.SuppressLint;
 import android.util.Log;
 
-import androidx.annotation.NonNull;
 import androidx.inspection.ArtTooling;
 
+import org.jspecify.annotations.NonNull;
+
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.Objects;
@@ -37,8 +38,7 @@
     private final @NonNull Class<?> mQueryClass;
     private final @NonNull Method mNotifyDataChangeMethod;
 
-    @NonNull
-    static Invalidation create(@NonNull ArtTooling artTooling) {
+    static @NonNull Invalidation create(@NonNull ArtTooling artTooling) {
         ClassLoader classLoader = SqlDelightInvalidation.class.getClassLoader();
         Objects.requireNonNull(classLoader);
         try {
diff --git a/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/SqliteInspector.java b/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/SqliteInspector.java
index c29c45f..e043571 100644
--- a/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/SqliteInspector.java
+++ b/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/SqliteInspector.java
@@ -43,8 +43,6 @@
 import android.os.CancellationSignal;
 import android.util.Log;
 
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
 import androidx.inspection.ArtTooling;
 import androidx.inspection.ArtTooling.EntryHook;
 import androidx.inspection.ArtTooling.ExitHook;
@@ -81,6 +79,9 @@
 
 import com.google.protobuf.ByteString;
 
+import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.Nullable;
+
 import java.io.File;
 import java.io.PrintWriter;
 import java.io.StringWriter;
@@ -211,7 +212,7 @@
     }
 
     @Override
-    public void onReceiveCommand(@NonNull byte[] data, @NonNull CommandCallback callback) {
+    public void onReceiveCommand(byte @NonNull [] data, @NonNull CommandCallback callback) {
         try {
             Command command = Command.parseFrom(data);
             switch (command.getOneOfCase()) {
@@ -688,7 +689,7 @@
 
     @SuppressLint("Recycle") // For: "The cursor should be freed up after use with #close"
     private static Cursor rawQuery(@NonNull SQLiteDatabase database, @NonNull String queryText,
-            @NonNull final String[] params, @Nullable CancellationSignal cancellationSignal) {
+            final String @NonNull [] params, @Nullable CancellationSignal cancellationSignal) {
         SQLiteDatabase.CursorFactory cursorFactory = new SQLiteDatabase.CursorFactory() {
             @Override
             public Cursor newCursor(SQLiteDatabase db, SQLiteCursorDriver driver,
@@ -710,8 +711,7 @@
                 cancellationSignal);
     }
 
-    @NonNull
-    private static String[] parseQueryParameterValues(QueryCommand command) {
+    private static String @NonNull [] parseQueryParameterValues(QueryCommand command) {
         String[] params = new String[command.getQueryParameterValuesCount()];
         for (int i = 0; i < command.getQueryParameterValuesCount(); i++) {
             QueryParameterValue param = command.getQueryParameterValues(i);
@@ -745,8 +745,8 @@
      *
      * @return null if no database found for the provided id. A database reference otherwise.
      */
-    @Nullable
-    private DatabaseConnection acquireConnection(int databaseId, CommandCallback callback) {
+    private @Nullable DatabaseConnection acquireConnection(int databaseId,
+            CommandCallback callback) {
         DatabaseConnection connection = mDatabaseLockRegistry.getConnection(databaseId);
         if (connection != null) {
             // With WAL enabled, we prefer to use the IO executor. With WAL off we don't have a
@@ -951,8 +951,7 @@
                 .build();
     }
 
-    @NonNull
-    private static String stackTraceFromException(Exception exception) {
+    private static @NonNull String stackTraceFromException(Exception exception) {
         StringWriter writer = new StringWriter();
         exception.printStackTrace(new PrintWriter(writer));
         return writer.toString();
@@ -970,8 +969,8 @@
      * needs to run queries on the thread that locked it.
      */
     static final class DatabaseConnection {
-        @NonNull final SQLiteDatabase mDatabase;
-        @NonNull final Executor mExecutor;
+        final @NonNull SQLiteDatabase mDatabase;
+        final @NonNull Executor mExecutor;
 
         DatabaseConnection(@NonNull SQLiteDatabase database, @NonNull Executor executor) {
             mDatabase = database;
diff --git a/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/SqliteInspectorFactory.java b/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/SqliteInspectorFactory.java
index db69c72..e3d2f01 100644
--- a/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/SqliteInspectorFactory.java
+++ b/sqlite/sqlite-inspection/src/main/java/androidx/sqlite/inspection/SqliteInspectorFactory.java
@@ -16,11 +16,12 @@
 
 package androidx.sqlite.inspection;
 
-import androidx.annotation.NonNull;
 import androidx.inspection.Connection;
 import androidx.inspection.InspectorEnvironment;
 import androidx.inspection.InspectorFactory;
 
+import org.jspecify.annotations.NonNull;
+
 /**
  * Factory for SqliteInspector
  */
@@ -32,9 +33,8 @@
         super(SQLITE_INSPECTOR_ID);
     }
 
-    @NonNull
     @Override
-    public SqliteInspector createInspector(@NonNull Connection connection,
+    public @NonNull SqliteInspector createInspector(@NonNull Connection connection,
             @NonNull InspectorEnvironment environment) {
         return new SqliteInspector(connection, environment);
     }
