Agent Client Protocol Harness

The Agent Client Protocol (ACP) harness adapter connects HarnessAgent to any harness compatible with ACP version 1. The generic adapter owns the bridge, ACP client, host-tool relay, event translation, approvals, and lifecycle behavior; the inline profile describes how to install and configure one ACP runtime.

All you need in addition to the ACP harness adapter is an ACP-compatible implementation that can be installed from NPM or with a trusted Bash command. You can then configure the ACP harness adapter with a few lines of code.

Setup

pnpm add @ai-sdk/harness @ai-sdk/harness-acp @ai-sdk/sandbox-vercel

Basic Usage

Define an ACP harness profile, such as one of the complete implementations below, and pass it to HarnessAgent:

1
import { HarnessAgent } from '@ai-sdk/harness/agent';
2
import { createVercelSandbox } from '@ai-sdk/sandbox-vercel';
3
import { codexACPHarness } from './codex-acp-harness';
4

5
const agent = new HarnessAgent({
6
  harness: codexACPHarness,
7
  sandbox: createVercelSandbox({
8
    runtime: 'node24',
9
    ports: [4000],
10
  }),
11
});
12

13
const session = await agent.createSession();
14
try {
15
  const result = await agent.generate({
16
    session,
17
    prompt: 'Check the test failures and fix the production code.',
18
  });
19
  console.log(result.text);
20
} finally {
21
  await session.destroy();
22
}

Adapter Settings

createACP accepts:

• harnessId: stable kebab-case identity for this profile.
• version: ACP protocol version. It defaults to and currently supports only 'v1'.
• source: how to acquire the ACP implementation, as a simple NPM package, locked NPM installation, or trusted Bash install command.
• executable: the bare command name to launch from the acquired implementation.
• args: optional arguments passed to the executable.
• forwardEnv: non-credential host environment variable names to forward into the sandbox.
• credentialEnv: host credential environment variable names. Configure this together with credentialBrokering.
• credentialBrokering: function that receives the effective host runtime environment as env and the environment forwarded to the sandbox as sandboxEnv, then returns additive outbound request transformations. Use the credential from sandboxEnv in exact request header matches and the real credential from env in transformed request headers.
• credentialForwarding: optional synchronous or asynchronous callback that customizes each credential immediately before the harness adapter forwards it into a sandbox process. It receives the credential value that would otherwise be forwarded (either the real credential or a masked value) and the environment variable name used to expose it. This callback only controls the value forwarded into the sandbox process. It does not restrict which credentials the harness adapter can discover, read, or otherwise access in the host process.
• env: persistent environment values written at bootstrap.
• builtinTools: optional native tool definitions for static typing and exact name matching.
• mcpServers: MCP server definitions keyed by server name.
• hostToolMcpTransport: transport used for the harness-owned MCP server that exposes host tools to the ACP implementation. It defaults to 'stdio'. Set this to 'http' for implementations that only accept HTTP or SSE MCP servers from the client, which requires the implementation to advertise agentCapabilities.mcpCapabilities.http.
• authentication: advertised ACP authentication method, metadata, and client capabilities.
• auth: downstream provider authentication mode:
  • auto (default): use AI Gateway when Gateway credentials and a providerAuthentication configuration are available; otherwise use direct authentication.
  • direct: always use direct authentication, even when Gateway credentials are available.
  • ai-gateway: always use AI Gateway and throw when Gateway credentials are unavailable. This requires providerAuthentication configuration.
  • An authentication environment: auto-detect from the supplied record instead of the host process environment.
