튼튼발자 개발 성장기🏋️

Claude Code: 제대로 알고 쓰자(Computer use tool편) 본문

AI/Claude Code

Claude Code: 제대로 알고 쓰자(Computer use tool편)

시뻘건 튼튼발자 2026. 3. 25. 16:57
반응형
Computer use tool - Claude Documentation

Claude는 computer use tool을 통해 컴퓨터 환경과 상호작용할 수 있으며, 이는 스크린샷 기능과 마우스/키보드 제어를 제공하여 자율적인 데스크톱 상호작용이 가능하게 한다. 실제 웹사이트에서의 자율적인 웹 탐색을 위한 벤치마크인 WebArena에서 Claude는 단일 에이전트 시스템 중에서도 최첨단 결과를 달성하며, 종단 간 다단계 브라우저 작업을 완료하는 강력한 능력을 보여준다.

Computer use는 베타 상태이며 beta header가 필요하다:

  • "computer-use-2025-11-24"는 Claude Opus 4.6, Claude Sonnet 4.6, Claude Opus 4.5용
  • "computer-use-2025-01-24"는 Sonnet 4.5, Haiku 4.5, Opus 4.1, Sonnet 4, Opus 4, 그리고 Sonnet 3.7용 (deprecated)

이 기능에 대한 피드백을 feedback form을 통해 공유해 주기 바란다.

이 기능은 베타 상태이며 Zero Data Retention (ZDR)에 적합하지 않다. 베타 기능은 ZDR에서 제외된다.

개요

Computer use는 Claude가 데스크톱 환경과 상호작용할 수 있게 하는 베타 기능이다. 이 tool은 다음을 제공한다:

  • Screenshot capture: 화면에 현재 표시된 내용 확인
  • Mouse control: 클릭, 드래그, 커서 이동
  • Keyboard input: 텍스트 입력 및 키보드 단축키 사용
  • Desktop automation: 모든 애플리케이션 또는 인터페이스와 상호작용

Computer use는 더 포괄적인 자동화 워크플로우를 위해 bash와 텍스트 편집기와 같은 다른 도구로 확장될 수 있지만, computer use는 특히 데스크톱 환경을 보고 제어하는 computer use tool의 기능을 의미한다.

모델 호환성

Computer use는 다음 Claude 모델에서 사용 가능하다:

Model Tool Version Beta Flag
Claude Opus 4.6, Claude Sonnet 4.6, Claude Opus 4.5 computer_20251124 computer-use-2025-11-24
All other supported models computer_20250124 computer-use-2025-01-24

Claude Opus 4.6, Claude Sonnet 4.6, 그리고 Claude Opus 4.5는 세부적인 화면 영역 검사를 위한 zoom action을 포함한 새로운 기능이 있는 computer_20251124 tool 버전을 도입한다. 다른 모든 모델(Sonnet 4.5, Haiku 4.5, Sonnet 4, Opus 4, Opus 4.1, 그리고 Sonnet 3.7)은 computer_20250124 tool 버전을 사용한다.

이전 tool 버전은 새로운 모델과 하위 호환성이 보장되지 않는다. 항상 모델 버전에 해당하는 tool 버전을 사용해야 한다.

보안 고려사항

Computer use는 표준 API 기능과 구별되는 고유한 위험을 가진 베타 기능이다. 이러한 위험은 인터넷과 상호작용할 때 더 높아진다.

위험을 최소화하기 위해 다음과 같은 예방 조치를 고려해야 한다:

  1. 직접적인 시스템 공격이나 사고를 방지하기 위해 최소한의 권한을 가진 전용 가상 머신이나 컨테이너를 사용한다.
  2. 정보 유출을 방지하기 위해 계정 로그인 정보와 같은 민감한 데이터에 대한 모델의 액세스를 피한다.
  3. 악성 콘텐츠에 대한 노출을 줄이기 위해 허용 목록의 도메인으로 인터넷 액세스를 제한한다.
  4. 쿠키 수락, 금융 거래 실행, 또는 서비스 약관 동의와 같은 긍정적인 동의가 필요한 작업뿐만 아니라 의미 있는 실제 결과를 초래할 수 있는 결정에 대해서는 인간의 확인을 요청한다.

일부 상황에서 Claude는 사용자의 지시와 충돌하더라도 콘텐츠에서 발견된 명령을 따를 수 있다. 예를 들어, 웹페이지의 Claude 지시나 이미지에 포함된 지시가 지시를 무시하거나 Claude가 실수를 하게 할 수 있다. 이러한 프롬프트 인젝션과 관련된 위험을 피하기 위해 Claude를 민감한 데이터와 작업에서 격리하는 예방 조치를 취해야 한다.

모델은 이러한 프롬프트 인젝션에 대항하도록 훈련되었으며, 추가적인 방어 계층이 추가되었다. computer use 도구를 사용하는 경우, 분류기가 자동으로 프롬프트에서 잠재적인 프롬프트 인젝션 인스턴스를 플래그하기 위해 실행된다. 이러한 분류기가 스크린샷에서 잠재적인 프롬프트 인젝션을 식별하면, 다음 작업을 진행하기 전에 사용자 확인을 요청하도록 모델을 자동으로 유도한다. 이 추가적인 보호는 모든 사용 사례(예: 인간이 개입하지 않는 사용 사례)에 이상적이지는 않으므로, 옵트아웃하고 끄려면 contact support를 통해 문의해야 한다.

분류기 방어 계층이 있더라도 이러한 예방 조치는 여전히 중요하다.

자신의 제품에서 computer use를 활성화하기 전에 최종 사용자에게 관련 위험을 알리고 동의를 받아야 한다.

Computer use reference implementation

웹 인터페이스, Docker 컨테이너, 예제 tool 구현, 그리고 agent loop이 포함된 computer use reference implementation으로 빠르게 시작해 본다.

참고: 이 구현은 Claude 4 모델과 Claude Sonnet 3.7을 위한 새로운 도구가 포함되어 업데이트되었다. 이러한 새로운 기능에 액세스하려면 반드시 저장소의 최신 버전을 pull해야 한다.

this form을 사용하여 모델 응답의 품질, API 자체, 또는 문서의 품질에 대한 피드백을 제공할 수 있다.

빠른 시작

Computer use를 시작하는 방법은 다음과 같다:

