Como Implantar e Hospedar o Claude Agent SDK com o Novita Sandbox

Em 2026, o cenário de IA atingiu um ponto de virada definitivo: a transição da inteligência experimental para a execução industrializada. Enquanto a primeira onda de IA focou na conversação, a era atual é definida pela agência.

Com o lançamento do Claude Agent SDK, o paradigma mudou de APIs sem estado para runtimes persistentes e com estado. Os desenvolvedores não estão mais satisfeitos com agentes que apenas geram código — eles exigem sistemas que possam executar, depurar e iterar de forma autônoma. Ao contrário dos LLMs tradicionais que “esquecem” após cada solicitação, o Claude Agent SDK agora mantém um loop de raciocínio contínuo, escrevendo código, depurando em tempo real e gerenciando sistemas de arquivos complexos.

No entanto, uma lacuna crítica permanece: a infraestrutura. Para passar de demonstração para uma força de trabalho digital de nível de produção, os agentes precisam de mais do que inteligência — eles precisam de ambientes seguros, escaláveis, de alta performance e acessíveis para realizar seu trabalho.

Aprenda a implantar e hospedar agentes Claude em produção usando o Novita Sandbox, um ambiente de execução em nuvem compatível com E2B que preenche essa lacuna com infraestrutura de nível empresarial e custo-benefício.

💡 Pronto para Começar a Construir?
A Novita fornece um exemplo completo e pronto para produção do Claude Agent SDK, com CLI interativa, implementações de ferramentas e melhores práticas. Clone o repositório e execute seu primeiro agente em minutos.

Principais Vantagens: Construído para a Anthropic

1. Migração Verdadeira “Sem Refatoração”

A Novita fornece um endpoint de API Anthropic totalmente compatível. Basta alterar um baseURL para dar aos seus aplicativos existentes alimentados por Claude capacidades de execução no mundo real.

• Integração Nativa: Use o @anthropic-ai/sdk diretamente — nenhum novo framework para aprender.
• Troca Sem Interrupções: Compatível com todos os recursos Beta, incluindo os modos context-management e thinking.

import Anthropic from "@anthropic-ai/sdk";

// Just modify baseURL to switch seamlessly to Novita
const anthropic = new Anthropic({
  baseURL: "https://api.novita.ai/anthropic",
  apiKey: process.env.NOVITA_API_KEY,
});

// All Anthropic SDK usage remains unchanged
const response = await anthropic.messages.create({
  model: "zai-org/glm-4.7",
  max_tokens: 4096,
  messages: [{ role: "user", content: "Hello, World!" }],
});

2. “Laboratório Sandbox” Isolado em Nuvem

O Novita Sandbox fornece ambientes Linux de lançamento instantâneo com acesso a sistema de arquivos, comunicação de rede e processos em segundo plano:

• Isolamento Seguro: Cada solicitação é executada em um sandbox independente, evitando contaminação de código.
• Capacidades Full-Stack: Ambientes integrados de Node.js, Python e Jupyter com suporte a instalação dinâmica de npm e pip.
• Pré-visualização Instantânea: Exposição de porta HTTPS pública com um clique — visualize as páginas geradas imediatamente.

import { Sandbox } from "novita-sandbox/code-interpreter";

// Create an isolated cloud environment in seconds
const sandbox = await Sandbox.create({ timeoutMs: 10 * 60 * 1000 });

// Write files
await sandbox.files.write("index.html", "<h1>Hello from Sandbox!</h1>");

// Start a background service and get a public URL
const handle = await sandbox.commands.run("npx http-server -p 3000", { background: true });
const publicUrl = `https://${sandbox.getHost(3000)}`;

console.log(`🌐 Preview URL: ${publicUrl}`);

3. Auto-Cura de Contexto e Consciência Inteligente

Aproveitando as capacidades de Uso de Ferramentas do Claude, os agentes podem:

• Adaptar e Reparar: Quando ocorrem erros de execução, o agente vê o stderr e reescreve o código automaticamente.
• Otimizar Memória: Combinado com estratégias de contextManagement, o sistema limpa automaticamente blocos de código antigos para manter o foco.

// Enable the context-management Beta feature
// Reference: https://platform.claude.com/docs/en/build-with-claude/context-editing
const response = await anthropic.beta.messages.create({
  model: "zai-org/glm-4.7",
  max_tokens: 4096,
  betas: ["context-management-2025-06-27"],
  contextManagement: {
    edits: [
      {
        type: "clear_tool_uses_20250919",
        trigger: { type: "input_tokens", value: 10000 },  // Trigger cleanup when exceeding 10k tokens
        keep: { type: "tool_uses", value: 2 },            // Keep the last 2 tool calls
        clear_tool_inputs: true,                          // Also clear tool inputs
      },
    ],
  },
  tools: TOOLS,
  messages: conversationHistory,
});

Como Funciona: Quando o contexto da conversação excede o limite definido, a API limpa automaticamente os resultados de chamadas de ferramentas anteriores, preservando as informações críticas recentes. Isso evita a “poluição de memória” que degrada o desempenho do agente.

Casos de Uso: Possibilidades Infinitas

Cenário	O que o Novita Sandbox Adiciona
Laboratório Web Interativo	Gere páginas React/Tailwind a partir de uma única frase; visualize instantaneamente.
Análise de Dados Inteligente	Execute Python dinamicamente para gerar gráficos com Pandas e Matplotlib.
Testes Automatizados com IA	Execute scripts de teste em ambientes isolados; capture e corrija bugs automaticamente.
Backend de IDE Personalizado	Forneça a cada usuário um executor de nuvem independente — sem sobrecarga de operações.
Fluxos de Trabalho de Código com Auto-Cura	Teste o código de API gerado em um loop fechado, garantindo que ele execute corretamente antes da entrega.

Início Rápido: Construa um Agente Interativo em Três Passos

Nenhuma configuração complexa necessária — a Novita torna o desenvolvimento simples.

Passo 1: Instalação Mínima

npm install @anthropic-ai/sdk novita-sandbox dotenv open

Passo 2: Integração Inteligente de Chave de API

O projeto inclui orientação interativa para a chave. Mesmo sem variáveis de ambiente, o programa solicita a chave na inicialização:

// agent_en.ts internal logic
if (!agent.hasApiKey()) {
  const apiKey = await promptForApiKey(rl);
  agent.setApiKey(apiKey);
}

Passo 3: Lançamento de CLI Interativa com Um Clique

Execute npm run agent-en para entrar no modo interativo. Basta inserir seus requisitos, e os modelos compatíveis com Anthropic cuidarão de gerar o código, executar os serviços e abrir o navegador.

npm run agent-en

Passo a Passo do Código Principal

📌 Definições de Ferramentas: Dando “Habilidades Físicas” à IA

const TOOLS: Anthropic.Beta.Messages.BetaTool[] = [
  {
    name: "write_file",
    description: "Create or modify a file in the sandbox",
    input_schema: {
      type: "object",
      properties: {
        path: { type: "string", description: "File path, e.g., index.html" },
        content: { type: "string", description: "Complete file content" },
      },
      required: ["path", "content"],
    },
  },
  {
    name: "get_preview_url",
    description: "Start the web server and get the preview URL (returns the existing URL if the server is already running)",
    input_schema: { type: "object", properties: {} },
  },
];

📌 Loop de Agente: Processar até a Conclusão da Tarefa

async chat(userMessage: string): Promise<void> {
  // Refresh sandbox timeout on each user input
  await this.refreshSandboxTimeout();
  
  this.messages.push({ role: "user", content: userMessage });

  // Agentic Loop—continue processing until no tool calls remain
  let continueLoop = true;
  while (continueLoop) {
    const { response, assistantContent } = await this.streamResponse();
    this.messages.push({ role: "assistant", content: assistantContent });

    // Process tool calls
    const { hasToolUse, toolResults } = await this.processToolCalls(assistantContent);

    if (hasToolUse && toolResults.length > 0) {
      this.messages.push({ role: "user", content: toolResults });
      continueLoop = true;  // Tool calls exist; continue loop
    } else {
      continueLoop = false; // No tool calls; end
    }

    if (response.stop_reason === "end_turn") {
      continueLoop = false;
    }
  }
}