• providerAuthentication: declarative runtime-specific Gateway environment.
• modelMapping: required static mapping from the model supplied to HarnessAgent to the ACP operation used by the implementation. Use session-config-option with its configuration option ID as path, or session-model with the session/set_model request property as path.
• skillsDirectory: native skills directory relative to the implementation's effective $HOME. It defaults to .agents/skills; override it for runtimes that use a different location.
• instructionMapping: optional mapping from HarnessAgent instructions to an implementation's native system or developer prompt. Use session-meta for a path below the ACP session request's _meta field, launch-env-json for a path within a JSON launch environment variable, or filesystem with a relative path to write instructions to a file under the implementation's effective $HOME. When omitted, instructions are prepended to the first user prompt.
• outputSchemaMapping: optional implementation-specific mapping from a structured output JSON Schema to a path below the ACP session/prompt request's _meta field. ACP does not standardize structured output, so omit this unless the selected implementation documents that private extension.
• askUserQuestions: optional translation between an implementation-specific ACP client request for questions and the Harness askUserQuestions tool. Configure it only when the ACP implementation exposes a native request that waits for the client's response.
• permissionModeMapping: mappings from all three Harness permission modes to advertised ACP session modes or configuration options. Set an entry to null when the ACP implementation does not support that mode. When omitted, the adapter applies permissionMode to ACP permission requests by tool kind.
• session.meta: serializable implementation-specific metadata for session creation and restoration.
• port: exposed bridge port override.
• startupTimeoutMs: bridge startup timeout. The default is 120 seconds.
• mintBridgeToken: synchronous function that receives the sandbox id and returns the bridge authentication token. By default, the adapter generates a random 32-byte token. Custom implementations must return a suitably secret token.
• clientApp: optional client attribution with name and version. It defaults to the installed ai-sdk/harness-acp/<version> identity and is available to Gateway environment placeholders.

Runtime-specific package names, environment variables, modes, and session metadata belong in the inline profile, not in the generic adapter.

Structured Output

ACP version 1 does not define a structured output capability. Profiles for implementations with a private prompt metadata extension can opt in explicitly:

1
const harness = createACP({
2
  harnessId: 'example-acp',
3
  source: {
4
    type: 'npm-simple',
5
    packageName: '@example/acp-agent',
6
  },
7
  executable: 'example-acp',
8
  modelMapping: {
9
    type: 'session-config-option',
10
    path: 'model',
11
  },
12
  outputSchemaMapping: {
13
    type: 'session-prompt-meta',
14
    path: ['outputSchema'],
15
  },
16
});

For a HarnessAgent configured with output, this writes the generated JSON Schema to session/prompt.params._meta.outputSchema. A profile without this mapping throws HarnessCapabilityUnsupportedError instead of assuming that an arbitrary ACP implementation understands the schema; Codex ACP is unsupported, while the Grok Build harness includes its verified mapping.

Implementation source

A simple NPM source installs a single package by name:

1
const source = {
2
  type: 'npm-simple',
3
  packageName: '@agentclientprotocol/codex-acp',
4
  packageVersion: '1.1.4',
5
} as const;

packageVersion is optional and must be an exact version when supplied. Omit it to install the package's latest dist-tag instead. An omitted version also stays out of the harness identity, so a new upstream release does not invalidate existing lifecycle state.

A simple source pins only the requested ACP package, while its transitive dependencies are resolved when the sandbox bootstraps. To freeze the complete installation, use a locked source and provide the contents of a package.json and its pnpm-lock.yaml:

1
const source = {
2
  type: 'npm-locked',
3
  packageJson: packageJsonContents,
4
  pnpmLockYaml: pnpmLockYamlContents,
5
  pnpmWorkspaceYaml: pnpmWorkspaceYamlContents,
6
} as const;

A locked source installs the supplied files with pnpm install --frozen-lockfile. pnpmWorkspaceYaml is optional; provide it when the locked installation needs workspace-level pnpm configuration, such as an exact-version allowBuilds policy for a required dependency build script.

The manifest, lockfile, and optional workspace configuration are persisted bootstrap artifacts and participate in lifecycle identity. Do not include credentials in these strings.

An install command source runs a trusted Bash command inside the harness's deterministic bootstrap directory:

1
const cursorSource = {
2
  type: 'install-command',
3
  command: 'curl https://cursor.com/install -fsS | bash',
4
} as const;
5

6
const fxSource = {
7
  type: 'install-command',
8
  command: 'curl -fsSL https://fx.sh/setup.sh | bash',
9
} as const;

The command runs with set -euo pipefail, with its working directory set to .harness-bootstrap/<harnessId>/implementation and HOME set to the home directory immediately below it. All persistent installation files must remain below that HOME. The command must install executable into $HOME/.local/bin; the adapter launches that deterministic path without a shell and does not fall back to a command already present in the sandbox.

Install commands do not provide automatic version pinning. A successful bootstrap remains cached, and the exact command participates in bootstrap and lifecycle identity. Treat the command as executable configuration and do not embed credentials in it because bootstrap recipes are persisted.

