### Platform Setup with Common Skills Installed Globally

Source: https://github.com/warpdotdev/warp/blob/master/WARP.md

Perform platform-specific setup and install common agent skills globally into ~/.agents/skills.

```bash
./script/bootstrap --install-common-skills-globally
```

--------------------------------

### Platform Setup with Common Skills Installed in Repository

Source: https://github.com/warpdotdev/warp/blob/master/WARP.md

Perform platform-specific setup and install common agent skills directly into the project's .agents/skills directory.

```bash
./script/bootstrap --install-common-skills-in-repo
```

--------------------------------

### Platform Setup Without Common Skill Installation

Source: https://github.com/warpdotdev/warp/blob/master/WARP.md

Perform platform-specific setup while skipping the installation or update of common agent skills.

```bash
./script/bootstrap --skip-common-skills
```

--------------------------------

### Compile Inno Setup Installer

Source: https://github.com/warpdotdev/warp/blob/master/script/windows/README.md

Compiles the Inno Setup script to generate a Windows installer executable. Ensure the Inno Setup Command-line Compiler is in your PATH.

```shell
iscc .\script\windows\windows-installer.iss
```

--------------------------------

### Install script placeholders for versioning

Source: https://github.com/warpdotdev/warp/blob/master/specs/APP-3805/TECH.md

Illustrates the use of version placeholders in the installation script for downloading and installing the remote server binary. These placeholders are substituted based on the release channel.

```bash
Download URL query string: `...&channel={channel}{version_query}`
Final install path: `mv "$bin" "$install_dir/{binary_name}{version_suffix}"`
```

--------------------------------

### Run Inno Setup Installer

Source: https://github.com/warpdotdev/warp/blob/master/script/windows/README.md

Executes the generated Warp Windows installer. The output path may vary based on your Inno Setup configuration.

```shell
.\script\windows\Output\Warp-Windows-Setup.exe
```

--------------------------------

### Handle SSH Remote Server Install Click - Rust

Source: https://github.com/warpdotdev/warp/blob/master/specs/APP-4069/TECH.md

Initiates the installation process by transitioning from AwaitingUserChoice to AwaitingInstall. Extracts necessary session information for the installation.

```rust
pub fn handle_ssh_remote_server_install(
    &mut self, session_id: SessionId, ctx: &mut ModelContext<Self>,
) {
    // Extract session_info from AwaitingUserChoice to get the socket path.
    let SshInitState::AwaitingUserChoice { ref session_info } = self.state else {
        log::warn!("Install clicked but state is not AwaitingUserChoice for {:?}", session_id);
        return;
    };
    let IsLegacySSHSession::Yes { socket_path } = &session_info.is_legacy_ssh_session else {
        return;
    };
    let socket_path = socket_path.clone();
    let SshInitState::AwaitingUserChoice { session_info } = std::mem::replace(&mut self.state, SshInitState::AwaitingInstall { session_id, socket_path: socket_path.clone() }) else {
        unreachable!("just matched AwaitingUserChoice above");
    };
}
```

--------------------------------

### Install Claude API Go SDK

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/claude-api/go/claude-api.md

Install the official Go SDK for the Claude API using the go get command.

```bash
go get github.com/anthropics/anthropic-sdk-go
```

--------------------------------

### Create an Agent (Minimal)

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/claude-api/python/managed-agents/README.md

Create a new agent. Agents are reusable and versioned. This minimal example shows agent creation and starting a session.

```APIDOC
## Create an Agent (required first step)

### Minimal

```python
# 1. Create the agent (reusable, versioned)
agent = client.beta.agents.create(
    name="Coding Assistant",
    model="claude-opus-4-7",
    tools=[{"type": "agent_toolset_20260401", "default_config": {"enabled": True}}],
)

# 2. Start a session
session = client.beta.sessions.create(
    agent={"type": "agent", "id": agent.id, "version": agent.version},
    environment_id=environment.id,
)
print(session.id, session.status)
```
```

--------------------------------

### Install Remote Binary

Source: https://github.com/warpdotdev/warp/blob/master/specs/APP-4069/TECH.md