📌 Auto-Cura de Serviço: Detecção Inteligente e Reinicialização Automática

private async handleGetPreviewUrl(): Promise<string> {
  // Verify whether the process is actually alive
  if (this.previewUrl && this.serverHandle) {
    const processAlive = await this.checkServerProcessAlive();
    if (!processAlive) {
      console.log(`⚠️ Server process has exited; restarting...`);
      this.serverHandle = null;
      this.previewUrl = null;
    }
  }

  // Start a new server
  this.serverHandle = await this.sandbox.commands.run(
    `npx -y http-server . -p ${CONFIG.serverPort} -c-1`,
    { background: true }
  );

  // Get the public URL and run a health check
  const host = this.sandbox.getHost(CONFIG.serverPort);
  this.previewUrl = `https://${host}`;
  
  await waitForServer(this.previewUrl, maxRetries, intervalMs);
  await openBrowser(this.previewUrl);
  
  return `Preview URL: ${this.previewUrl}`;
}

Explore o Exemplo Completo

A Novita fornece um exemplo totalmente funcional do Claude Agent SDK com padrões de código prontos para produção. O exemplo demonstra:

• Interface CLI interativa com respostas de streaming
• Implementações completas de ferramentas (operações de arquivo, execução de código, gerenciamento de servidor web)
• Gerenciamento de contexto com limpeza automática
• Tratamento de erros e lógica de repetição
• Verificações de saúde de serviço com reinicialização automática
• Conversa multi-turno com estado persistente

Repositório GitHub: Novita-CollabHub/examples/claude-agent

Início Rápido com o Exemplo:

# Clone o repositório
git clone https://github.com/novitalabs/Novita-CollabHub.git
cd Novita-CollabHub/examples/claude-agent

# Instale as dependências
npm install

# Defina sua chave de API
export NOVITA_API_KEY=your_api_key_here

# Execute o agente interativo
npm run agent-en

Demonstração de Diálogo Multi-Turno

Aqui está um exemplo completo de diálogo multi-turno que mostra como o agente refina iterativamente uma página com base no feedback do usuário:

Rodada 1: Criar um aplicativo de lista de tarefas

Entrada do Usuário: Criar um aplicativo de lista de tarefas

Rodada 2: Mudar para o Estilo Stardew Valley

Entrada do Usuário: Mudar para o estilo Stardew Valley

Rodada 3: Adicionar mais funções

Entrada do Usuário: Adicionar mais funções

Conclusão

Implantar o Claude Agent SDK em produção requer infraestrutura que as plataformas de nuvem tradicionais não foram projetadas para fornecer. O Novita Sandbox fornece uma infraestrutura pronta para produção que se integra perfeitamente ao Claude Agent SDK, dando aos seus agentes as “mãos” que eles precisam para trabalhar no mundo real, oferecendo:

• Ambiente de execução em nuvem compatível com E2B para integração perfeita com ferramentas existentes
• Endpoint nativo compatível com Anthropic que não requer nenhuma refatoração — basta alterar o baseURL
• Isolamento seguro de contêineres para execução de código não confiável
• Provisionamento instantâneo com runtimes pré-configurados
• Exposição de URL pública para aplicativos web gerados
• Gerenciamento de processos em segundo plano para serviços de longa duração

Comece a construir agentes de IA com estado hoje mesmo:

• Documentação do Novita Sandbox
• Exemplo Completo do Agent SDK

A Novita AI é uma plataforma de nuvem de IA líder que fornece aos desenvolvedores APIs fáceis de usar e infraestrutura GPU acessível e confiável para construir e escalar aplicativos de IA.