@@ -545,6 +545,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- **Annotated agents work as framework-proxied beans and with inherited handlers.**
+  `AcpAgentSupport` read `@AcpAgent` and the handler methods from the bean's own class only. A
+  proxy that Spring (CGLIB), Quarkus (ArC) or Micronaut (AOP) generates for the bean is an
+  unannotated subclass, so `create(proxy)` failed with "Class must be annotated with @AcpAgent",
+  and handlers declared on a superclass were never found (the client got `-32601`). Discovery
+  now walks the class hierarchy: `@AcpAgent` may be on a superclass, handlers are collected
+  from every class up to `Object` and invoked on the instance given (through the proxy, so its
+  interceptors run), an annotated override is one handler, and bridge and synthetic methods are
+  skipped. `agentInfo.name` defaults to the annotated class's simple name, not the proxy's.
+
 - **An annotated agent advertises what its annotations declare.** Without an `@Initialize` method,
   `AcpAgentSupport` answered `initialize` with `InitializeResponse.ok()`: `loadSession: false`, no
   session, auth or provider capabilities, no `authMethods` and no `agentInfo`. An agent with
 
@@ -50,7 +50,7 @@ This module transitively includes `acp-annotations` and `acp-core`.
 
 | Annotation | Description |
 |------------|-------------|
-| `@AcpAgent` | Marks a class as an ACP agent. Required on all agent classes. Its attributes are advertised in the `initialize` response: `name`, `version` and `title` as `agentInfo` (the name defaults to the class's simple name, the version to the jar manifest's `Implementation-Version`, else `"unknown"`), `authMethods` (`@AuthMethod`s) as `authMethods`, and `mcpHttp`/`mcpSse` as `mcpCapabilities`. |
+| `@AcpAgent` | Marks a class as an ACP agent. Required on the agent class or a superclass of it: handlers are discovered on the class and its superclasses, so a framework proxy of the bean (Spring CGLIB, Quarkus ArC, Micronaut AOP) is accepted and invoked through the proxy. Its attributes are advertised in the `initialize` response: `name`, `version` and `title` as `agentInfo` (the name defaults to the class's simple name, the version to the jar manifest's `Implementation-Version`, else `"unknown"`), `authMethods` (`@AuthMethod`s) as `authMethods`, and `mcpHttp`/`mcpSse` as `mcpCapabilities`. |
 | `@AuthMethod` | One authentication method inside `@AcpAgent(authMethods = ...)`: `id`, `name`, `description`, and `type` `AGENT` (served by `@Authenticate`) or `TERMINAL` (the client reruns the agent program with `args` and `env`). |
 
 ### Handler Methods
 
@@ -12,9 +12,11 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.UUID;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
@@ -673,27 +675,88 @@ private Definition definition() {
 					List.copyOf(interceptors), requestTimeout, cancelGracePeriod, maxPromptDuration);
 		}
 