Initiates the installation of the binary on the remote host. Emits SetupStateChanged and BinaryInstallComplete. This is a side-effect decoupled from the session lifecycle.

```rust
pub fn install_binary(
        &self,
        session_id: SessionId,
        socket_path: PathBuf,
        ctx: &mut ModelContext<Self>,
    ) {
        ctx.emit(RemoteServerManagerEvent::SetupStateChanged {
            session_id,
            state: RemoteServerSetupState::Installing { progress_percent: None },
        });
        let spawner = self.spawner.clone();
        ctx.background_executor().spawn(async move {
            let result = match run_ssh_script(&socket_path, &install_script(), INSTALL_TIMEOUT).await {
                Ok(output) if output.status.success() => Ok(()),
                Ok(output) => {
                    let code = output.status.code().unwrap_or(-1);
                    let stderr = String::from_utf8_lossy(&output.stderr);
                    Err(format!("install script failed (exit {code}): {stderr}"))
                }
                Err(e) => Err(e.to_string()),
            };
            let _ = spawner.spawn(move |_, ctx| {
                ctx.emit(RemoteServerManagerEvent::BinaryInstallComplete {
                    session_id, result,
                });
            }).await;
        }).detach();
    }
```

--------------------------------

### Install Platform Plugin in setup_harness

Source: https://github.com/warpdotdev/warp/blob/master/specs/REMOTE-1218/TECH.md

Adds a call to install the platform plugin alongside the existing plugin installation. Both calls are best-effort and log warnings on failure.

```rust
if let Some(manager) = plugin_manager {
    if let Err(e) = manager.install().await {
        log::warn!("Plugin installation failed (continuing): {e}");
    }
    if let Err(e) = manager.install_platform_plugin().await {
        log::warn!("Platform plugin installation failed (continuing): {e}");
    }
}
```

--------------------------------

### Install Docker Desktop

Source: https://github.com/warpdotdev/warp/blob/master/app/tests/ssh/README.md

Installs Docker Desktop using Homebrew. Ensure Docker Desktop is running to make the `docker` CLI available.

```bash
brew install --cask docker
```

--------------------------------

### Inno Setup Compiler CLI Usage

Source: https://github.com/warpdotdev/warp/blob/master/script/windows/README.md

Demonstrates the command-line usage for the Inno Setup Compiler, including how to override preprocessor definitions using the /D flag.

```shell
iscc <script path> /D<name>[=<value>]
```

--------------------------------

### Platform-Specific Setup and Skill Installation

Source: https://github.com/warpdotdev/warp/blob/master/WARP.md

Perform platform-specific setup and install common agent skills from skills-lock.json. This command prompts for project or global installation if needed, unless overridden by flags or environment variables.

```bash
./script/bootstrap
```

--------------------------------

### Example Parameter Definitions

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/tab-configs/SKILL.md

Illustrates how to define parameters for tab configurations, allowing users to input values at runtime. Supports types like 'repo' for repository selection and 'branch' for Git branch selection.

```toml
[params.project_dir]
type = "repo"
description = "Project directory"
```

```toml
[params.branch]
type = "branch"
description = "Branch to check out"

```

--------------------------------

### Client Initialization

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/claude-api/go/managed-agents/README.md

Demonstrates how to initialize the Anthropic Go client, both with and without an explicit API key.

```APIDOC
## Client Initialization

```go
import (
    "context"

    "github.com/anthropics/anthropic-sdk-go"
    "github.com/anthropics/anthropic-sdk-go/option"
)

// Default (uses ANTHROPIC_API_KEY env var)
client := anthropic.NewClient()

// Explicit API key
client := anthropic.NewClient(
    option.WithAPIKey("your-api-key"),
)

ctx := context.Background()
```
```

--------------------------------

### Platform Setup with Explicit Common Skill Installation

Source: https://github.com/warpdotdev/warp/blob/master/WARP.md

Perform platform-specific setup and explicitly install common agent skills from skills-lock.json. This is the default behavior.

```bash
./script/bootstrap --install-common-skills
```

--------------------------------