Shell
curl https://api.anthropic.com/v1/messages \
  -H "content-type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: computer-use-2025-11-24" \
  -d '{
    "model": "claude-opus-4-6",
    "max_tokens": 1024,
    "tools": [
      {
        "type": "computer_20251124",
        "name": "computer",
        "display_width_px": 1024,
        "display_height_px": 768,
        "display_number": 1
      },
      {
        "type": "text_editor_20250728",
        "name": "str_replace_based_edit_tool"
      },
      {
        "type": "bash_20250124",
        "name": "bash"
      }
    ],
    "messages": [
      {
        "role": "user",
        "content": "Save a picture of a cat to my desktop."
      }
    ]
  }'
Python
import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-opus-4-6",  # or another compatible model
    max_tokens=1024,
    tools=[
        {
            "type": "computer_20251124",
            "name": "computer",
            "display_width_px": 1024,
            "display_height_px": 768,
            "display_number": 1,
        },
        {"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"},
        {"type": "bash_20250124", "name": "bash"},
    ],
    messages=[{"role": "user", "content": "Save a picture of a cat to my desktop."}],
    betas=["computer-use-2025-11-24"],
)
print(response)
TypeScript
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const response = await client.beta.messages.create({
  model: "claude-opus-4-6",
  max_tokens: 1024,
  tools: [
    {
      type: "computer_20251124",
      name: "computer",
      display_width_px: 1024,
      display_height_px: 768,
      display_number: 1
    },
    {
      type: "text_editor_20250728",
      name: "str_replace_based_edit_tool"
    },
    {
      type: "bash_20250124",
      name: "bash"
    }
  ],
  messages: [{ role: "user", content: "Save a picture of a cat to my desktop." }],
  betas: ["computer-use-2025-11-24"]
});

console.log(response);
C#
using System;
using System.Threading.Tasks;
using Anthropic;
using Anthropic.Models.Beta.Messages;

class Program
{
    static async Task Main(string[] args)
    {
        var client = new AnthropicClient();

        var parameters = new MessageCreateParams
        {
            Model = Model.ClaudeOpus4_6,
            MaxTokens = 1024,
            Tools = new BetaToolUnion[]
            {
                new BetaToolComputerUse20251124
                {
                    DisplayWidthPx = 1024,
                    DisplayHeightPx = 768,
                    DisplayNumber = 1
                },
                new BetaToolTextEditor20250728(),
                new BetaToolBash20250124()
            },
            Messages = new[]
            {
                new BetaMessageParam
                {
                    Role = Role.User,
                    Content = "Save a picture of a cat to my desktop."
                }
            },
            Betas = new[] { "computer-use-2025-11-24" }
        };

        var response = await client.Beta.Messages.Create(parameters);
        Console.WriteLine(response);
    }
}
Go
package main

