diff --git a/nullaway/src/main/java/com/uber/nullaway/NullAway.java b/nullaway/src/main/java/com/uber/nullaway/NullAway.java
index db5b9585b6..94e7911b4c 100644
--- a/nullaway/src/main/java/com/uber/nullaway/NullAway.java
+++ b/nullaway/src/main/java/com/uber/nullaway/NullAway.java
@@ -2083,15 +2083,20 @@ private Description handleInvocation(
         }
       }
 
-      // perform generics checks for calls to annotated methods in JSpecify mode
-      if (config.isJSpecifyMode()) {
-        genericsChecks.compareGenericTypeParameterNullabilityForCall(methodSymbol, tree, state);
-        if (!methodSymbol.getTypeParameters().isEmpty()) {
-          genericsChecks.checkGenericMethodCallTypeArguments(tree, state);
-        }
+      // perform generics checks for type arguments on calls to annotated methods in JSpecify mode
+      if (config.isJSpecifyMode() && !methodSymbol.getTypeParameters().isEmpty()) {
+        genericsChecks.checkGenericMethodCallTypeArguments(tree, state);
       }
     }
 
+    // Perform generics checks for calls in JSpecify mode, including calls to @NullUnmarked
+    // methods.  For @NullUnmarked methods, only restrictive (explicit) nullness annotations
+    // on type parameters are enforced (see #1488).
+    if (config.isJSpecifyMode()) {
+      genericsChecks.compareGenericTypeParameterNullabilityForCall(
+          methodSymbol, tree, state, isMethodAnnotated);
+    }
+
     // Allow handlers to override the list of non-null argument positions. For a varargs parameter,
     // this array holds the nullness of individual varargs arguments; the case of a varargs array is
     // handled separately
diff --git a/nullaway/src/main/java/com/uber/nullaway/generics/CheckIdenticalNullabilityVisitor.java b/nullaway/src/main/java/com/uber/nullaway/generics/CheckIdenticalNullabilityVisitor.java
index bb8f9a604a..eb628fe29a 100644
--- a/nullaway/src/main/java/com/uber/nullaway/generics/CheckIdenticalNullabilityVisitor.java
+++ b/nullaway/src/main/java/com/uber/nullaway/generics/CheckIdenticalNullabilityVisitor.java
@@ -5,6 +5,7 @@
 import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.code.Types;
 import com.uber.nullaway.Config;
+import com.uber.nullaway.Nullness;
 import java.util.List;
 import javax.lang.model.type.NullType;
 import javax.lang.model.type.TypeKind;
@@ -18,12 +19,22 @@ public class CheckIdenticalNullabilityVisitor extends Types.DefaultTypeVisitor<B
   private final VisitorState state;
   private final GenericsChecks genericsChecks;
   private final Config config;
+  private final boolean isMethodUnannotated;
 
   CheckIdenticalNullabilityVisitor(
       VisitorState state, GenericsChecks genericsChecks, Config config) {
+    this(state, genericsChecks, config, false);
+  }
+
+  CheckIdenticalNullabilityVisitor(
+      VisitorState state,
+      GenericsChecks genericsChecks,
+      Config config,
+      boolean isMethodUnannotated) {
     this.state = state;
     this.genericsChecks = genericsChecks;
     this.config = config;
+    this.isMethodUnannotated = isMethodUnannotated;
   }
 
   @Override