### Create a Minimal Agent and Start a Session

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/claude-api/go/managed-agents/README.md

Create a reusable agent with a specified model, system prompt, and tools, then start a new session linked to that agent and an environment. Agent creation should be done once and the ID reused.

```go
// 1. Create the agent (reusable, versioned)
agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
    Name: "Coding Assistant",
    Model: anthropic.BetaManagedAgentsModelConfigParams{
        ID:   "claude-opus-4-7",
        Type: anthropic.BetaManagedAgentsModelConfigParamsTypeModelConfig,
    },
    System: anthropic.String("You are a helpful coding assistant."),
    Tools: []anthropic.BetaAgentNewParamsToolUnion{{
        OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
            Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
        },
    }},
})
if err != nil {
    panic(err)
}

// 2. Start a session
session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
    Agent: anthropic.BetaSessionNewParamsAgentUnion{
        OfBetaManagedAgentsAgents: &anthropic.BetaManagedAgentsAgentParams{
            Type:    anthropic.BetaManagedAgentsAgentParamsTypeAgent,
            ID:      agent.ID,
            Version: anthropic.Int(agent.Version),
        },
    },
    EnvironmentID: environment.ID,
    Title:         anthropic.String("Quickstart session"),
})
if err != nil {
    panic(err)
}
fmt.Printf("Session ID: %s, status: %s\n", session.ID, session.Status)
```

--------------------------------

### Manage Environments and Sessions

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/claude-api/go/managed-agents/README.md

Provides examples for listing, retrieving, archiving, and deleting environments, as well as deleting sessions. Ensure proper IDs are used and dependencies are handled (e.g., sessions referencing environments).

```go
// List environments
environments, err := client.Beta.Environments.List(ctx, anthropic.BetaEnvironmentListParams{})
if err != nil {
    panic(err)
}

// Retrieve a specific environment
env, err := client.Beta.Environments.Get(ctx, environment.ID, anthropic.BetaEnvironmentGetParams{})
if err != nil {
    panic(err)
}

// Archive an environment (read-only, existing sessions continue)
_, err = client.Beta.Environments.Archive(ctx, environment.ID, anthropic.BetaEnvironmentArchiveParams{})
if err != nil {
    panic(err)
}

// Delete an environment (only if no sessions reference it)
_, err = client.Beta.Environments.Delete(ctx, environment.ID, anthropic.BetaEnvironmentDeleteParams{})
if err != nil {
    panic(err)
}

// Delete a session
_, err = client.Beta.Sessions.Delete(ctx, session.ID, anthropic.BetaSessionDeleteParams{})
if err != nil {
    panic(err)
}
```

--------------------------------

### Use System Prompts

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/claude-api/typescript/claude-api/README.md

Include a system prompt to guide the AI's behavior or persona. This example instructs the AI to provide Python examples.

```typescript
const response = await client.messages.create({
  model: "claude-opus-4-7",
  max_tokens: 16000,
  system:
    "You are a helpful coding assistant. Always provide examples in Python.",
  messages: [{ role: "user", content: "How do I read a JSON file?" }],
});
```

--------------------------------

### Remote Server Setup State Machine

Source: https://github.com/warpdotdev/warp/blob/master/specs/alokedesai/APP-3797/TECH.md

Defines the possible states for the remote server setup process. Use this enum to track the progress and status of the installation.

```rust
enum RemoteServerSetupState {
    /// Checking if the binary exists on remote.
    Checking,
    /// Downloading and installing the binary.
    Installing { progress_percent: Option<u8> },
    /// Binary is launched, waiting for InitializeResponse.
    Initializing,
    /// Handshake complete. Ready.
    Ready,
    /// Something failed. Fall back to ControlMaster.
    Failed { error: String },
}

```

--------------------------------

### Initialize Cloud Preferences Syncer Entry Point

Source: https://github.com/warpdotdev/warp/blob/master/specs/danielpeng/QUALITY-474/TECH.md

This snippet shows how to call the `initialize_cloud_preferences_syncer` entry point from `lib.rs`, passing the TOML file path and any parse errors encountered during startup.