import (
	"context"
	"fmt"
	"log"

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

func main() {
	client := anthropic.NewClient()

	response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
		Model:     anthropic.ModelClaudeOpus4_6,
		MaxTokens: 1024,
		Tools: []anthropic.BetaToolUnionParam{
			{OfComputerUseTool20251124: &anthropic.BetaToolComputerUse20251124Param{
				DisplayWidthPx:  1024,
				DisplayHeightPx: 768,
				DisplayNumber:   anthropic.Int(1),
			}},
			{OfTextEditor20250728: &anthropic.BetaToolTextEditor20250728Param{}},
			{OfBashTool20250124: &anthropic.BetaToolBash20250124Param{}},
		},
		Messages: []anthropic.BetaMessageParam{
			anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Save a picture of a cat to my desktop.")),
		},
		Betas: []anthropic.AnthropicBeta{
			anthropic.AnthropicBetaComputerUse2025_11_24,
		},
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(response)
}
Java
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaToolBash20250124;
import com.anthropic.models.beta.messages.BetaToolComputerUse20251124;
import com.anthropic.models.beta.messages.BetaToolTextEditor20250728;
import com.anthropic.models.beta.messages.MessageCreateParams;

public class ComputerUseExample {
    public static void main(String[] args) {
        AnthropicClient client = AnthropicOkHttpClient.fromEnv();

        MessageCreateParams params = MessageCreateParams.builder()
            .model("claude-opus-4-6")
            .maxTokens(1024L)
            .addTool(BetaToolComputerUse20251124.builder()
                .displayWidthPx(1024L)
                .displayHeightPx(768L)
                .displayNumber(1L)
                .build())
            .addTool(BetaToolTextEditor20250728.builder().build())
            .addTool(BetaToolBash20250124.builder().build())
            .addUserMessage("Save a picture of a cat to my desktop.")
            .addBeta("computer-use-2025-11-24")
            .build();

        BetaMessage response = client.beta().messages().create(params);
        System.out.println(response);
    }
}
PHP
<?php

use Anthropic\Client;

$client = new Client(apiKey: getenv("ANTHROPIC_API_KEY"));

$response = $client->beta->messages->create(
    maxTokens: 1024,
    messages: [
        ['role' => 'user', 'content' => 'Save a picture of a cat to my desktop.'],
    ],
    model: 'claude-opus-4-6',
    tools: [
        [
            'type' => 'computer_20251124',
            'name' => 'computer',
            'display_width_px' => 1024,
            'display_height_px' => 768,
            'display_number' => 1,
        ],
        [
            'type' => 'text_editor_20250728',
            'name' => 'str_replace_based_edit_tool',
        ],
        [
            'type' => 'bash_20250124',
            'name' => 'bash',
        ],
    ],
    betas: ['computer-use-2025-11-24'],
);

echo $response;
Ruby
require "anthropic"

client = Anthropic::Client.new

response = client.beta.messages.create(
  model: "claude-opus-4-6",
  max_tokens: 1024,
  tools: [
    {
      type: "computer_20251124",
      name: "computer",
      display_width_px: 1024,
      display_height_px: 768,
      display_number: 1
    },
    {
      type: "text_editor_20250728",
      name: "str_replace_based_edit_tool"
    },
    {
      type: "bash_20250124",
      name: "bash"
    }
  ],
  messages: [
    { role: "user", content: "Save a picture of a cat to my desktop." }
  ],
  betas: ["computer-use-2025-11-24"]
)

puts response

Beta header는 computer use tool에만 필요하다.

위의 예제는 세 가지 도구를 함께 사용하는 것을 보여주는데, 이는 computer use tool을 포함하고 있기 때문에 beta header가 필요하다.

Computer use의 작동 방식

1
Claude에게 computer use tool과 사용자 프롬프트 제공
  • API 요청에 computer use tool(및 선택적으로 다른 도구)을 추가한다.
  • 데스크톱 상호작용이 필요한 사용자 프롬프트를 포함한다. 예: "Save a picture of a cat to my desktop."
2
Claude가 computer use tool을 사용하기로 결정
  • Claude는 사용자의 쿼리에 computer use tool이 도움이 될 수 있는지 평가한다.
  • 그렇다면 Claude는 적절히 형식화된 tool use 요청을 구성한다.
  • API 응답은 Claude의 의도를 나타내는 tool_use의 stop_reason을 가진다.
3
Tool 입력 추출, 컴퓨터에서 tool 평가, 결과 반환
  • 사용자 측에서 Claude의 요청에서 tool 이름과 입력을 추출한다.
  • 컨테이너 또는 가상 머신에서 tool을 사용한다.
  • tool_result 콘텐츠 블록을 포함한 새로운 user 메시지로 대화를 계속한다.
4
Claude가 작업을 완료할 때까지 computer use tool을 계속 호출
  • Claude는 더 많은 tool 사용이 필요한지 또는 작업이 완료되었는지 결정하기 위해 tool 결과를 분석한다.
  • Claude가 다른 tool이 필요하다고 결정하면 tool_use stop_reason으로 응답하고 3단계로 돌아가야 한다.
  • 그렇지 않으면 사용자에게 텍스트 응답을 작성한다.

3단계와 4단계의 반복은 사용자 입력 없이 이루어지며, 이를 "agent loop"(즉, Claude가 tool use 요청으로 응답하고 애플리케이션이 해당 요청을 평가한 결과를 Claude에게 반환하는 것)이라고 한다.

컴퓨팅 환경

Computer use는 Claude가 애플리케이션과 웹과 안전하게 상호작용할 수 있는 샌드박스 컴퓨팅 환경을 필요로 한다. 이 환경은 다음을 포함한다:

  1. Virtual display: Claude가 스크린샷을 통해 보고 마우스/키보드 동작으로 제어할 데스크톱 인터페이스를 렌더링하는 가상 X11 디스플레이 서버(Xvfb 사용).
  2. Desktop environment: Claude가 상호작용할 수 있는 일관된 그래픽 인터페이스를 제공하는 Linux에서 실행되는 가벼운 UI와 창 관리자(Mutter) 및 패널(Tint2).
  3. Applications: Claude가 작업을 완료하는 데 사용할 수 있는 Firefox, LibreOffice, 텍스트 편집기, 파일 관리자와 같은 사전 설치된 Linux 애플리케이션.
  4. Tool implementations: Claude의 추상적인 tool 요청(예: "마우스 이동" 또는 "스크린샷 찍기")을 가상 환경의 실제 작업으로 변환하는 통합 코드.
  5. Agent loop: 환경과 Claude 사이의 통신을 처리하고 Claude의 동작을 환경에 보내고 결과(스크린샷, 명령 출력 등)를 Claude에게 반환하는 프로그램.

Computer use를 사용할 때 Claude는 이 환경에 직접 연결하지 않는다. 대신 애플리케이션이 다음을 수행한다:

  1. Claude의 tool use 요청 수신
  2. 컴퓨팅 환경에서 동작으로 변환
  3. 결과(스크린샷, 명령 출력 등) 캡처
  4. 이러한 결과를 Claude에게 반환

보안과 격리를 위해 reference implementation은 환경 보기 및 상호작용을 위한 적절한 포트 매핑과 함께 Docker 컨테이너 내부에서 모든 것을 실행한다.

Computer use 구현 방법

Reference implementation으로 시작

Reference implementation은 computer use로 빠르게 시작하는 데 필요한 모든 것을 포함하고 있다:

다중 agent loop 이해

Computer use의 핵심은 "agent loop"이다. 여기서 Claude는 tool 동작을 요청하고, 애플리케이션이 이를 실행하며, 결과를 Claude에게 반환하는 주기이다. 다음은 단순화된 예제이다:

Python
async def sampling_loop(
    *,
    model: str,
    messages: list[dict],
    api_key: str,
    max_tokens: int = 4096,
    tool_version: str,
    thinking_budget: int | None = None,
    max_iterations: int = 10,  # 무한 루프 방지를 위한 반복 제한 추가
):
    """
    Claude computer use 상호작용을 위한 간단한 agent loop.

    이 함수는 다음 사이의 왕복을 처리한다:
    1. 사용자 메시지를 Claude에게 보내기
    2. Claude의 tool 사용 요청
    3. 앱이 해당 도구 실행
    4. tool 결과를 Claude에게 다시 보내기
    """
    # 도구 및 API 매개변수 설정
    client = Anthropic(api_key=api_key)
    beta_flag = (
        "computer-use-2025-11-24"
        if "20251124" in tool_version
        else "computer-use-2025-01-24"
        if "20250124" in tool_version
        else "computer-use-2024-10-22"
    )

    # 도구 구성 - 이미 다른 곳에서 초기화되어 있어야 한다
    tools = [
        {
            "type": f"computer_{tool_version}",
            "name": "computer",
            "display_width_px": 1024,
            "display_height_px": 768,
        },
        {"type": f"text_editor_{tool_version}", "name": "str_replace_editor"},
        {"type": f"bash_{tool_version}", "name": "bash"},
    ]

    # 무한 루프 방지를 위한 반복 제한이 있는 주요 agent loop
    iterations = 0
    while True and iterations < max_iterations:
        iterations += 1
        # 선택적 thinking 매개변수 설정(Claude Sonnet 3.7용)
        thinking = None
        if thinking_budget:
            thinking = {"type": "enabled", "budget_tokens": thinking_budget}

        # Claude API 호출
        response = client.beta.messages.create(
            model=model,
            max_tokens=max_tokens,
            messages=messages,
            tools=tools,
            betas=[beta_flag],
            thinking=thinking,
        )

        # Claude의 응답을 대화 기록에 추가
        response_content = response.content
        messages.append({"role": "assistant", "content": response_content})

        # Claude가 도구를 사용했는지 확인
        tool_results = []
        for block in response_content:
            if block.type == "tool_use":
                # 실제 앱에서는 여기서 도구를 실행할 것이다
                # 예: result = run_tool(block.name, block.input)
                result = {"result": "Tool executed successfully"}

                # Claude를 위한 결과 형식 지정
                tool_results.append(
                    {"type": "tool_result", "tool_use_id": block.id, "content": result}
                )

        # 도구를 사용하지 않은 경우 Claude가 완료됨 - 최종 메시지 반환
        if not tool_results:
            return messages

        # 다음 Claude 반복을 위해 메시지에 tool 결과 추가
        messages.append({"role": "user", "content": tool_results})

루프는 Claude가 도구를 요청하지 않고 응답할 때(작업 완료) 또는 최대 반복 제한에 도달할 때까지 계속된다. 이 안전장치는 예상치 못한 API 비용을 초래할 수 있는 잠재적인 무한 루프를 방지한다.

이 문서의 나머지 부분을 읽기 전에 reference implementation을 먼저 시도해 보기 바란다.

프롬프팅으로 모델 성능 최적화

최상의 품질 출력을 얻는 방법에 대한 팁은 다음과 같다:

  1. 각 단계에 대한 명시적인 지시와 함께 간단하고 잘 정의된 작업을 지정한다.
  2. Claude는 때때로 결과를 명시적으로 확인하지 않고 자신의 작업 결과를 가정한다. 이를 방지하기 위해 다음과 같이 Claude에게 프롬프트를 제공할 수 있다: After each step, take a screenshot and carefully evaluate if you have achieved the right outcome. Explicitly show your thinking: "I have evaluated step X..." If not correct, try again. Only when you confirm a step was executed correctly should you move on to the next one.
  3. 일부 UI 요소(드롭다운 및 스크롤바와 같은)는 마우스 움직임을 사용하여 Claude가 조작하기 어려울 수 있다. 이러한 문제를 경험한다면 모델에게 키보드 단축키를 사용하도록 프롬프트를 시도해 본다.
  4. 반복 가능한 작업이나 UI 상호작용의 경우 프롬프트에 성공적인 결과의 예제 스크린샷과 tool 호출을 포함한다.
  5. 모델에게 로그인이 필요한 경우, <robot_credentials>와 같은 XML 태그 안에 사용자 이름과 비밀번호를 프롬프트에 제공한다. Computer use를 로그인이 필요한 애플리케이션 내에서 사용하면 프롬프트 인젝션으로 인한 부정적인 결과의 위험이 증가한다. 모델에 로그인 자격 증명을 제공하기 전에 guide on mitigating prompt injections을 검토한다.

명확한 문제 집합을 반복적으로 경험하거나 Claude가 완료해야 할 작업을 미리 알고 있다면, 시스템 프롬프트를 사용하여 Claude에게 작업을 성공적으로 수행하는 방법에 대한 명시적인 팁이나 지시를 제공한다.

여러 세션에 걸친 에이전트의 경우, 구현 후뿐만 아니라 각 세션 시작 시 종단 간 검증을 실행한다. 브라우저 기반 확인은 코드 수준 검토만으로는 놓칠 수 있는 이전 세션의 회귀를 포착한다. 자세한 내용은 Effective harnesses for long-running agents를 참조한다.

시스템 프롬프트

Anthropic 정의 도구 중 하나가 Claude API를 통해 요청되면 computer use 특정 시스템 프롬프트가 생성된다. 이는 tool use system prompt와 유사하지만 다음으로 시작한다:

You have access to a set of functions you can use to answer the user's question. This includes access to a sandboxed computing environment. You do NOT currently have the ability to inspect files or interact with external resources, except by invoking the below functions.

일반적인 tool use와 마찬가지로 사용자 제공 system_prompt 필드는 여전히 존중되며 결합된 시스템 프롬프트의 구성에 사용된다.

사용 가능한 동작

Computer use tool은 다음 동작을 지원한다:

기본 동작(모든 버전)

  • screenshot - 현재 디스플레이 캡처
  • left_click - 좌표 [x, y]에서 클릭
  • type - 텍스트 문자열 입력
  • key - 키 또는 키 조합 누르기(예: "ctrl+s")
  • mouse_move - 좌표로 커서 이동

향상된 동작(computer_20250124)

Claude 4 모델과 Claude Sonnet 3.7에서 사용 가능:

  • scroll - 양을 제어하여 모든 방향으로 스크롤
  • left_click_drag - 좌표 간 클릭 및 드래그
  • right_click, middle_click - 추가 마우스 버튼
  • double_click, triple_click - 다중 클릭
  • left_mouse_down, left_mouse_up - 세밀한 클릭 제어
  • hold_key - 지정된 기간(초) 동안 키 누르기 유지
  • wait - 동작 간 일시 중지

향상된 동작(computer_20251124)

Claude Opus 4.6 및 Claude Opus 4.5에서 사용 가능:

  • computer_20250124의 모든 동작
  • zoom - 전체 해상도로 화면의 특정 영역 보기. tool 정의에서 enable_zoom: true가 필요함. 검사할 영역의 좌상단과 우하단 모서리를 정의하는 [x1, y1, x2, y2] 좌표를 포함하는 region 매개변수 사용.
Example actions

스크린샷 찍기:

{
  "action": "screenshot"
}

위치에서 클릭:

{
  "action": "left_click",
  "coordinate": [500, 300]
}

텍스트 입력:

{
  "action": "type",
  "text": "Hello, world!"
}

아래로 스크롤(Claude 4/3.7):

{
  "action": "scroll",
  "coordinate": [500, 400],
  "scroll_direction": "down",
  "scroll_amount": 3
}

상세한 영역 보기를 위한 줌(Opus 4.5):

{
  "action": "zoom",
  "region": [100, 200, 400, 350]
}
Modifier keys with click and scroll actions

클릭 또는 스크롤 동작을 수행하는 동안 수정자 키(Shift, Ctrl 또는 Alt 등)를 누르고 있으려면 해당 동작의 text 매개변수를 사용한다. 이는 다른 동작 없이 일정 기간 동안 키를 누르기만 하는 hold_key와 다르다.

Shift+클릭(예: 항목 범위 선택):

{
  "action": "left_click",
  "coordinate": [500, 300],
  "text": "shift"
}

Ctrl+클릭(예: Windows/Linux에서 다중 선택):

{
  "action": "left_click",
  "coordinate": [500, 300],
  "text": "ctrl"
}

Cmd+클릭(예: macOS에서 다중 선택):

{
  "action": "left_click",
  "coordinate": [500, 300],
  "text": "super"
}

Shift+스크롤(예: 가로 스크롤):

{
  "action": "scroll",
  "coordinate": [500, 400],
  "scroll_direction": "down",
  "scroll_amount": 3,
  "text": "shift"
}

클릭/스크롤 동작의 text 매개변수는 shift, ctrl, alt, 그리고 super(Command/Windows 키)와 같은 수정자 키를 허용한다.

Tool 매개변수

Parameter Required Description
type Yes Tool 버전 (computer_20251124, computer_20250124, 또는 computer_20241022)
name Yes 반드시 "computer"여야 함
display_width_px Yes 픽셀 단위 디스플레이 너비
display_height_px Yes 픽셀 단위 디스플레이 높이
display_number No X11 환경의 디스플레이 번호
enable_zoom No Zoom 동작 활성화 (computer_20251124만). Claude가 특정 화면 영역으로 줌 인할 수 있도록 true로 설정. 기본값: false

중요: computer use tool은 반드시 애플리케이션에 의해 명시적으로 실행되어야 한다 - Claude는 직접 실행할 수 없다. 스크린샷 캡처, 마우스 움직임, 키보드 입력 및 기타 동작을 Claude의 요청을 기반으로 구현하는 것은 사용자의 책임이다.

Claude 4 모델 및 Claude Sonnet 3.7에서 thinking 기능 활성화

Claude Sonnet 3.7은 복잡한 작업을 수행하면서 모델의 추론 과정을 볼 수 있는 새로운 "thinking" 기능을 도입했다. 이 기능은 Claude가 문제에 어떻게 접근하고 있는지 이해하는 데 도움이 되며 디버깅이나 교육 목적에 특히 가치가 있다.

Thinking을 활성화하려면 API 요청에 thinking 매개변수를 추가한다:

{
  "thinking": {
    "type": "enabled",
    "budget_tokens": 1024
  }
}

budget_tokens 매개변수는 Claude가 thinking에 사용할 수 있는 토큰 수를 지정한다. 이는 전체 max_tokens 예산에서 차감된다.

Thinking이 활성화되면 Claude는 응답의 일부로 추론 과정을 반환하며, 이는 다음에 도움이 될 수 있다:

  1. 모델의 의사결정 과정 이해
  2. 잠재적인 문제나 오해 식별
  3. Claude의 문제 해결 접근 방식에서 배우기
  4. 복잡한 다단계 작업에 대한 더 많은 가시성 얻기

다음은 thinking 출력이 어떤 모습인지에 대한 예시이다:

[Thinking]
I need to save a picture of a cat to the desktop. Let me break this down into steps:

1. First, I'll take a screenshot to see what's on the desktop
2. Then I'll look for a web browser to search for cat images
3. After finding a suitable image, I'll need to save it to the desktop

Let me start by taking a screenshot to see what's available...

다른 도구로 computer use 보강

Computer use tool은 다른 도구와 결합하여 더 강력한 자동화 워크플로우를 만들 수 있다. 이는 다음이 필요할 때 특히 유용하다:

  • 시스템 명령 실행(bash tool)
  • 구성 파일 또는 스크립트 편집(text editor tool)
  • 사용자 정의 API 또는 서비스와 통합(사용자 정의 도구)
Shell
curl https://api.anthropic.com/v1/messages \
  -H "content-type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: computer-use-2025-11-24" \
  -d '{
    "model": "claude-opus-4-6",
    "max_tokens": 2000,
    "tools": [
      {
        "type": "computer_20251124",
        "name": "computer",
        "display_width_px": 1024,
        "display_height_px": 768,
        "display_number": 1
      },
      {
        "type": "text_editor_20250728",
        "name": "str_replace_based_edit_tool"
      },
      {
        "type": "bash_20250124",
        "name": "bash"
      },
      {
        "name": "get_weather",
        "description": "Get the current weather in a given location",
        "input_schema": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "The city and state, e.g. San Francisco, CA"
            },
            "unit": {
              "type": "string",
              "enum": ["celsius", "fahrenheit"],
              "description": "The unit of temperature, either '\''celsius'\'' or '\''fahrenheit'\''"
            }
          },
          "required": ["location"]
        }
      }
    ],
    "messages": [
      {
        "role": "user",
        "content": "Find flights from San Francisco to a place with warmer weather."
      }
    ],
    "thinking": {
      "type": "enabled",
      "budget_tokens": 1024
    }
  }'