@@ -71,7 +82,12 @@ public Boolean visitClassType(Type.ClassType lhsType, Type rhsType) {
       boolean isLHSNullableAnnotated = genericsChecks.isNullableAnnotated(lhsTypeArgument);
       boolean isRHSNullableAnnotated = genericsChecks.isNullableAnnotated(rhsTypeArgument);
       if (isLHSNullableAnnotated != isRHSNullableAnnotated) {
-        return false;
+        if (shouldSkipMismatchInUnannotatedMethod(lhsTypeArgument, isLHSNullableAnnotated)) {
+          // LHS is unannotated in @NullUnmarked context; skip this level but still check
+          // nested types below (which may have restrictive annotations)
+        } else {
+          return false;
+        }
       }
       // nested generics
       if (!lhsTypeArgument.accept(this, rhsTypeArgument)) {
@@ -107,11 +123,29 @@ public Boolean visitArrayType(Type.ArrayType lhsType, Type rhsType) {
     boolean isLHSNullableAnnotated = genericsChecks.isNullableAnnotated(lhsComponentType);
     boolean isRHSNullableAnnotated = genericsChecks.isNullableAnnotated(rhsComponentType);
     if (isRHSNullableAnnotated != isLHSNullableAnnotated) {
-      return false;
+      if (shouldSkipMismatchInUnannotatedMethod(lhsComponentType, isLHSNullableAnnotated)) {
+        // LHS component is unannotated in @NullUnmarked context; skip this level
+      } else {
+        return false;
+      }
     }
     return lhsComponentType.accept(this, rhsComponentType);
   }
 
+  /**
+   * Returns {@code true} when a nullability mismatch should be skipped because the LHS type has no
+   * explicit nullness annotation and we are inside {@code @NullUnmarked} code.
+   *
+   * @param lhsType the formal (LHS) type whose annotations are inspected
+   * @param isLhsNullableAnnotated whether {@code lhsType} carries a {@code @Nullable} annotation
+   */
+  private boolean shouldSkipMismatchInUnannotatedMethod(
+      Type lhsType, boolean isLhsNullableAnnotated) {
+    return isMethodUnannotated
+        && !isLhsNullableAnnotated
+        && !Nullness.hasNonNullAnnotation(lhsType.getAnnotationMirrors().stream(), config);
+  }
+
   @Override
   public Boolean visitType(Type t, Type type) {
     return true;
diff --git a/nullaway/src/main/java/com/uber/nullaway/generics/GenericsChecks.java b/nullaway/src/main/java/com/uber/nullaway/generics/GenericsChecks.java
index 5127cf2acd..2da1cdf5ec 100644
--- a/nullaway/src/main/java/com/uber/nullaway/generics/GenericsChecks.java
+++ b/nullaway/src/main/java/com/uber/nullaway/generics/GenericsChecks.java
@@ -1438,19 +1438,25 @@ public void checkTypeParameterNullnessForFunctionReturnType(
    * @param state the visitor state
    */
   private boolean identicalTypeParameterNullability(
-      Type lhsType, Type rhsType, VisitorState state) {
-    return lhsType.accept(new CheckIdenticalNullabilityVisitor(state, this, config), rhsType);
+      Type lhsType, Type rhsType, VisitorState state, boolean isMethodUnannotated) {
+    return lhsType.accept(
+        new CheckIdenticalNullabilityVisitor(state, this, config, isMethodUnannotated), rhsType);
   }
 
   /**
-   * Like {@link #identicalTypeParameterNullability(Type, Type, VisitorState)}, but allows for
-   * covariant array subtyping at the top level.
+   * Like {@link #identicalTypeParameterNullability(Type, Type, VisitorState, boolean)}, but allows
+   * for covariant array subtyping at the top level.
    *
    * @param lhsType type for the lhs of the assignment
    * @param rhsType type for the rhs of the assignment
    * @param state the visitor state
    */
   private boolean subtypeParameterNullability(Type lhsType, Type rhsType, VisitorState state) {
+    return subtypeParameterNullability(lhsType, rhsType, state, false);
+  }
+
+  private boolean subtypeParameterNullability(
+      Type lhsType, Type rhsType, VisitorState state, boolean isMethodUnannotated) {
     if (lhsType.isRaw()) {
       return true;
     }
@@ -1466,11 +1472,19 @@ private boolean subtypeParameterNullability(Type lhsType, Type rhsType, VisitorS
       boolean isRHSNullableAnnotated = isNullableAnnotated(rhsComponentType);
       // an array of @Nullable references is _not_ a subtype of an array of @NonNull references
       if (isRHSNullableAnnotated && !isLHSNullableAnnotated) {
-        return false;
+        // In @NullUnmarked code, skip if the LHS component has no explicit nullness annotation
+        if (isMethodUnannotated
+            && !Nullness.hasNonNullAnnotation(
+                lhsComponentType.getAnnotationMirrors().stream(), config)) {
+          // unannotated component in @NullUnmarked context; fall through to nested check
+        } else {
+          return false;
+        }
       }
-      return identicalTypeParameterNullability(lhsComponentType, rhsComponentType, state);
+      return identicalTypeParameterNullability(
+          lhsComponentType, rhsComponentType, state, isMethodUnannotated);
     } else {
-      return identicalTypeParameterNullability(lhsType, rhsType, state);
+      return identicalTypeParameterNullability(lhsType, rhsType, state, isMethodUnannotated);
     }
   }
 
@@ -1553,9 +1567,12 @@ public void checkTypeParameterNullnessForConditionalExpression(
    * @param methodSymbol the symbol for the method being called
    * @param tree the tree representing the method call
    * @param state the visitor state
+   * @param isMethodAnnotated whether the called method is in annotated (non-{@code @NullUnmarked})
+   *     code. When {@code false}, only restrictive (explicit) nullness annotations on type
+   *     parameters are enforced.
    */
   public void compareGenericTypeParameterNullabilityForCall(
-      Symbol.MethodSymbol methodSymbol, Tree tree, VisitorState state) {
+      Symbol.MethodSymbol methodSymbol, Tree tree, VisitorState state, boolean isMethodAnnotated) {
     Config config = analysis.getConfig();
     if (!config.isJSpecifyMode()) {
       return;
@@ -1602,13 +1619,15 @@ public void compareGenericTypeParameterNullabilityForCall(
                 // the type of the method reference tree provided by javac may not capture
                 // nullability of nested types. So, do explicit type checks based on the return and
                 // parameter types of the referenced method
+                boolean isUnannotated = !isMethodAnnotated;
                 GenericsUtils.processMethodRefTypeRelations(
                     this,
                     formalParameter,
                     memberReferenceTree,
                     state,
                     (subtype, supertype, relationKind) -> {
-                      if (!subtypeParameterNullability(supertype, subtype, state)) {
+                      if (!subtypeParameterNullability(
+                          supertype, subtype, state, isUnannotated)) {
                         if (relationKind == MethodRefTypeRelationKind.RETURN) {
                           reportInvalidMethodReferenceReturnTypeError(
                               memberReferenceTree, supertype, subtype, state);
@@ -1646,7 +1665,8 @@ public void compareGenericTypeParameterNullabilityForCall(
                           false,
                           false);
                 }
-                if (!subtypeParameterNullability(formalParameter, actualParameterType, state)) {
+                if (!subtypeParameterNullability(
+                    formalParameter, actualParameterType, state, !isMethodAnnotated)) {
                   reportInvalidParametersNullabilityError(
                       formalParameter, actualParameterType, currentActualParam, state);
                 }
@@ -1929,8 +1949,12 @@ private Type substituteTypeArgsInGenericMethodType(
         return TypeSubstitutionUtils.updateMethodTypeWithInferredNullability(
             methodTypeAtCallSite, methodType, successResult.typeVarNullability, state, config);
       } else {
-        // inference failed; just return the method type at the call site with no substitutions
-        return methodTypeAtCallSite;
+        // inference failed; restore explicit nullability annotations from the original method
+        // type to the call-site type, so restrictive annotations (e.g. @NonNull on type
+        // arguments) are still enforced
+        return TypeSubstitutionUtils.restoreExplicitNullabilityAnnotations(
+                methodType, methodTypeAtCallSite, config, Collections.emptyMap())
+            .asMethodType();
       }
     }
     return TypeSubstitutionUtils.subst(
diff --git a/nullaway/src/test/java/com/uber/nullaway/jspecify/NullMarkednessTests.java b/nullaway/src/test/java/com/uber/nullaway/jspecify/NullMarkednessTests.java
index 2345fb50b6..feea2da5d7 100644
--- a/nullaway/src/test/java/com/uber/nullaway/jspecify/NullMarkednessTests.java
+++ b/nullaway/src/test/java/com/uber/nullaway/jspecify/NullMarkednessTests.java
@@ -1031,6 +1031,78 @@ public static void caller() {
         .doTest();
   }
 
+  @Test
+  public void nullUnmarkedRestrictiveAnnotationsOnTypeVariables() {
+    makeTestHelperWithArgs(
+            JSpecifyJavacConfig.withJSpecifyModeArgs(
+                Arrays.asList(
+                    "-d",
+                    temporaryFolder.getRoot().getAbsolutePath(),
+                    "-XepOpt:NullAway:OnlyNullMarked=true")))
+        .addSourceLines(
+            "Test.java",
+            """
+            package com.uber;
+            import org.jspecify.annotations.NonNull;
+            import org.jspecify.annotations.NullMarked;
+            import org.jspecify.annotations.NullUnmarked;
+            import org.jspecify.annotations.Nullable;
+            @NullMarked
+            class Test {
+              interface Foo<T extends @Nullable Object> {}
+              @NullUnmarked
+              static void takeFoo(Foo<@NonNull String> f) {}
+              @NullUnmarked
+              static <T> T identity(Foo<@NonNull T> t) {
+                throw new RuntimeException("not implemented");
+              }
+              void test(Foo<@Nullable String> s, Foo<String> nonNullFoo) {
+                // Error: passing Foo<@Nullable String> where Foo<@NonNull String> is required
+                // BUG: Diagnostic contains: incompatible types
+                takeFoo(s);
+                // OK: passing Foo<String> where Foo<@NonNull String> is required
+                takeFoo(nonNullFoo);
+                // Error: passing Foo<@Nullable String> to generic identity method
+                // with restrictive @NonNull on type parameter
+                // BUG: Diagnostic contains: incompatible types
+                String x = identity(s);
+                // OK: passing Foo<String> where Foo<@NonNull String> is expected
+                String y = identity(nonNullFoo);
+              }
+            }
+            """)
+        .doTest();
+  }
+
+  @Test
+  public void nullUnmarkedUnannotatedTypeVariableNoError() {
+    makeTestHelperWithArgs(
+            JSpecifyJavacConfig.withJSpecifyModeArgs(
+                Arrays.asList(
+                    "-d",
+                    temporaryFolder.getRoot().getAbsolutePath(),
+                    "-XepOpt:NullAway:OnlyNullMarked=true")))
+        .addSourceLines(
+            "Test.java",
+            """
+            package com.uber;
+            import org.jspecify.annotations.NullMarked;
+            import org.jspecify.annotations.NullUnmarked;
+            import org.jspecify.annotations.Nullable;
+            import java.util.List;
+            @NullMarked
+            class Test {
+              @NullUnmarked
+              static <T> void bar(List<T> list) {}
+              void test(List<@Nullable String> s) {
+                // No error: T is unannotated in @NullUnmarked code, so unconstrained
+                bar(s);
+              }
+            }
+            """)
+        .doTest();
+  }
+
   @Test
   public void nullUnmarkedOuterMethodLevelWithLocalClass() {
     defaultCompilationHelper