+		/**
+		 * Discovers the handler methods of {@code agentClass} and its superclasses, and binds
+		 * them to the one instance the factory gives. The {@code @AcpAgent} annotation may be on
+		 * a superclass, as it is for a proxy a framework generates (Spring CGLIB, Quarkus ArC,
+		 * Micronaut AOP), whose subclass carries no annotations: handlers are then found on the
+		 * user's class and invoked on the proxy, so its interceptors run. A method overridden in
+		 * a subclass is one handler, invoked virtually, and bridge and synthetic methods are not
+		 * handlers.
+		 */
 		private void discoverHandlers(Class<?> agentClass, Supplier<Object> instanceFactory) {
-			if (!agentClass.isAnnotationPresent(com.agentclientprotocol.sdk.annotation.AcpAgent.class)) {
-				throw new IllegalArgumentException("Class must be annotated with @AcpAgent: " + agentClass.getName());
+			Class<?> annotatedClass = annotatedAgentClass(agentClass);
+			if (annotatedClass == null) {
+				throw new IllegalArgumentException("Class must be annotated with @AcpAgent: " + agentClass.getName()
+						+ " (neither it nor a superclass is)");
 			}
-			AgentAdvertisement.validate(agentClass);
-			agentClasses.add(agentClass);
+			AgentAdvertisement.validate(annotatedClass);
+			agentClasses.add(annotatedClass);
 			// One instance for every handler and request: handlers share the agent's state
 			Object agentInstance = instanceFactory.get();
-			for (Method method : agentClass.getDeclaredMethods()) {
-				HANDLER_ANNOTATIONS.forEach((annotation, acpMethod) -> {
-					if (method.isAnnotationPresent(annotation)) {
-						handlers.put(acpMethod, new AcpHandlerMethod(agentInstance, method, acpMethod));
-						log.debug("Discovered @{} handler: {}", annotation.getSimpleName(), method.getName());
-					}
-				});
-				String extensionMethod = extensionMethod(method);
-				if (extensionMethod != null) {
-					handlers.put(extensionMethod, new AcpHandlerMethod(agentInstance, method, extensionMethod));
-					log.debug("Discovered extension handler for {}: {}", extensionMethod, method.getName());
+			Set<String> seen = new HashSet<>();
+			for (Class<?> type = agentClass; type != null && type != Object.class; type = type.getSuperclass()) {
+				discoverDeclaredHandlers(type, agentInstance, seen);
+			}
+		}
+
+		/**
+		 * Registers the handlers {@code type} declares, other than those an annotated override
+		 * below it already registered ({@code seen}, the signatures registered so far). An
+		 * unannotated override, such as a proxy's, leaves the annotations to the method it
+		 * overrides. A generic override's bridge stands for the erased method it overrides.
+		 */
+		private void discoverDeclaredHandlers(Class<?> type, Object agentInstance, Set<String> seen) {
+			Set<String> registeredHere = new HashSet<>();
+			for (Method method : type.getDeclaredMethods()) {
+				if (!method.isBridge() && !method.isSynthetic() && !seen.contains(signature(method))
+						&& discoverHandler(method, agentInstance)) {
+					registeredHere.add(method.getName());
+					seen.add(signature(method));
+				}
+			}
+			for (Method method : type.getDeclaredMethods()) {
+				if (method.isBridge() && registeredHere.contains(method.getName())) {
+					seen.add(signature(method));
+				}
+			}
+		}
+
+		/**
+		 * Registers {@code method} for each handler annotation it carries.
+		 * @return whether it carries any
+		 */
+		private boolean discoverHandler(Method method, Object agentInstance) {
+			boolean handler = false;
+			for (Map.Entry<Class<? extends Annotation>, String> entry : HANDLER_ANNOTATIONS.entrySet()) {
+				if (method.isAnnotationPresent(entry.getKey())) {
+					handlers.put(entry.getValue(), new AcpHandlerMethod(agentInstance, method, entry.getValue()));
+					log.debug("Discovered @{} handler: {}", entry.getKey().getSimpleName(), method.getName());
+					handler = true;
+				}
+			}
+			String extensionMethod = extensionMethod(method);
+			if (extensionMethod != null) {
+				handlers.put(extensionMethod, new AcpHandlerMethod(agentInstance, method, extensionMethod));
+				log.debug("Discovered extension handler for {}: {}", extensionMethod, method.getName());
+				handler = true;
+			}
+			return handler;
+		}
+
+		/** A method's name and parameter types, which an override shares. */
+		private static String signature(Method method) {
+			return method.getName() + Arrays.toString(method.getParameterTypes());
+		}
+
+		/** The first class from {@code type} up that is annotated {@code @AcpAgent}, or null. */
+		private static @Nullable Class<?> annotatedAgentClass(Class<?> type) {
+			for (Class<?> candidate = type; candidate != null; candidate = candidate.getSuperclass()) {
+				if (candidate.isAnnotationPresent(com.agentclientprotocol.sdk.annotation.AcpAgent.class)) {
+					return candidate;
 				}
 			}
+			return null;
 		}
 
 		/**
 
@@ -0,0 +1,216 @@
+/*
+ * Copyright 2026 the original author or authors.
+ */
+
+package com.agentclientprotocol.sdk.agent.support;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+
+import com.agentclientprotocol.sdk.annotation.AcpAgent;
+import com.agentclientprotocol.sdk.annotation.LoadSession;
+import com.agentclientprotocol.sdk.annotation.NewSession;
+import com.agentclientprotocol.sdk.annotation.Prompt;
+import com.agentclientprotocol.sdk.client.AcpAsyncClient;
+import com.agentclientprotocol.sdk.client.AcpClient;
+import com.agentclientprotocol.sdk.spec.AcpSchema;
+import com.agentclientprotocol.sdk.spec.AcpSchema.InitializeResponse;
+import com.agentclientprotocol.sdk.spec.AcpSchema.NewSessionResponse;
+import com.agentclientprotocol.sdk.spec.AcpSchema.PromptRequest;
+import com.agentclientprotocol.sdk.spec.AcpSchema.PromptResponse;
+import com.agentclientprotocol.sdk.test.InMemoryTransportPair;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+/**
+ * Handler discovery walks the class hierarchy: a bean that a framework proxies (Spring CGLIB,
+ * Quarkus ArC or Micronaut AOP generate a subclass that carries no annotations) is still found,
+ * and invoked through the proxy, so its interceptors run; handlers declared on a superclass are
+ * found; an override is one handler, not two; and the bridge method a generic override compiles
+ * to is not a handler of its own.
+ */
+class AgentDiscoveryTest {
+
+	private static final Duration TIMEOUT = Duration.ofSeconds(5);
+
+	@AcpAgent(name = "proxied", version = "1")
+	static class ProxiedAgent {
+
+		@NewSession
+		public NewSessionResponse newSession() {
+			return new NewSessionResponse("s1", null, null);
+		}
+
+		@LoadSession
+		public AcpSchema.LoadSessionResponse load() {
+			return new AcpSchema.LoadSessionResponse(null);
+		}
+
+		@Prompt
+		public PromptResponse prompt() {
+			return new PromptResponse(AcpSchema.StopReason.END_TURN);
+		}
+
+	}
+
+	/** What a CGLIB/ArC/Micronaut proxy looks like: an unannotated subclass overriding public methods. */
+	static class ProxiedAgent$$SpringCGLIB$$0 extends ProxiedAgent {
+
+		final AtomicInteger intercepted = new AtomicInteger();
+
+		@Override
+		public PromptResponse prompt() {
+			intercepted.incrementAndGet();
+			return super.prompt();
+		}
+
+		@Override
+		public NewSessionResponse newSession() {
+			intercepted.incrementAndGet();
+			return super.newSession();
+		}
+
+	}
+
+	@Test
+	void aProxiedBeanIsDiscoveredOnItsUserClassAndInvokedThroughTheProxy() {
+		ProxiedAgent$$SpringCGLIB$$0 proxy = new ProxiedAgent$$SpringCGLIB$$0();
+
+		InitializeResponse init = session(AcpAgentSupport.create(proxy), client -> {
+			assertThat(prompt(client)).isEqualTo(AcpSchema.StopReason.END_TURN);
+			return client.initialize().block(TIMEOUT);
+		});
+
+		assertThat(proxy.intercepted).as("newSession and prompt ran through the proxy").hasValue(2);
+		assertThat(init.agentCapabilities().loadSession()).isTrue();
+		assertThat(init.agentInfo().name()).isEqualTo("proxied");
+	}
+
+	@Test
+	void anAnonymousSubclassIsDiscoveredToo() {
+		AtomicInteger intercepted = new AtomicInteger();
+		ProxiedAgent anonymous = new ProxiedAgent() {
+			@Override
+			public PromptResponse prompt() {
+				intercepted.incrementAndGet();
+				return super.prompt();
+			}
+		};
+
+		session(AcpAgentSupport.create(anonymous), AgentDiscoveryTest::prompt);
+
+		assertThat(intercepted).hasValue(1);
+	}
+
+	abstract static class AbstractAgent {
+
+		@NewSession
+		NewSessionResponse newSession() {
+			return new NewSessionResponse("s1", null, null);
+		}
+
+		@Prompt
+		PromptResponse prompt(PromptRequest request) {
+			return new PromptResponse(AcpSchema.StopReason.MAX_TOKENS);
+		}
+
+	}
+
+	@AcpAgent
+	static class ConcreteAgent extends AbstractAgent {
+
+	}
+
+	@Test
+	void handlersOnAnAbstractSuperclassAreDiscovered() {
+		assertThat(session(AcpAgentSupport.create(new ConcreteAgent()), AgentDiscoveryTest::prompt))
+			.isEqualTo(AcpSchema.StopReason.MAX_TOKENS);
+	}
+
+	@AcpAgent
+	static class OverridingAgent extends AbstractAgent {
+
+		@Override
+		@Prompt
+		PromptResponse prompt(PromptRequest request) {
+			return new PromptResponse(AcpSchema.StopReason.REFUSAL);
+		}
+
+	}
+
+	@Test
+	void anAnnotatedOverrideIsOneHandlerAndTheOverrideRuns() {
+		assertThat(session(AcpAgentSupport.create(new OverridingAgent()), AgentDiscoveryTest::prompt))
+			.isEqualTo(AcpSchema.StopReason.REFUSAL);
+	}
+
+	abstract static class GenericAgent<R> {
+
+		@Prompt
+		abstract PromptResponse prompt(R request);
+
+	}
+
+	/** The override compiles to a bridge prompt(Object) that carries the annotation too. */
+	@AcpAgent
+	static class TypedAgent extends GenericAgent<PromptRequest> {
+
+		@NewSession
+		NewSessionResponse newSession() {
+			return new NewSessionResponse("s1", null, null);
+		}
+
+		@Override
+		@Prompt
+		PromptResponse prompt(PromptRequest request) {
+			return new PromptResponse(request.sessionId().equals("s1") ? AcpSchema.StopReason.END_TURN
+					: AcpSchema.StopReason.REFUSAL);
+		}
+
+	}
+
+	@Test
+	void aBridgeMethodIsNotAHandler() {
+		assertThat(session(AcpAgentSupport.create(new TypedAgent()), AgentDiscoveryTest::prompt))
+			.isEqualTo(AcpSchema.StopReason.END_TURN);
+	}
+
+	static class NotAnAgent {
+
+	}
+
+	@Test
+	void aClassWithNoAcpAgentInItsHierarchyIsRejectedNamingIt() {
+		assertThatThrownBy(() -> AcpAgentSupport.create(new NotAnAgent()))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessageContaining(NotAnAgent.class.getName())
+			.hasMessageContaining("@AcpAgent");
+	}
+
+	private static AcpSchema.StopReason prompt(AcpAsyncClient client) {
+		client.newSession(new AcpSchema.NewSessionRequest("/w", List.of())).block(TIMEOUT);
+		return client.prompt(new PromptRequest("s1", List.of(new AcpSchema.TextContent("hi"))))
+			.block(TIMEOUT)
+			.stopReason();
+	}
+
+	private static <T> T session(AcpAgentSupport.Builder builder, Function<AcpAsyncClient, T> scenario) {
+		InMemoryTransportPair pair = InMemoryTransportPair.create();
+		AcpAgentSupport agent = builder.transport(pair.agentTransport()).requestTimeout(TIMEOUT).build();
+		agent.start();
+		AcpAsyncClient client = AcpClient.async(pair.clientTransport()).requestTimeout(TIMEOUT).build();
+		try {
+			client.initialize().block(TIMEOUT);
+			return scenario.apply(client);
+		}
+		finally {
+			client.closeGracefully().block(TIMEOUT);
+			agent.close();
+		}
+	}
+
+}
@@ -22,9 +22,13 @@
  * qualified.
  *
  * <p><b>Finding the handler methods.</b> {@code AcpAgentSupport} looks for them once, when the
- * object is given to its builder, and rejects a class without this annotation with an
- * {@code IllegalArgumentException}. It finds methods of any visibility declared in the class
- * itself; methods inherited from a superclass are not found. Declare at most one method for each
+ * object is given to its builder, and rejects a class with this annotation neither on it nor on a
+ * superclass with an {@code IllegalArgumentException}. It finds methods of any visibility declared
+ * in the class and its superclasses, so handlers can live on an abstract base class, and a
+ * subclass that a framework generates for a bean (a Spring CGLIB, Quarkus ArC or Micronaut AOP
+ * proxy, which carries no annotations) is found through the annotated class it extends and
+ * invoked on the proxy, so its interceptors run. An annotated override replaces the method it
+ * overrides. Declare at most one method for each
  * annotation: with two, one of them is used and the other is ignored without an error. With no
  * {@link Initialize} method the agent answers {@code initialize} with the response derived from
  * its annotations (see Capabilities below); with no {@link NewSession} method it answers {@code session/new}