Authentication

AI Gateway authentication is supported when providerAuthentication defines how the underlying ACP implementation accepts Gateway configuration. The adapter reads these environment variables:

• VERCEL_OIDC_TOKEN
• AI_GATEWAY_API_KEY
• AI_GATEWAY_BASE_URL

With the default auth: 'auto', the adapter uses AI Gateway when AI_GATEWAY_API_KEY or VERCEL_OIDC_TOKEN is available and otherwise uses direct authentication.

Applications that resolve credentials at runtime can pass them without mutating process.env:

1
const harness = createACP({
2
  // ...implementation settings
3
  auth: {
4
    AI_GATEWAY_API_KEY: await resolveGatewayToken(),
5
    AI_GATEWAY_BASE_URL: 'https://ai-gateway.vercel.sh',
6
  },
7
});

The supplied record replaces the host environment for authentication discovery. credentialEnv reads from this record while forwardEnv continues to read non-authentication runtime configuration from the host. Credential values are excluded from bootstrap and lifecycle identity.

For direct authentication, configure credentialEnv with the host environment variable names that the underlying ACP implementation reads, and use credentialBrokering to map their values to outbound request headers. When the network sandbox supports additive request transformations, the ACP process sees the values from sandboxEnv, which are ephemeral placeholders by default. The real values are injected after requests leave the sandbox, and only when the request contains the exact expected value. Sandboxes without that capability retain the legacy behavior of forwarding the real values. Use forwardEnv only for non-credential runtime configuration.

Gateway environment

Set providerAuthentication.gateway.env to the environment variables that the underlying ACP implementation uses for its provider endpoint, credentials, and attribution. Profile values such as gateway-api-key, gateway-base-url, gateway-authorization, client-app, client-app-name, and client-app-version are placeholders that the adapter resolves only after Gateway authentication has been selected. The three client-app placeholders resolve to the combined name/version identifier, its name, and its version, respectively. Structured launch environment values are serialized as JSON after their placeholders are resolved. The resolved Gateway environment overrides same-name direct values in the environment passed to credentialBrokering, so one callback works for both authentication modes.

Sandbox

Every ACP harness requires a network sandbox with at least one exposed port, e.g. @ai-sdk/sandbox-vercel:

1
const sandbox = createVercelSandbox({
2
  runtime: 'node24',
3
  ports: [4000],
4
});

By default, the adapter uses the first exposed port. Set port on createACP to select another exposed port. If neither is available, session startup throws HarnessCapabilityUnsupportedError with instructions to configure one.

Bridge packages, ACP installations, and replay state live in adapter-owned directories outside the session project. Skills are written to the configured native directory below the implementation's $HOME. The session workspace starts empty.

Tools and Approvals

Optional builtinTools definitions classify native ACP tools only when the agent supplies a programmatic name matching the tool key or nativeName. Unmatched native and third-party MCP calls remain valid provider-executed dynamic tools.

Host-defined AI SDK tools are exposed through a harness-owned MCP server and execute in the host. Their recursive JSON Schemas are preserved. A tool without execute pauses for a caller-supplied result through continueStream.

Map all three Harness permission modes when the ACP implementation exposes native permission controls, and set unsupported modes to null. Selecting a null mapping throws HarnessCapabilityUnsupportedError. The adapter validates concrete modes or config options against the session response. When a mapping is configured, any ACP permission request that still occurs becomes a Harness approval request. Without a mapping, the adapter automatically selects allow_once for tool kinds allowed by permissionMode and requests Harness approval for the rest. A rejection selects reject_once; persistent choices are never inferred. Host-tool approval remains independent.

Complete ACP Harness Implementations

Unless noted otherwise, these profiles support direct authentication through the runtime-specific environment variables shown below and AI Gateway authentication through AI_GATEWAY_API_KEY or VERCEL_OIDC_TOKEN.

Claude Code ACP

Claude Code accepts the Anthropic-compatible Gateway root URL without /v1. This profile uses the runtime's supported launch environment:

1
import { createACP, type ACPPermissionModeMapping } from '@ai-sdk/harness-acp';
2
import { createCredentialRequestTransformation } from '@ai-sdk/harness/utils';
3