Python
import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-opus-4-6",
    max_tokens=2000,
    tools=[
        {
            "type": "computer_20251124",
            "name": "computer",
            "display_width_px": 1024,
            "display_height_px": 768,
            "display_number": 1,
        },
        {"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"},
        {"type": "bash_20250124", "name": "bash"},
        {
            "name": "get_weather",
            "description": "Get the current weather in a given location",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA",
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "The unit of temperature, either 'celsius' or 'fahrenheit'",
                    },
                },
                "required": ["location"],
            },
        },
    ],
    messages=[
        {
            "role": "user",
            "content": "Find flights from San Francisco to a place with warmer weather.",
        }
    ],
    betas=["computer-use-2025-11-24"],
    thinking={"type": "enabled", "budget_tokens": 1024},
)
print(response)
TypeScript
import Anthropic from "@anthropic-ai/sdk";

const anthropic = new Anthropic();

const message = await anthropic.beta.messages.create({
  model: "claude-opus-4-6",
  max_tokens: 4096,
  tools: [
    {
      type: "computer_20251124",
      name: "computer",
      display_width_px: 1024,
      display_height_px: 768,
      display_number: 1
    },
    {
      type: "text_editor_20250728",
      name: "str_replace_based_edit_tool"
    },
    {
      type: "bash_20250124",
      name: "bash"
    },
    {
      name: "get_weather",
      description: "Get the current weather in a given location",
      input_schema: {
        type: "object",
        properties: {
          location: {
            type: "string",
            description: "The city and state, e.g. San Francisco, CA"
          },
          unit: {
            type: "string",
            enum: ["celsius", "fahrenheit"],
            description: "The unit of temperature, either 'celsius' or 'fahrenheit'"
          }
        },
        required: ["location"]
      }
    }
  ],
  messages: [
    {
      role: "user",
      content: "Find flights from San Francisco to a place with warmer weather."
    }
  ],
  betas: ["computer-use-2025-11-24"],
  thinking: { type: "enabled", budget_tokens: 1024 }
});
console.log(message);
C#
using System;
using System.Collections.Generic;
using System.Text.Json;
using System.Threading.Tasks;
using Anthropic;
using Anthropic.Models.Beta.Messages;