```rust
let toml_path = settings::user_preferences_toml_file_path();
let parse_error = user_defaults_on_startup
    .settings_file_error
    .as_ref()
    .and_then(|err| match err {
        SettingsFileError::FileParseFailed(msg) => Some(msg.clone()),
        SettingsFileError::InvalidSettings(_) => None,
    });
ctx.add_singleton_model(move |ctx| {
    initialize_cloud_preferences_syncer(
        &toml_path,
        parse_error.as_deref(),
        ctx,
    )
});
```

--------------------------------

### Warp Development Setup

Source: https://github.com/warpdotdev/warp/blob/master/CONTRIBUTING.md

Run these commands to set up your development environment and build the Warp application.

```bash
./script/bootstrap   # platform-specific setup

```

```bash
cargo run            # build and run Warp

```

```bash
./script/presubmit   # fmt, clippy, and tests

```

--------------------------------

### Client Initialization

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/claude-api/python/claude-api/README.md

Demonstrates how to initialize the Anthropic client, both with and without an explicit API key, and how to create an asynchronous client.

```APIDOC
## Client Initialization

```python
import anthropic

# Default (uses ANTHROPIC_API_KEY env var)
client = anthropic.Anthropic()

# Explicit API key
client = anthropic.Anthropic(api_key="your-api-key")

# Async client
async_client = anthropic.AsyncAnthropic()
```
```

--------------------------------

### Example of using external jq with oz run list

Source: https://github.com/warpdotdev/warp/blob/master/specs/REMOTE-1393/PRODUCT.md

This example demonstrates the common scripting pattern that requires an external `jq` binary to filter JSON output from `oz run list`. This pattern is less portable and more complex in environments without `jq` installed.

```bash
oz run list --state failed --output-format json | jq -r '.runs[].task_id'
```

--------------------------------

### Example Workflow for Invoking Third-Party CLI

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/oz-platform/SKILL.md

This snippet outlines the typical steps for a cloud agent to use a third-party CLI, including setup, execution, and artifact reporting.

```shell
# 1. Read this skill and references/third-party-clis.md to understand CLI usage

# 2. Set up authentication if needed (e.g., for Codex)
# For Claude Code, ANTHROPIC_API_KEY is already available

# 3. Run the CLI with the user's task - let it do ALL the work
$ claude -p "Summarize the architecture of this project"

# 4. If a PR was created, parse the CLI output and report the artifact
# Example: report_pr(pr_url="https://github.com/...", branch="feature-branch")
```

--------------------------------

### Create an Agent with System Prompt and Custom Tools

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/claude-api/python/managed-agents/README.md

Create an agent with a system prompt for behavior guidance and custom tools, including a 'run_tests' tool with a defined input schema. This example also demonstrates attaching resources like a GitHub repository to the session.

```python
import os

agent = client.beta.agents.create(
    name="Code Reviewer",
    model="claude-opus-4-7",
    system="You are a senior code reviewer.",
    tools=[
        {"type": "agent_toolset_20260401"},
        {
            "type": "custom",
            "name": "run_tests",
            "description": "Run the test suite",
            "input_schema": {
                "type": "object",
                "properties": {
                    "test_path": {"type": "string", "description": "Path to test file"}
                },
                "required": ["test_path"],
            },
        },
    ],
)

session = client.beta.sessions.create(
    agent={"type": "agent", "id": agent.id, "version": agent.version},
    environment_id=environment.id,
    title="Code review session",
    resources=[
        {
            "type": "github_repository",
            "url": "https://github.com/owner/repo",
            "mount_path": "/workspace/repo",
            "authorization_token": os.environ["GITHUB_TOKEN"],
            "branch": "main",
        }
    ],
)
```

--------------------------------

### Setup Environment Variables and Headers

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/claude-api/curl/managed-agents.md

Set up your API key and common headers for making requests to the Anthropic API.

```bash
export ANTHROPIC_API_KEY="your-api-key"

# Common headers
HEADERS=(
  -H "Content-Type: application/json"
  -H "x-api-key: $ANTHROPIC_API_KEY"
  -H "anthropic-version: 2023-06-01"
  -H "anthropic-beta: managed-agents-2026-04-01"
)
```