4
export const claudeCodeACPHarness = createACP({
5
  harnessId: 'acp-claude-code',
6
  // Define the runtime's built-in tool names and input schemas to expose
7
  // provider-executed calls as typed HarnessAgent tools.
8
  // builtinTools: { ... },
9
  source: {
10
    type: 'npm-simple',
11
    packageName: '@agentclientprotocol/claude-agent-acp',
12
    packageVersion: '0.61.0',
13
  },
14
  executable: 'claude-agent-acp',
15
  modelMapping: {
16
    type: 'session-config-option',
17
    path: 'model',
18
  },
19
  skillsDirectory: '.claude/skills',
20
  credentialEnv: ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN'],
21
  credentialBrokering: ({ env, sandboxEnv }) => {
22
    const apiKey = env.ANTHROPIC_API_KEY;
23
    const authToken = env.ANTHROPIC_AUTH_TOKEN;
24
    const sandboxApiKey = sandboxEnv?.ANTHROPIC_API_KEY;
25
    const sandboxAuthToken = sandboxEnv?.ANTHROPIC_AUTH_TOKEN;
26
    if (!apiKey && !authToken) return [];
27

28
    const transformations = [];
29
    if (apiKey && sandboxApiKey) {
30
      transformations.push(
31
        createCredentialRequestTransformation({
32
          matchUrl: env.ANTHROPIC_BASE_URL ?? 'https://api.anthropic.com',
33
          matchHeaders: { 'x-api-key': sandboxApiKey },
34
          transformHeaders: { 'x-api-key': apiKey },
35
        }),
36
      );
37
    }
38
    if (authToken && sandboxAuthToken) {
39
      transformations.push(
40
        createCredentialRequestTransformation({
41
          matchUrl: env.ANTHROPIC_BASE_URL ?? 'https://api.anthropic.com',
42
          matchHeaders: {
43
            Authorization: `Bearer ${sandboxAuthToken}`,
44
          },
45
          transformHeaders: { Authorization: `Bearer ${authToken}` },
46
        }),
47
      );
48
    }
49
    return transformations;
50
  },
51
  env: {
52
    IS_SANDBOX: '1',
53
  },
54
  instructionMapping: {
55
    type: 'session-meta',
56
    path: ['systemPrompt', 'append'],
57
  },
58
  permissionModeMapping: {
59
    'allow-reads': { type: 'session-mode', modeId: 'default' },
60
    'allow-edits': { type: 'session-mode', modeId: 'acceptEdits' },
61
    'allow-all': { type: 'session-mode', modeId: 'bypassPermissions' },
62
  } as const satisfies ACPPermissionModeMapping,
63
  providerAuthentication: {
64
    gateway: {
65
      env: {
66
        ANTHROPIC_API_KEY: { $source: 'gateway-api-key' },
67
        ANTHROPIC_AUTH_TOKEN: { $source: 'gateway-api-key' },
68
        ANTHROPIC_BASE_URL: { $source: 'gateway-base-url' },
69
        CLAUDE_AGENT_SDK_CLIENT_APP: { $source: 'client-app' },
70
      },
71
    },
72
  },
73
});

Without Gateway credentials, this profile uses direct ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN authentication. The Gateway environment supplies versioned attribution through Claude's supported CLAUDE_AGENT_SDK_CLIENT_APP setting. IS_SANDBOX allows Claude Code ACP to advertise bypassPermissions when the sandbox process runs as root.

Codex ACP

Codex ACP accepts an API key and JSON session configuration through its launch environment. Its OpenAI-compatible endpoint must end in /v1:

1
import { createACP, type ACPPermissionModeMapping } from '@ai-sdk/harness-acp';
2
import { createCredentialRequestTransformation } from '@ai-sdk/harness/utils';
3
import { secureJsonParse } from '@ai-sdk/provider-utils';
4