public class Program
{
    public static async Task Main(string[] args)
    {
        AnthropicClient client = new()
        {
            ApiKey = Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY")
        };

        var parameters = new MessageCreateParams
        {
            Model = Model.ClaudeOpus4_6,
            MaxTokens = 2000,
            Tools = new BetaToolUnion[]
            {
                new BetaToolComputerUse20251124
                {
                    DisplayWidthPx = 1024,
                    DisplayHeightPx = 768,
                    DisplayNumber = 1
                },
                new BetaToolTextEditor20250728(),
                new BetaToolBash20250124(),
                new BetaTool
                {
                    Name = "get_weather",
                    Description = "Get the current weather in a given location",
                    InputSchema = new InputSchema
                    {
                        Properties = new Dictionary<string, JsonElement>
                        {
                            ["location"] = JsonSerializer.SerializeToElement(new
                            {
                                type = "string",
                                description = "The city and state, e.g. San Francisco, CA"
                            }),
                            ["unit"] = JsonSerializer.SerializeToElement(new
                            {
                                type = "string",
                                @enum = new[] { "celsius", "fahrenheit" },
                                description = "The unit of temperature, either 'celsius' or 'fahrenheit'"
                            })
                        },
                        Required = ["location"]
                    }
                }
            },
            Messages = new BetaMessageParam[]
            {
                new()
                {
                    Role = Role.User,
                    Content = "Find flights from San Francisco to a place with warmer weather."
                }
            },
            Betas = ["computer-use-2025-11-24"],
            Thinking = new BetaThinkingConfigParam(new BetaThinkingConfigEnabled(1024))
        };

        var message = await client.Beta.Messages.Create(parameters);
        Console.WriteLine(message);
    }
}
Go
package main