--------------------------------

### Daemon Startup Flow via run_internal

Source: https://github.com/warpdotdev/warp/blob/master/specs/daemon-sentry-initialization/TECH.md

The daemon now starts by calling `run_internal` with `LaunchMode::RemoteServerDaemon`, which then proceeds through early initialization and `initialize_app` for full singleton setup including Sentry.

```rust
run_daemon(identity_key) → run_internal(LaunchMode::RemoteServerDaemon { identity_key })
  → early init (logging, feature flags, profiling, resource limits, TLS)
  → AppBuilder::new_headless + initialize_app (full singleton chain including Sentry)
  → launch() which matches LaunchMode::RemoteServerDaemon and calls launch_daemon()
```

--------------------------------

### Message Request with System Prompt (Python)

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/claude-api/python/claude-api/README.md

Include a system prompt in your message request to guide the AI's behavior. This example sets the assistant's persona to be a helpful coding assistant.

```python
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    system="You are a helpful coding assistant. Always provide examples in Python.",
    messages=[{"role": "user", "content": "How do I read a JSON file?"}]
)
```

--------------------------------

### Initialize MCP Server Config

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/add-mcp-server/SKILL.md

Create a new `.mcp.json` file with the required `mcpServers` wrapper key if it does not exist.

```json
{
  "mcpServers": {}
}
```

--------------------------------

### Code Execution with Claude API

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/claude-api/python/claude-api/tool-use.md

Utilize Claude's code execution tool to run Python code and get results. This is demonstrated with a basic example calculating statistics and a more advanced scenario involving file uploads.

```python
import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    messages=[{
        "role": "user",
        "content": "Calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
    }],
    tools=[{
        "type": "code_execution_20260120",
        "name": "code_execution"
    }]
)

for block in response.content:
    if block.type == "text":
        print(block.text)
    elif block.type == "bash_code_execution_tool_result":
        print(f"stdout: {block.content.stdout}")
```

```python
# 1. Upload a file
uploaded = client.beta.files.upload(file=open("sales_data.csv", "rb"))

# 2. Pass to code execution via container_upload block

```

--------------------------------

### Install Remote Server Binary

Source: https://github.com/warpdotdev/warp/blob/master/specs/APP-4069/TECH.md

Installs the necessary binary for the remote server. This method is called when the user chooses to install.

```rust
    }; 
    self.flush_stashed_bootstrap(session_info, ctx);
    RemoteServerManager::handle(ctx).update(ctx, |mgr, ctx| {
        mgr.install_binary(session_id, socket_path, ctx);
    });
}
```

--------------------------------

### Capture Baseline Table Example Screenshots

Source: https://github.com/warpdotdev/warp/blob/master/crates/warpui/examples/table-sample/WARP.md

Run this command to build and capture baseline reference images for the table example. Ensure you are in the correct directory relative to the target executable.

```bash
../../.. /../../../target/debug/examples/table-sample --capture-baseline
```

--------------------------------

### Build and Run Warp from Source

Source: https://github.com/warpdotdev/warp/blob/master/FAQ.md

Use these commands to set up, build, and run Warp from its source code. Ensure platform-specific setup is completed first.

```bash
./script/bootstrap   # platform-specific setup
cargo run            # build and run Warp
./script/presubmit   # fmt, clippy, and tests
```

--------------------------------

### Start a Session

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/claude-api/curl/managed-agents.md

Starts a new session for an agent within an environment.