5
export const codexACPHarness = createACP({
6
  harnessId: 'acp-codex',
7
  // Define the runtime's built-in tool names and input schemas to expose
8
  // provider-executed calls as typed HarnessAgent tools.
9
  // builtinTools: { ... },
10
  source: {
11
    type: 'npm-simple',
12
    packageName: '@agentclientprotocol/codex-acp',
13
    packageVersion: '1.1.4',
14
  },
15
  executable: 'codex-acp',
16
  modelMapping: {
17
    type: 'session-config-option',
18
    path: 'model',
19
  },
20
  forwardEnv: ['CODEX_CONFIG'],
21
  credentialEnv: ['CODEX_API_KEY', 'OPENAI_API_KEY'],
22
  credentialBrokering: ({ env, sandboxEnv }) => {
23
    const environmentVariableName = env.CODEX_API_KEY
24
      ? 'CODEX_API_KEY'
25
      : 'OPENAI_API_KEY';
26
    const credential = env[environmentVariableName];
27
    const sandboxCredential = sandboxEnv?.[environmentVariableName];
28
    if (!credential || !sandboxCredential) return [];
29
    const config =
30
      env.CODEX_CONFIG == null
31
        ? undefined
32
        : (secureJsonParse(env.CODEX_CONFIG) as {
33
            model_provider?: string;
34
            model_providers?: Record<string, { base_url?: string }>;
35
          });
36
    const baseUrl =
37
      config?.model_providers?.[config.model_provider ?? '']?.base_url ??
38
      'https://api.openai.com/v1';
39
    return [
40
      createCredentialRequestTransformation({
41
        matchUrl: baseUrl,
42
        matchHeaders: {
43
          Authorization: `Bearer ${sandboxCredential}`,
44
        },
45
        transformHeaders: { Authorization: `Bearer ${credential}` },
46
      }),
47
    ];
48
  },
49
  instructionMapping: {
50
    type: 'launch-env-json',
51
    variable: 'CODEX_CONFIG',
52
    path: ['developer_instructions'],
53
  },
54
  permissionModeMapping: {
55
    'allow-reads': null,
56
    'allow-edits': null,
57
    'allow-all': { type: 'session-mode', modeId: 'agent-full-access' },
58
  } as const satisfies ACPPermissionModeMapping,
59
  authentication: {
60
    methodId: 'api-key',
61
  },
62
  providerAuthentication: {
63
    gateway: {
64
      env: {
65
        CODEX_API_KEY: { $source: 'gateway-api-key' },
66
        CODEX_CONFIG: {
67
          model: 'openai/gpt-5.6-sol',
68
          model_provider: 'ai_gateway',
69
          model_providers: {
70
            ai_gateway: {
71
              name: 'AI Gateway',
72
              base_url: {
73
                $source: 'gateway-base-url',
74
                ensureSuffix: '/v1',
75
              },
76
              env_key: 'CODEX_API_KEY',
77
              wire_api: 'responses',
78
              supports_websockets: false,
79
              http_headers: {
80
                'User-Agent': { $source: 'client-app' },
81
                'x-client-app': { $source: 'client-app' },
82
              },
83
            },
84
          },
85
          model_supports_reasoning_summaries: true,
86
          preferred_auth_method: 'apikey',
87
        },
88
      },
89
    },
90
  },
91
});

Codex ACP supports only permissionMode: 'allow-all'. Its restrictive session modes enable Codex's internal sandbox, which must not run inside the sandbox already provided to HarnessAgent.

The client-app placeholder resolves to the versioned ai-sdk/harness-acp/<version> identifier and sends it as both User-Agent and x-client-app. Without Gateway credentials, this profile uses direct CODEX_API_KEY or OPENAI_API_KEY authentication. Gateway env values are added to the ACP process only when Gateway is selected, so direct runtime configuration remains unchanged.

Cursor ACP

Cursor exposes ACP through agent acp and installs its CLI with a Bash installer rather than an NPM package:

1
import { createACP } from '@ai-sdk/harness-acp';
2

3
export const cursorACPHarness = createACP({
4
  harnessId: 'cursor-acp',
5
  source: {
6
    type: 'install-command',
7
    command: 'curl https://cursor.com/install -fsS | bash',
8
  },
9
  executable: 'agent',
10
  args: ['--disable-auto-update', 'acp'],
11
  modelMapping: {
12
    type: 'session-config-option',
13
    path: 'model',
14
  },
15
  clientCapabilities: {
16
    _meta: { parameterizedModelPicker: true },
17
  },
18
  credentialEnv: ['CURSOR_API_KEY'],
19
  credentialBrokering: ({ env, sandboxEnv }) => {
20
    if (!env.CURSOR_API_KEY || !sandboxEnv?.CURSOR_API_KEY) return [];
21
    return [
22
      {
23
        match: {
24
          host: 'api2.cursor.sh',
25
          path: { exact: '/auth/exchange_user_api_key' },
26
          method: ['POST'],
27
          headers: [
28
            {
29
              key: { exact: 'Authorization' },
30
              value: { exact: `Bearer ${sandboxEnv.CURSOR_API_KEY}` },
31
            },
32
          ],
33
        },
34
        transform: {
35
          headers: {
36
            Authorization: `Bearer ${env.CURSOR_API_KEY}`,
37
          },
38
        },
39
      },
40
    ];
41
  },
42
});

