@@ -5,19 +5,21 @@
 import java.util.List;
 import java.util.ServiceLoader;
 import java.util.Set;
-import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
 import java.util.logging.Logger;
 import java.util.stream.Collectors;
 
 import jakarta.enterprise.inject.Instance;
 
+import org.a2aproject.sdk.server.multitenancy.AgentCardRouter;
+import org.a2aproject.sdk.server.multitenancy.TenantNotFoundException;
 import org.a2aproject.sdk.server.util.CdiUtils;
 import org.a2aproject.sdk.spec.AgentCard;
-import org.jspecify.annotations.Nullable;
 import org.a2aproject.sdk.spec.AgentInterface;
 import org.a2aproject.sdk.spec.TransportProtocol;
+import org.jspecify.annotations.Nullable;
 
 /**
  * Validates AgentCard transport configuration against available transport endpoints.
@@ -35,41 +37,52 @@ public class AgentCardValidator {
     public static final String SKIP_GRPC_PROPERTY = "org.a2aproject.sdk.transport.grpc.skipValidation";
     public static final String SKIP_REST_PROPERTY = "org.a2aproject.sdk.transport.rest.skipValidation";
 
+    /**
+     * Creates a new thread-safe set for tracking which {@link AgentCard} instances have already
+     * been validated. Each distinct card is validated at most once; subsequent requests for the
+     * same card skip validation.
+     *
+     * @return a concurrent set suitable for use as the {@code validatedCards} parameter
+     */
+    public static Set<AgentCard> newValidatedCardsSet() {
+        return ConcurrentHashMap.newKeySet();
+    }
+
     /**
      * Resolves an {@link AgentCard} from the given {@link Instance} and validates its transport
-     * configuration exactly once using the default {@link #validateTransportConfiguration} check.
-     * The {@code transportValidated} guard is reset on failure so validation can be retried on
-     * the next call.
+     * configuration once per distinct card using the default
+     * {@link #validateTransportConfiguration} check. On failure the card is removed from the
+     * set so validation can be retried on the next call.
      *
      * @param agentCardInstance the CDI instance holding the agent card
-     * @param transportValidated atomic guard ensuring validation runs once
+     * @param validatedCards set tracking which cards have already been validated
      * @return the resolved agent card
      */
     public static AgentCard resolveAndValidateOnce(Instance<AgentCard> agentCardInstance,
-            AtomicBoolean transportValidated) {
-        return resolveAndValidateOnce(agentCardInstance::get, transportValidated,
+            Set<AgentCard> validatedCards) {
+        return resolveAndValidateOnce(agentCardInstance::get, validatedCards,
                 AgentCardValidator::validateTransportConfiguration);
     }
 
     /**
      * Obtains an {@link AgentCard} from the given supplier and applies the provided validator
-     * exactly once. The {@code transportValidated} guard is reset on failure so validation can
-     * be retried on the next call.
+     * once per distinct card. On failure the card is removed from the set so validation can be
+     * retried on the next call.
      *
      * @param agentCardSupplier supplier that produces the agent card
-     * @param transportValidated atomic guard ensuring validation runs once
+     * @param validatedCards set tracking which cards have already been validated
      * @param validator validation logic to apply on first access
      * @return the resolved agent card
      */
     public static AgentCard resolveAndValidateOnce(Supplier<AgentCard> agentCardSupplier,
-            AtomicBoolean transportValidated,
+            Set<AgentCard> validatedCards,
             Consumer<AgentCard> validator) {
         AgentCard card = agentCardSupplier.get();
-        if (transportValidated.compareAndSet(false, true)) {
+        if (validatedCards.add(card)) {
             try {
                 validator.accept(card);
             } catch (RuntimeException e) {
-                transportValidated.set(false);
+                validatedCards.remove(card);
                 throw e;
             }
         }
@@ -82,23 +95,96 @@ public static AgentCard resolveAndValidateOnce(Supplier<AgentCard> agentCardSupp
      *
      * @param publicCard the CDI instance for the {@code @PublicAgentCard}
      * @param extendedCard the CDI instance for the {@code @ExtendedAgentCard}, may be {@code null}
-     * @param transportValidated atomic guard ensuring validation runs once
+     * @param validatedCards set tracking which cards have already been validated
      * @return the resolved agent card
      * @throws IllegalStateException if neither card is available
      */
     public static AgentCard resolveWithFallback(Instance<AgentCard> publicCard,
             @Nullable Instance<AgentCard> extendedCard,
-            AtomicBoolean transportValidated) {
+            Set<AgentCard> validatedCards) {
+        return resolveWithFallback(publicCard, extendedCard, null, null, validatedCards);
+    }
+
+    /**
+     * Resolves an agent card using one of two resolution strategies depending on whether a
+     * tenant-scoped request is being made.
+     *
+     * <p><strong>Tenant-scoped</strong> (non-blank tenant with a router): only the
+     * {@link AgentCardRouter} is consulted. CDI default beans are <em>not</em> used as
+     * fallbacks — doing so would let the request proceed against the wrong tenant's card.
+     * <ol>
+     *   <li>Tenant-specific public card via the router</li>
+     *   <li>Tenant-specific extended card via the router</li>
+     *   <li>{@link TenantNotFoundException} if neither is registered</li>
+     * </ol>
+     *
+     * <p><strong>Non-tenant-scoped</strong> (no tenant, blank tenant, or no router):
+     * <ol>
+     *   <li>Unqualified {@code @PublicAgentCard} CDI bean</li>
+     *   <li>Router's public card (when no default bean exists)</li>
+     *   <li>Unqualified {@code @ExtendedAgentCard} CDI bean</li>
+     *   <li>Router's extended card (when no default bean exists)</li>
+     *   <li>{@link IllegalStateException} if nothing resolves</li>
+     * </ol>
+     *
+     * @param publicCard the CDI instance for the {@code @PublicAgentCard}
+     * @param extendedCard the CDI instance for the {@code @ExtendedAgentCard}, may be {@code null}
+     * @param agentCardRouter optional router for tenant-specific card resolution
+     * @param tenant the tenant identifier, may be {@code null}
+     * @param validatedCards set tracking which cards have already been validated
+     * @return the resolved agent card
+     * @throws TenantNotFoundException if a non-blank tenant is specified, a router is available,
+     *         but neither a public nor extended card is registered for that tenant
+     * @throws IllegalStateException if no card can be resolved (non-tenant-scoped path)
+     */
+    public static AgentCard resolveWithFallback(Instance<AgentCard> publicCard,
+            @Nullable Instance<AgentCard> extendedCard,
+            @Nullable AgentCardRouter agentCardRouter,
+            @Nullable String tenant,
+            Set<AgentCard> validatedCards) {
+        // When a tenant is specified and a router is available, only the router
+        // determines resolution.  A null result means the tenant is unknown per
+        // the AgentCardRouter contract — falling through to default beans would
+        // let the request proceed against the wrong tenant's card.
+        if (tenant != null && !tenant.isBlank() && agentCardRouter != null) {
+            AgentCard routerCard = agentCardRouter.resolvePublicCard(tenant);
+            if (routerCard != null) {
+                return resolveAndValidateOnce(() -> routerCard, validatedCards,
+                        AgentCardValidator::validateTransportConfiguration);
+            }
+            AgentCard routerExtCard = agentCardRouter.resolveExtendedCard(tenant);
+            if (routerExtCard != null) {
+                return resolveAndValidateOnce(() -> routerExtCard, validatedCards,
+                        AgentCardValidator::validateTransportConfiguration);
+            }
+            throw new TenantNotFoundException(tenant);
+        }
+        // --- Public cards ---
         AgentCard resolved = CdiUtils.resolveDefault(publicCard);
         if (resolved != null) {
-            return resolveAndValidateOnce(() -> resolved, transportValidated,
+            return resolveAndValidateOnce(() -> resolved, validatedCards,
                     AgentCardValidator::validateTransportConfiguration);
         }
+        if (agentCardRouter != null) {
+            AgentCard routerCard = agentCardRouter.resolvePublicCard(tenant);
+            if (routerCard != null) {
+                return resolveAndValidateOnce(() -> routerCard, validatedCards,
+                        AgentCardValidator::validateTransportConfiguration);
+            }
+        }
+        // --- Extended cards ---
         AgentCard extResolved = CdiUtils.resolveDefault(extendedCard);
         if (extResolved != null) {
-            return resolveAndValidateOnce(() -> extResolved, transportValidated,
+            return resolveAndValidateOnce(() -> extResolved, validatedCards,
                     AgentCardValidator::validateTransportConfiguration);
         }
+        if (agentCardRouter != null) {
+            AgentCard routerExtCard = agentCardRouter.resolveExtendedCard(tenant);
+            if (routerExtCard != null) {
+                return resolveAndValidateOnce(() -> routerExtCard, validatedCards,
+                        AgentCardValidator::validateTransportConfiguration);
+            }
+        }
         throw new IllegalStateException(NO_AGENT_CARD_MESSAGE);
     }