import (
	"context"
	"fmt"
	"log"

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

func main() {
	client := anthropic.NewClient()

	response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
		Model:     anthropic.ModelClaudeOpus4_6,
		MaxTokens: 16384,
		Tools: []anthropic.BetaToolUnionParam{
			{OfComputerUseTool20251124: &anthropic.BetaToolComputerUse20251124Param{
				DisplayWidthPx:  1024,
				DisplayHeightPx: 768,
				DisplayNumber:   anthropic.Int(1),
			}},
			{OfTextEditor20250728: &anthropic.BetaToolTextEditor20250728Param{}},
			{OfBashTool20250124: &anthropic.BetaToolBash20250124Param{}},
			{OfTool: &anthropic.BetaToolParam{
				Name:        "get_weather",
				Description: anthropic.String("Get the current weather in a given location"),
				InputSchema: anthropic.BetaToolInputSchemaParam{
					Properties: map[string]any{
						"location": map[string]any{
							"type":        "string",
							"description": "The city and state, e.g. San Francisco, CA",
						},
						"unit": map[string]any{
							"type":        "string",
							"enum":        []string{"celsius", "fahrenheit"},
							"description": "The unit of temperature, either 'celsius' or 'fahrenheit'",
						},
					},
					Required: []string{"location"},
				},
			}},
		},
		Messages: []anthropic.BetaMessageParam{
			anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Find flights from San Francisco to a place with warmer weather.")),
		},
		Thinking: anthropic.BetaThinkingConfigParamOfEnabled(1024),
		Betas:    []anthropic.AnthropicBeta{anthropic.AnthropicBetaComputerUse2025_11_24},
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(response)
}
Java
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.core.JsonValue;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaTool;
import com.anthropic.models.beta.messages.BetaToolBash20250124;
import com.anthropic.models.beta.messages.BetaToolComputerUse20251124;
import com.anthropic.models.beta.messages.BetaToolTextEditor20250728;
import com.anthropic.models.beta.messages.MessageCreateParams;
import java.util.List;
import java.util.Map;

public class MultipleToolsExample {

    public static void main(String[] args) {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
        .model("claude-opus-4-6")
        .maxTokens(16384L)
        .addTool(
          BetaToolComputerUse20251124.builder()
            .displayWidthPx(1024L)
            .displayHeightPx(768L)
            .displayNumber(1L)
            .build()
        )
        .addTool(BetaToolTextEditor20250728.builder().build())
        .addTool(BetaToolBash20250124.builder().build())
        .addTool(
          BetaTool.builder()
            .name("get_weather")
            .description("Get the current weather in a given location")
            .inputSchema(
              BetaTool.InputSchema.builder()
                .properties(
                  BetaTool.InputSchema.Properties.builder()
                    .putAdditionalProperty(
                      "location",
                      JsonValue.from(
                        Map.of(
                          "type", "string",
                          "description", "The city and state, e.g. San Francisco, CA"
                        )
                      )
                    )
                    .putAdditionalProperty(
                      "unit",
                      JsonValue.from(
                        Map.of(
                          "type", "string",
                          "enum", List.of("celsius", "fahrenheit"),
                          "description", "The unit of temperature, either 'celsius' or 'fahrenheit'"
                        )
                      )
                    )
                    .build()
                )
                .build()
            )
            .build()
        )
        .enabledThinking(1024L)
        .addUserMessage("Find flights from San Francisco to a place with warmer weather.")
        .addBeta("computer-use-2025-11-24")
        .build();

      BetaMessage message = client.beta().messages().create(params);
      System.out.println(message);
    }
}
PHP
<?php

use Anthropic\Client;

$client = new Client(apiKey: getenv("ANTHROPIC_API_KEY"));

$message = $client->beta->messages->create(
    maxTokens: 2000,
    messages: [
        ['role' => 'user', 'content' => 'Find flights from San Francisco to a place with warmer weather.'],
    ],
    model: 'claude-opus-4-6',
    tools: [
        [
            'type' => 'computer_20251124',
            'name' => 'computer',
            'display_width_px' => 1024,
            'display_height_px' => 768,
            'display_number' => 1,
        ],
        [
            'type' => 'text_editor_20250728',
            'name' => 'str_replace_based_edit_tool',
        ],
        [
            'type' => 'bash_20250124',
            'name' => 'bash',
        ],
        [
            'name' => 'get_weather',
            'description' => 'Get the current weather in a given location',
            'input_schema' => [
                'type' => 'object',
                'properties' => [
                    'location' => [
                        'type' => 'string',
                        'description' => 'The city and state, e.g. San Francisco, CA',
                    ],
                    'unit' => [
                        'type' => 'string',
                        'enum' => ['celsius', 'fahrenheit'],
                        'description' => 'The unit of temperature, either \'celsius\' or \'fahrenheit\'',
                    ],
                ],
                'required' => ['location'],
            ],
        ],
    ],
    betas: ['computer-use-2025-11-24'],
    thinking: ['type' => 'enabled', 'budget_tokens' => 1024],
);

echo $message;
Ruby
require "anthropic"

client = Anthropic::Client.new

message = client.beta.messages.create(
  model: "claude-opus-4-6",
  max_tokens: 2000,
  tools: [
    {
      type: "computer_20251124",
      name: "computer",
      display_width_px: 1024,
      display_height_px: 768,
      display_number: 1
    },
    {
      type: "text_editor_20250728",
      name: "str_replace_based_edit_tool"
    },
    {
      type: "bash_20250124",
      name: "bash"
    },
    {
      name: "get_weather",
      description: "Get the current weather in a given location",
      input_schema: {
        type: "object",
        properties: {
          location: {
            type: "string",
            description: "The city and state, e.g. San Francisco, CA"
          },
          unit: {
            type: "string",
            enum: ["celsius", "fahrenheit"],
            description: "The unit of temperature, either 'celsius' or 'fahrenheit'"
          }
        },
        required: ["location"]
      }
    }
  ],
  messages: [
    {
      role: "user",
      content: "Find flights from San Francisco to a place with warmer weather."
    }
  ],
  betas: ["computer-use-2025-11-24"],
  thinking: {
    type: "enabled",
    budget_tokens: 1024
  }
)
puts message

사용자 정의 computer use 환경 구축

Reference implementation은 computer use를 시작하는 데 도움이 되도록 만들어졌다. Claude가 컴퓨터를 사용하는 데 필요한 모든 구성 요소를 포함하고 있다. 그러나 필요에 맞는 자신만의 computer use 환경을 구축할 수 있다. 다음이 필요하다:

  • Claude용 computer use에 적합한 가상화되거나 컨테이너화된 환경
  • Anthropic 정의 computer use 도구 중 하나 이상의 구현
  • Claude API와 상호작용하고 tool 구현을 사용하여 tool_use 결과를 실행하는 agent loop
  • Agent loop을 시작하기 위한 사용자 입력을 허용하는 API 또는 UI

Computer use tool 구현

Computer use tool은 스키마 없는 tool로 구현된다. 이 tool을 사용할 때는 다른 도구와 같이 입력 스키마를 제공할 필요가 없다. 스키마는 Claude의 모델에 내장되어 있으며 수정할 수 없다.

1
컴퓨팅 환경 설정

Claude가 상호작용할 가상 디스플레이를 만들거나 기존 디스플레이에 연결한다. 이는 일반적으로 Xvfb(X Virtual Framebuffer) 또는 유사한 기술을 설정하는 것을 포함한다.

2
동작 핸들러 구현

Claude가 요청할 수 있는 각 동작 유형을 처리하는 함수를 만든다:

def handle_computer_action(action_type, params):
    if action_type == "screenshot":
        return capture_screenshot()
    elif action_type == "left_click":
        x, y = params["coordinate"]
        return click_at(x, y)
    elif action_type == "type":
        return type_text(params["text"])
    # ... 다른 동작 처리
3
Claude의 tool 호출 처리

Claude의 응답에서 tool 호출을 추출하고 실행한다:

for content in response.content:
    if content.type == "tool_use":
        action = content.input["action"]
        result = handle_computer_action(action, content.input)

        # Claude에게 결과 반환
        tool_result = {
            "type": "tool_result",
            "tool_use_id": content.id,
            "content": result,
        }
4
Agent loop 구현

Claude가 작업을 완료할 때까지 계속되는 루프를 만든다:

while True:
    response = client.beta.messages.create(...)

    # Claude가 도구를 사용했는지 확인
    tool_results = process_tool_calls(response)

    if not tool_results:
        # 더 이상 tool 사용 없음, 작업 완료
        break

    # tool 결과로 대화 계속
    messages.append({"role": "user", "content": tool_results})

오류 처리

Computer use tool을 구현할 때 다양한 오류가 발생할 수 있다. 다음은 이를 처리하는 방법이다:

Screenshot capture failure

스크린샷 캡처가 실패하면 적절한 오류 메시지를 반환한다:

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "Error: Failed to capture screenshot. Display may be locked or unavailable.",
      "is_error": true
    }
  ]
}
Invalid coordinates