The update flag prevents the cached installation from changing itself at runtime. Credential brokering is limited to Cursor's initial API-key exchange, so subsequent requests keep the short-lived Cursor access token returned by that exchange.

Cursor supports AI Gateway. Configure Cursor's OpenAI API key with an AI Gateway credential and set Override OpenAI Base URL to https://ai-gateway.vercel.sh/cursor/v1. The regular Cursor CLI continues to authenticate to Cursor with CURSOR_API_KEY; that login is separate from the model provider and routing configured in the Cursor account.

Grok Build ACP

Grok Build exposes ACP directly through grok agent stdio. It does not advertise ACP session modes for its permission behavior, so this profile omits permissionModeMapping:

1
import { createACP } from '@ai-sdk/harness-acp';
2
import { createCredentialRequestTransformation } from '@ai-sdk/harness/utils';
3

4
export const grokBuildACPHarness = createACP({
5
  harnessId: 'acp-grok-build',
6
  // Define the runtime's built-in tool names and input schemas to expose
7
  // provider-executed calls as typed HarnessAgent tools.
8
  // builtinTools: { ... },
9
  source: {
10
    type: 'npm-simple',
11
    packageName: '@xai-official/grok',
12
    packageVersion: '0.2.111',
13
  },
14
  executable: 'grok',
15
  args: ['agent', 'stdio'],
16
  modelMapping: {
17
    type: 'session-model',
18
    path: 'modelId',
19
  },
20
  credentialEnv: ['XAI_API_KEY'],
21
  credentialBrokering: ({ env, sandboxEnv }) => {
22
    if (!env.XAI_API_KEY || !sandboxEnv?.XAI_API_KEY) return [];
23
    return [
24
      createCredentialRequestTransformation({
25
        matchUrl: env.GROK_XAI_API_BASE_URL ?? 'https://api.x.ai/v1',
26
        matchHeaders: {
27
          Authorization: `Bearer ${sandboxEnv.XAI_API_KEY}`,
28
        },
29
        transformHeaders: {
30
          Authorization: `Bearer ${env.XAI_API_KEY}`,
31
        },
32
      }),
33
    ];
34
  },
35
  instructionMapping: {
36
    type: 'filesystem',
37
    path: '.grok/AGENTS.md',
38
  },
39
  providerAuthentication: {
40
    gateway: {
41
      env: {
42
        GROK_CLIENT_NAME: { $source: 'client-app-name' },
43
        GROK_CLIENT_VERSION: { $source: 'client-app-version' },
44
        XAI_API_KEY: { $source: 'gateway-api-key' },
45
        GROK_XAI_API_BASE_URL: {
46
          $source: 'gateway-base-url',
47
          ensureSuffix: '/v1',
48
        },
49
        GROK_MODELS_BASE_URL: {
50
          $source: 'gateway-base-url',
51
          ensureSuffix: '/v1',
52
        },
53
      },
54
    },
55
  },
56
});

Without Gateway credentials, this profile uses direct XAI_API_KEY authentication. The Gateway environment supplies client name and version attribution. Grok Build handles its built-in safe operations internally. For permission requests sent through ACP, the adapter applies the configured Harness permissionMode by tool kind and requests explicit approval for the rest.

Known Limitations

• ACP v1 does not expose model-step boundaries or per-step usage. The adapter infers boundaries and reports unknown per-step usage; terminal prompt usage supplies the turn total.
• Standard ACP v1 has no portable manual compaction or mid-turn steering API.
• ACP v1 has no portable built-in tool filtering API. You can still use activeTools and inactiveTools to filter host-executed tools, but filtering ACP built-ins will throw.
• A changed host-tool catalog requires the ACP implementation to refresh its MCP tool list. Implementations that retain stale tools fail explicitly.

Related

• HarnessAgent
• Harness tools
• Harness adapters