@@ -1043,6 +1043,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- **Spring Boot: `spring.acp.agent.enabled=false` turns the agent off on every transport.** The
+  stdio transport and the HTTP endpoint already backed off, but `AcpAgentAutoConfiguration` did
+  not: it still built the `AcpAgentFactory` from the `@AcpAgent` bean and still served the agent on
+  an `AcpAgentTransport` bean the application defined itself. With `enabled=false` it now creates
+  no agent beans and serves nothing, as Micronaut and Quarkus already did.
+
+- **Spring Boot: two `@AcpAgent` beans no longer fail the startup when
+  `spring.acp.agent.enabled=false`.** The startup failed with the error naming both beans, whose
+  advice was to set `spring.acp.agent.enabled=false`. Same cause and fix as the entry above.
+
+- **Spring Boot: `spring.acp.agent.transport.type=http` in a reactive (WebFlux) web application
+  fails the startup.** It served no endpoint and gave no error. The startup now fails with "The
+  ACP HTTP transport needs a servlet web application or the standalone listener
+  (acp-streamable-http-jetty); WebFlux is not supported".
+
 - **A prompt answers `cancelled` once `session/cancel` was received, whatever its handler
   returns.** ACP requires an agent to answer a cancelled prompt with stop reason `cancelled`. A
   handler that noticed the cancel and returned another stop reason within the grace period had
 
@@ -153,6 +153,12 @@
             <artifactId>spring-boot-starter-web</artifactId>
             <scope>test</scope>
         </dependency>
+        <!-- A reactive web application: Boot detects one by spring-webflux on the classpath -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-webflux</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>com.agentclientprotocol</groupId>
             <artifactId>acp-test</artifactId>
 
@@ -28,6 +28,7 @@
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ConfigurableApplicationContext;
@@ -56,9 +57,13 @@
  * the handler executor come from {@link AcpAgentProperties}. More than one {@code @AcpAgent} bean
  * fails the startup with an error naming them. On the HTTP endpoint every connection's agent calls
  * the same bean, so its handler methods must be thread-safe.
+ *
+ * <p>With {@code spring.acp.agent.enabled=false} it creates nothing: no factory and no agent, on
+ * any transport, however many {@code @AcpAgent} beans there are.
  */
 @AutoConfiguration(after = AcpAgentTransportAutoConfiguration.class)
 @ConditionalOnClass(AcpAgentSupport.class)
