Claude Agent SDK + Ertas

Build agents with the Claude Agent SDK — Anthropic's official framework with computer-use, code execution, and file system primitives, configurable to run against Ertas-trained local models via OpenAI-compatible adapters.

Overview

The Claude Agent SDK is Anthropic's official framework for building agents that can take action in computer environments. It exposes a small set of high-level primitives — computer-use (mouse, keyboard, screenshots), code execution (Python sandboxes), file system access, and web search — that together implement Anthropic's 'give the agent a computer' design philosophy. Rather than making the agent compose actions from low-level tool calls, the SDK provides production-grade implementations of common environments and lets the model reason at a higher level. The May 8, 2026 release added a `defer` permission decision in `PreToolUse` hooks (so a hook can postpone the call until additional context arrives), a `strict` MCP configuration option, batched and eager `session_store_flush` modes for live transcript tailing, and a new `xhigh` effort level — operational primitives that materially improve production observability and safety review workflows.

The SDK is most often used with Claude itself, but its design is model-agnostic at the orchestration layer. The agent loop, the action executors, and the safety primitives all sit above the model API, which means any model that supports tool calling and function output can be plugged in. For teams that want the SDK's environment primitives but don't want to be locked into Claude's API economics, the framework can be configured to call an OpenAI-compatible endpoint serving an Ertas-trained model — gaining computer-use, code execution, and file system actions while controlling inference costs.

Claude Agent SDK adoption accelerated rapidly through 2026 because of its environment primitives. Most agent frameworks leave the user to implement computer-use, sandboxed code execution, and file system tooling — work that is non-trivial and often the source of production bugs and security vulnerabilities. The SDK provides battle-tested implementations of these out of the box.

How Ertas Integrates

Ertas-trained models work with the Claude Agent SDK through its model-provider configuration layer. After fine-tuning your model in Ertas Studio and deploying to an OpenAI-compatible endpoint, you configure the SDK to use your endpoint as the model provider. The SDK's environment primitives — computer-use, code execution, file system access — work transparently regardless of which model is generating the actions.

For agentic workflows where the model needs to reason about computer environments, fine-tuning is unusually valuable. A general-purpose 7B–14B model often produces clumsy or unsafe action sequences when handed a computer; an Ertas-trained model whose training data includes representative computer-use traces from the target domain (e.g., your company's internal CRM, your Salesforce instance, your custom admin tools) produces dramatically more reliable action sequences. The SDK handles execution; Studio handles specialization.

The combination is particularly compelling for regulated-industry deployments. Claude Agent SDK plus an Ertas-trained model running on-premise lets organizations get the SDK's environment primitives without sending data or actions to Anthropic's API. Healthcare, legal, and financial-services teams that have considered Claude for agentic workflows but couldn't deploy due to data-sovereignty constraints can use this combination to deploy on their own infrastructure.

Getting Started

1
Fine-tune a domain-specific model in Ertas Studio
Train on traces of computer-use, tool calls, and code execution from your target environment. Studio's training data format supports the structured action-observation pairs the Agent SDK uses.
2
Deploy to an OpenAI-compatible endpoint
Export to GGUF and serve via Ollama, vLLM, or Ertas Cloud. The SDK calls any endpoint that exposes the standard chat-completion API with tool calling.
3
Install the Claude Agent SDK and configure the provider
Install claude-agent-sdk and configure its model provider to point at your Ertas inference endpoint. The SDK's adapter layer handles the API translation transparently.
4
Configure environment primitives
Enable the SDK's computer-use, code execution, and file system primitives as needed. Each runs in its own sandbox and exposes a structured action API the model can call.
5
Run the agent loop with safety and tracing
Use the SDK's built-in agent loop. Safety checks, action permissions, and tracing all work transparently regardless of the underlying model. Use traces to feed back into Studio for incremental improvement.

python

from claude_agent_sdk import Agent, ComputerUseTool, FileSystemTool
from claude_agent_sdk.providers import OpenAICompatibleProvider

# Configure the SDK to use your Ertas-trained model
provider = OpenAICompatibleProvider(
    base_url="http://localhost:11434/v1",
    api_key="not-needed",
    model="ertas-internal-ops-14b",
)

agent = Agent(
    provider=provider,
    tools=[
        ComputerUseTool(sandbox="docker:secure-desktop"),
        FileSystemTool(root="/data/internal-ops"),
    ],
    instructions="You operate the internal-ops console — schedule reports, run queries, file tickets.",
)

# Run an action sequence — the SDK handles screenshots, action permissions, and tracing
result = agent.run(
    "Run the weekly revenue report and file a ticket for any rows where revenue dropped >20% week-over-week."
)
print(result.summary)

Build an internal-ops automation agent with the Claude Agent SDK and a 14B Ertas-trained model. Computer-use and file system primitives are handled by the SDK; the model is fine-tuned for the company's specific tools.

Benefits

Production-grade environment primitives — computer-use, code execution, file system, web search
Model-agnostic orchestration layer works with Claude or any compatible alternative
Built-in safety primitives — action permissions, sandboxing, audit trails
Pairs with Ertas fine-tuning for domain-specific computer-use specialization
On-premise deployment story for regulated industries — no cloud egress
Production tracing and observability built in