```APIDOC
## Start a Session

### Description
Starts a new session for an agent within an environment.

### Method
POST

### Endpoint
/v1/sessions

### Request Body
- **agent** (object) - Required - Specifies the agent to use.
  - **type** (string) - Required - Must be "agent".
  - **id** (string) - Required - The ID of the agent.
  - **version** (string) - Optional - The version of the agent.
- **environment_id** (string) - Required - The ID of the environment to use.
- **title** (string) - Optional - A title for the session.
- **resources** (array) - Optional - Resources to mount in the session.
  - **type** (string) - Required - The type of resource (e.g., "github_repository").
  - **url** (string) - Required for github_repository - The URL of the repository.
  - **mount_path** (string) - Required for github_repository - The path to mount the repository at.
  - **authorization_token** (string) - Optional for github_repository - Authorization token for the repository.
  - **branch** (string) - Optional for github_repository - The branch to checkout.

### Request Example
```json
{
  "agent": { "type": "agent", "id": "agent_abc123", "version": "1772585501101368014" },
  "environment_id": "env_abc123"
}
```

### Request Example (With Resources)
```json
{
  "agent": { "type": "agent", "id": "agent_abc123", "version": "1772585501101368014" },
  "environment_id": "env_abc123",
  "title": "Code review session",
  "resources": [
    {
      "type": "github_repository",
      "url": "https://github.com/owner/repo",
      "mount_path": "/workspace/repo",
      "authorization_token": "ghp_...",
      "branch": "feature-branch"
    }
  ]
}
```
```

--------------------------------

### Create an Agent with System Prompt and Custom Tools

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/claude-api/curl/managed-agents.md

Create an agent with a system prompt, custom tools, and configure it to use a GitHub repository.

```bash
# 1. Create the agent
curl -X POST https://api.anthropic.com/v1/agents \
  "${HEADERS[@]}" \
  -d '{
    "name": "Code Reviewer",
    "model": "claude-opus-4-7",
    "system": "You are a senior code reviewer. Be thorough and constructive.",
    "tools": [
      { "type": "agent_toolset_20260401" },
      {
        "type": "custom",
        "name": "run_linter",
        "description": "Run the project linter on a file",
        "input_schema": {
          "type": "object",
          "properties": {
            "file_path": { "type": "string", "description": "Path to lint" }
          },
          "required": ["file_path"]
        }
      }
    ]
  }'

# 2. Start a session with the repo mounted
curl -X POST https://api.anthropic.com/v1/sessions \
  "${HEADERS[@]}" \
  -d '{
    "agent": { "type": "agent", "id": "agent_abc123", "version": "1772585501101368014" },
    "environment_id": "env_abc123",
    "title": "Code review session",
    "resources": [
      {
        "type": "github_repository",
        "url": "https://github.com/owner/repo",
        "mount_path": "/workspace/repo",
        "authorization_token": "ghp_...",
        "branch": "feature-branch"
      }
    ]'
  }'
```

--------------------------------

### Install Common Skills with Target

Source: https://github.com/warpdotdev/warp/blob/master/specs/common-skills-installation/TECH.md

Installs common skills into a specified target repository root. It can be used with `--if-needed` to only install if required, and `--quiet` for silent operation.

```bash
warpdotdev/common-skills/scripts/install_common_skills --repo-root <warp-checkout> --if-needed --quiet
```

--------------------------------

### Create an Agent and Start a Session

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/claude-api/go/managed-agents/README.md

Illustrates the process of creating a reusable agent with a specified model, system prompt, and tools, followed by starting a new session linked to that agent and a created environment.

```APIDOC
## Create an Agent (required first step)

> ⚠️ **There is no inline agent config.** `Model`/`System`/`Tools` live on the agent object, not the session. Always start with `Beta.Agents.New()` — the session only takes `Agent: anthropic.BetaSessionNewParamsAgentUnion{OfString: anthropic.String(agent.ID)}` (or the typed `OfBetaManagedAgentsAgents` variant when you need a specific version).

### Minimal

```go
// 1. Create the agent (reusable, versioned)
agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
    Name: "Coding Assistant",
    Model: anthropic.BetaManagedAgentsModelConfigParams{
        ID:   "claude-opus-4-7",
        Type: anthropic.BetaManagedAgentsModelConfigParamsTypeModelConfig,
    },
    System: anthropic.String("You are a helpful coding assistant."),
    Tools: []anthropic.BetaAgentNewParamsToolUnion{{ // Assuming Toolset20260401 is the correct type for tools
        OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
            Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
        },
    }},
})
if err != nil {
    panic(err)
}