+@ConditionalOnProperty(prefix = "spring.acp.agent", name = "enabled", havingValue = "true", matchIfMissing = true)
 @EnableConfigurationProperties(AcpAgentProperties.class)
 public class AcpAgentAutoConfiguration {
 
 
@@ -48,7 +48,8 @@
  * HTTP/2 and WebSocket upgrades on the same path. It starts with the context and stops with it,
  * waiting at most 30 seconds. A {@code StreamableHttpAcpAgentTransport} bean of the application's
  * own replaces it.</li>
- * <li>A reactive web application gets neither.</li>
+ * <li>A reactive (WebFlux) web application fails the startup: the endpoint needs a servlet web
+ * application or the standalone listener.</li>
  * </ul>
  * The endpoint's limits come from {@code spring.acp.agent.transport.http.*}
  * ({@link AcpAgentProperties.AgentHttpProperties}). Nothing here applies when
@@ -89,6 +90,17 @@ AcpServletLifecycle acpServletLifecycle(
 
 	}
 
+	@Configuration(proxyBeanMethods = false)
+	@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.REACTIVE)
+	static class ReactiveConfiguration {
+
+		ReactiveConfiguration() {
+			throw new IllegalStateException("The ACP HTTP transport needs a servlet web application or the "
+					+ "standalone listener (acp-streamable-http-jetty); WebFlux is not supported");
+		}
+
+	}
+
 	@Configuration(proxyBeanMethods = false)
 	@ConditionalOnNotWebApplication
 	static class ListenerConfiguration {
 
@@ -79,10 +79,9 @@ public class AcpAgentProperties {
 	 * ({@code spring.acp.agent.enabled}). Default {@code true}; maps to
 	 * {@link AcpAgentSettings#enabled()}.
 	 *
-	 * <p>With {@code false} the autoconfiguration creates no stdio transport and no HTTP endpoint.
-	 * {@link AcpAgentAutoConfiguration} still builds its agent factory from the {@code @AcpAgent}
-	 * bean, and still serves the bean on an {@code AcpAgentTransport} bean the application defines
-	 * itself.
+	 * <p>With {@code false} the agent autoconfiguration creates nothing: no agent factory, no stdio
+	 * transport, no HTTP endpoint, and no agent on an {@code AcpAgentTransport} bean the application
+	 * defines itself. More than one {@code @AcpAgent} bean is then no error.
 	 * @return whether the agent is served
 	 */
 	public boolean isEnabled() {
 
@@ -9,6 +9,7 @@
 import java.util.UUID;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import com.agentclientprotocol.sdk.agent.AcpAgentFactory;
 import com.agentclientprotocol.sdk.agent.SyncPromptContext;
 import com.agentclientprotocol.sdk.agent.support.AcpAgentSupport;
 import com.agentclientprotocol.sdk.agent.support.interceptor.AcpInterceptor;
@@ -106,6 +107,31 @@ void noAgentWhenDisabled() {
 			});
 	}
 
+	@Test
+	void disabledServesNothingOnTheApplicationsOwnTransport() {
+		new ApplicationContextRunner()
+			.withConfiguration(AutoConfigurations.of(AcpAgentTransportAutoConfiguration.class,
+					AcpAgentAutoConfiguration.class, AcpAgentHttpAutoConfiguration.class))
+			.withUserConfiguration(SingleAgentWithInMemoryTransportConfiguration.class)
+			.withPropertyValues("spring.acp.agent.enabled=false")
+			.run(context -> {
+				assertThat(context).hasNotFailed();
+				assertThat(context).doesNotHaveBean(AcpAgentFactory.class);
+				assertThat(context).doesNotHaveBean("acpAgentLifecycle");
+			});
+	}
+
+	@Test
+	void disabledToleratesTwoAgentBeans() {
+		this.runner.withUserConfiguration(MultipleAgentConfiguration.class)
+			.withPropertyValues("spring.acp.agent.enabled=false")
+			.run(context -> {
+				assertThat(context).hasNotFailed();
+				assertThat(context).doesNotHaveBean(AcpAgentFactory.class);
+				assertThat(context).doesNotHaveBean("acpAgentLifecycle");
+			});
+	}
+
 	@Test
 	void noAgentWithoutTransportBean() {
 		new ApplicationContextRunner().withConfiguration(AutoConfigurations.of(AcpAgentAutoConfiguration.class))
 
@@ -34,6 +34,7 @@
 
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.boot.test.context.runner.ReactiveWebApplicationContextRunner;
 import org.springframework.boot.test.context.runner.WebApplicationContextRunner;
 import org.springframework.boot.web.servlet.ServletRegistrationBean;
 import org.springframework.context.annotation.Bean;
@@ -197,6 +198,19 @@ void backsOffWhenAgentDisabled() {
 			.run(context -> assertThat(context).doesNotHaveBean(StreamableHttpAcpAgentTransport.class));
 	}
 
+	@Test
+	void reactiveWebApplicationFailsTheStartup() {
+		new ReactiveWebApplicationContextRunner().withConfiguration(AGENT_AUTO_CONFIGURATIONS)
+			.withUserConfiguration(EchoAgentConfiguration.class)
+			.withPropertyValues("spring.acp.agent.transport.type=http", "spring.acp.agent.transport.http.listener.port=0")
+			.run(context -> {
+				assertThat(context).hasFailed();
+				assertThat(context.getStartupFailure()).rootCause()
+					.hasMessageContaining("The ACP HTTP transport needs a servlet web application or the "
+							+ "standalone listener (acp-streamable-http-jetty); WebFlux is not supported");
+			});
+	}
+
 	@Test
 	void servletWebApplicationMountsServletInsteadOfListener() {
 		new WebApplicationContextRunner().withConfiguration(AGENT_AUTO_CONFIGURATIONS)