Claude가 디스플레이 범위를 벗어나는 좌표를 제공한 경우:

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "Error: Coordinates (1200, 900) are outside display bounds (1024x768).",
      "is_error": true
    }
  ]
}
Action execution failure

동작 실행이 실패한 경우:

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "Error: Failed to perform click action. The application may be unresponsive.",
      "is_error": true
    }
  ]
}

더 높은 해상도를 위한 좌표 스케일링 처리

API는 이미지를 최대 긴 모서리 1568 픽셀 및 총 약 1.15 메가픽셀로 제한한다(자세한 내용은 image resizing 참조). 예를 들어, 1512x982 화면은 약 1330x864로 다운샘플링된다. Claude는 이 더 작은 이미지를 분석하고 해당 공간에서 좌표를 반환하지만, tool은 원래 화면 공간에서 클릭을 실행한다.

이것이 좌표 변환을 처리하지 않으면 Claude의 클릭 좌표가 대상을 놓칠 수 있다.

이를 해결하려면 스크린샷을 직접 크기를 조정하고 Claude의 좌표를 다시 확대한다:

Python
import math


def get_scale_factor(width, height):
    """Calculate scale factor to meet API constraints."""
    long_edge = max(width, height)
    total_pixels = width * height

    long_edge_scale = 1568 / long_edge
    total_pixels_scale = math.sqrt(1_150_000 / total_pixels)

    return min(1.0, long_edge_scale, total_pixels_scale)


# 스크린샷을 캡처할 때
scale = get_scale_factor(screen_width, screen_height)
scaled_width = int(screen_width * scale)
scaled_height = int(screen_height * scale)

# Claude에게 보내기 전에 이미지를 크기 조정된 크기로 조정
screenshot = capture_and_resize(scaled_width, scaled_height)


# Claude의 좌표를 처리할 때, 다시 확대
func execute_click(x, y):
    screen_x = x / scale
    screen_y = y / scale
    perform_click(screen_x, screen_y)
TypeScript
const MAX_LONG_EDGE = 1568;
const MAX_PIXELS = 1_150_000;

function getScaleFactor(width: number, height: number): number {
  const longEdge = Math.max(width, height);
  const totalPixels = width * height;

  const longEdgeScale = MAX_LONG_EDGE / longEdge;
  const totalPixelsScale = Math.sqrt(MAX_PIXELS / totalPixels);

  return Math.min(1.0, longEdgeScale, totalPixelsScale);
}

// 스크린샷을 캡처할 때
const scale = getScaleFactor(screenWidth, screenHeight);
const scaledWidth = Math.floor(screenWidth * scale);
const scaledHeight = Math.floor(screenHeight * scale);

// Claude에게 보내기 전에 이미지를 크기 조정된 크기로 조정
const screenshot = captureAndResize(scaledWidth, scaledHeight);

// Claude의 좌표를 처리할 때, 다시 확대
function executeClick(x: number, y: number): void {
  const screenX = x / scale;
  const screenY = y / scale;
  performClick(screenX, screenY);
}

구현 모범 사례 따르기

Use appropriate display resolution

권장 제한 내에서 유지하면서 사용 사례에 맞는 디스플레이 크기를 설정한다:

  • 일반적인 데스크톱 작업: 1024x768 또는 1280x720
  • 웹 애플리케이션: 1280x800 또는 1366x768
  • 성능 문제를 방지하기 위해 1920x1080 이상의 해상도는 피한다