// 2. Start a session
session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
    Agent: anthropic.BetaSessionNewParamsAgentUnion{
        OfBetaManagedAgentsAgents: &anthropic.BetaManagedAgentsAgentParams{
            Type:    anthropic.BetaManagedAgentsAgentParamsTypeAgent,
            ID:      agent.ID,
            Version: anthropic.Int(agent.Version),
        },
    },
    EnvironmentID: environment.ID,
    Title:         anthropic.String("Quickstart session"),
})
if err != nil {
    panic(err)
}
fmt.Printf("Session ID: %s, status: %s\n", session.ID, session.Status)
```
```

--------------------------------

### Install Cargo Test Dependencies

Source: https://github.com/warpdotdev/warp/blob/master/WARP.md

Install the necessary Cargo test dependencies for the project.

```bash
./script/install_cargo_test_deps
```

--------------------------------

### Create an Agent with System Prompt and Custom Tools

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/claude-api/typescript/managed-agents/README.md

Create an agent with a system prompt for behavior guidance and define custom tools that the agent can utilize. This example also includes setting up session resources like GitHub repositories.

```typescript
const agent = await client.beta.agents.create(
  {
    name: "Code Reviewer",
    model: "claude-opus-4-7",
    system: "You are a senior code reviewer.",
    tools: [
      { type: "agent_toolset_20260401", default_config: { enabled: true } },
      {
        type: "custom",
        name: "run_tests",
        description: "Run the test suite",
        input_schema: {
          type: "object",
          properties: {
            test_path: { type: "string", description: "Path to test file" },
          },
          required: ["test_path"],
        },
      },
    ],
  },
);

const session = await client.beta.sessions.create(
  {
    agent: { type: "agent", id: agent.id, version: agent.version },
    environment_id: environment.id,
    title: "Code review session",
    resources: [
      {
        type: "github_repository",
        url: "https://github.com/owner/repo",
        mount_path: "/workspace/repo",
        authorization_token: process.env.GITHUB_TOKEN,
        branch: "main",
      },
    ],
  },
);
```

--------------------------------

### Create an Environment

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/claude-api/go/managed-agents/README.md

Create a new environment for managed agents. This example uses unrestricted networking.

```go
environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
    Name: "my-dev-env",
    Config: anthropic.BetaCloudConfigParams{
        Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
            OfUnrestricted: &anthropic.UnrestrictedNetworkParam{},
        },
    },
})
if err != nil {
    panic(err)
}
fmt.Println(environment.ID) // env_...
```

--------------------------------

### Install Cargo Build Dependencies

Source: https://github.com/warpdotdev/warp/blob/master/WARP.md

Install the necessary Cargo build dependencies for the project.

```bash
./script/install_cargo_build_deps
```

--------------------------------

### Install the Claude SDK

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/claude-api/typescript/claude-api/README.md

Install the official Anthropic SDK for Node.js using npm.

```bash
npm install @anthropic-ai/sdk
```

--------------------------------

### Python: One-Time Agent Setup

Source: https://github.com/warpdotdev/warp/blob/master/resources/bundled/skills/claude-api/shared/managed-agents-onboarding.md

Run this code once to create an environment and an agent, then store their IDs. Ensure you have the necessary environment variables set.

```python
import os

from dotenv import load_dotenv

from warp_api.managed_agents import agents, environments, sessions

load_dotenv()

# ONE-TIME SETUP — run once, save the IDs to config/.env

# Create an environment
env_id = environments.create(
    name=f"My Test Environment",
    description="My Test Environment Description",
)
print(f"Environment created: {env_id}")

# Create an agent
agent_id, agent_version = agents.create(
    name=f"My Test Agent",
    description="My Test Agent Description",
    environment_id=env_id,
    # Add any other agent configuration here
)
print(f"Agent created: {agent_id} (Version: {agent_version})")

# Save the IDs to .env file
with open(".env", "w") as f:
    f.write(f"ENV_ID={env_id}\n")
    f.write(f"AGENT_ID={agent_id}\n")
    f.write(f"AGENT_VERSION={agent_version}\n")

```