Implement proper screenshot handling

Claude에게 스크린샷을 반환할 때:

  • 스크린샷을 base64 PNG 또는 JPEG로 인코딩
  • 성능 향상을 위해 큰 스크린샷 압축 고려
  • 타임스탬프 또는 디스플레이 상태와 같은 관련 메타데이터 포함
  • 더 높은 해상도를 사용하는 경우 좌표가 정확히 스케일링되었는지 확인
Add action delays

일부 애플리케이션은 동작에 반응하는 데 시간이 필요하다:

def click_and_wait(x, y, wait_time=0.5):
    click_at(x, y)
    time.sleep(wait_time)  # UI 업데이트 허용
Validate actions before execution

요청된 동작이 안전하고 유효한지 확인한다:

def validate_action(action_type, params):
    if action_type == "left_click":
        x, y = params.get("coordinate", (0, 0))
        if not (0 <= x < display_width and 0 <= y < display_height):
            return False, "Coordinates out of bounds"
    return True, None
Log actions for debugging

문제 해결을 위해 모든 동작의 로그를 유지한다:

import logging


def log_action(action_type, params, result):
    logging.info(f"Action: {action_type}, Params: {params}, Result: {result}")

Computer use 제한 사항 이해

Computer use 기능은 베타 상태이다. Claude의 기능은 최첨단이지만 개발자는 그 제한 사항을 알아야 한다:

  1. Latency: 현재 computer use의 인간-AI 상호작용 지연 시간은 일반적인 인간이 지시하는 컴퓨터 동작에 비해 너무 느릴 수 있다. 신뢰할 수 있는 환경에서 속도가 중요하지 않은 사용 사례(예: 백그라운드 정보 수집, 자동화된 소프트웨어 테스트)에 중점을 둔다.
  2. Computer vision 정확도와 안정성: Claude는 동작을 생성하면서 특정 좌표를 출력할 때 실수를 하거나 환각을 일으킬 수 있다. Claude Sonnet 3.7은 모델의 추론을 이해하고 잠재적인 문제를 식별하는 데 도움이 될 수 있는 thinking 기능을 도입했다.
  3. Tool 선택 정확도와 안정성: Claude는 동작을 생성하면서 도구를 선택하거나 문제를 해결하기 위해 예상치 못한 동작을 취할 때 실수를 하거나 환각을 일으킬 수 있다. 또한 틈새 애플리케이션이나 여러 애플리케이션과 동시에 상호작용할 때 안정성이 낮을 수 있다. 복잡한 작업을 요청할 때 모델에게 신중하게 프롬프트를 제공한다.
  4. Scrolling 안정성: Claude Sonnet 3.7은 방향 제어가 있는 전용 스크롤 동작을 도입하여 안정성을 향상시켰다. 이제 모델은 지정된 양만큼 모든 방향(위/아래/왼쪽/오른쪽)으로 명시적으로 스크롤할 수 있다.
  5. Spreadsheet 상호작용: Claude Sonnet 3.7에서 left_mouse_down, left_mouse_up 및 새로운 수정자 키 지원과 같은 더 정밀한 마우스 제어 동작의 추가로 스프레드시트 상호작용을 위한 마우스 클릭이 개선되었다. 이러한 세밀한 제어와 수정자 키를 클릭과 결합하여 셀 선택을 더 안정적으로 할 수 있다.
  6. 소셜 및 커뮤니케이션 플랫폼의 계정 생성 및 콘텐츠 생성: Claude는 웹사이트를 방문하지만, Claude가 소셜 미디어 웹사이트와 플랫폼에서 계정을 만들거나 콘텐츠를 생성하고 공유하거나 인간을 가장하여 참여하는 능력은 제한된다. 이 기능은 향후 업데이트될 수 있다.
  7. 취약점: 탈옥이나 프롬프트 인젝션과 같은 취약점은 베타 computer use API를 포함한 최첨단 AI 시스템에서 지속될 수 있다. 일부 상황에서 Claude는 사용자의 지시와 충돌하는 경우에도 콘텐츠에서 발견된 명령을 따를 수 있다. 예를 들어, 웹페이지의 Claude 지시나 이미지에 포함된 지시가 지시를 무시하거나 Claude가 실수를 하게 할 수 있다. 다음을 고려한다:
    1. Computer use를 최소한의 권한을 가진 가상 머신이나 컨테이너와 같은 신뢰할 수 있는 환경으로 제한
    2. 엄격한 감독 없이 computer use가 민감한 계정이나 데이터에 액세스하는 것을 피함
    3. 애플리케이션에서 computer use 기능에 필요한 권한을 활성화하거나 요청하기 전에 최종 사용자에게 관련 위험을 알리고 동의를 얻음
  8. 부적절하거나 불법적인 동작: Anthropic의 서비스 약관에 따라 computer use를 사용하여 법률이나 허용 사용 정책을 위반해서는 안 된다.

Claude의 computer use 동작과 로그를 항상 신중하게 검토하고 확인한다. 인간의 감독 없이 완벽한 정확도가 필요한 작업이나 민감한 사용자 정보가 필요한 작업에는 Claude를 사용하지 않는다.

가격

Computer use는 표준 tool use 가격을 따른다. Computer use tool을 사용할 때:

시스템 프롬프트 오버헤드: Computer use 베타는 시스템 프롬프트에 466-499 토큰을 추가한다

Computer use tool 토큰 사용량:

Model Input tokens per tool definition
Claude 4.x models 735 tokens
Claude Sonnet 3.7 (deprecated) 735 tokens

추가 토큰 소비:

  • 스크린샷 이미지(Vision 가격 참조)
  • Claude에게 반환된 tool 실행 결과

Computer use와 함께 bash 또는 텍스트 편집기 도구를 사용하는 경우, 해당 도구는 각각의 페이지에 문서화된 대로 자체 토큰 비용을 가진다.

반응형
저작자표시 비영리 변경금지 (새창열림)

'AI > Claude Code' 카테고리의 다른 글

Claude Code: 제대로 알고 쓰자(channels 편)  (0) 2026.03.20
Claude Code: 제대로 알고 쓰자(remote control편)  (0) 2026.02.27
Claude Code: 제대로 알고 쓰자(mcp편)  (0) 2026.02.10
Claude Code: 제대로 알고 쓰자(hooks편)  (0) 2026.02.10
Claude Code: 제대로 알고 쓰자(agent team편)  (0) 2026.02.09
'AI/Claude Code' Related Articles more