Agent Harness Capabilities

import { createDeepAgent } from 'ai-sdk-deep-agent';
import { anthropic } from '@ai-sdk/anthropic';

const agent = createDeepAgent({
  model: anthropic('claude-sonnet-4-5-20250929'),
});

// Agent can use all filesystem tools
const result = await agent.generate({
  prompt: `
  1. List all TypeScript files in the src directory
  2. Read the main.ts file
  3. Search for "TODO" comments across all files
  4. Create a summary file
  `,
});

const agent = createDeepAgent({
  model: anthropic('claude-sonnet-4-5-20250929'),
  toolResultEvictionLimit: 20000, // Default: 20,000 tokens
});

import {
  StateBackend,
  FilesystemBackend,
  PersistentBackend,
  CompositeBackend
} from 'ai-sdk-deep-agent';

// Example 1: Simple filesystem access
const agent = createDeepAgent({
  model: anthropic('claude-sonnet-4-5-20250929'),
  backend: new FilesystemBackend({ rootDir: './workspace' }),
});

// Example 2: Hybrid storage (ephemeral + persistent)
const backend = new CompositeBackend(
  new StateBackend(), // Default: ephemeral
  {
    '/memories/': new PersistentBackend({ store: myStore }),
  }
);

const agent = createDeepAgent({
  model: anthropic('claude-sonnet-4-5-20250929'),
  backend,
});

const agent = createDeepAgent({
  model: anthropic('claude-sonnet-4-5-20250929'),
  // No subagents needed - general-purpose is always available
});

// Agent can delegate complex tasks automatically
const result = await agent.generate({
  prompt: 'Analyze this codebase and find all API endpoints',
  // Agent may use task tool to delegate to general-purpose subagent
});

const result = await agent.generate({
  prompt: 'Build a REST API with authentication',
});

// Access the todo list
result.state.todos.forEach(todo => {
  console.log(`[${todo.status}] ${todo.content}`);
});

// Output:
// [completed] Design API endpoints
// [completed] Set up project structure
// [in_progress] Implement authentication middleware
// [pending] Add input validation
// [pending] Write tests

const agent = createDeepAgent({
  model: anthropic('claude-sonnet-4-5-20250929'),
  interruptOn: {
    write_file: true,  // Pause before every write
    edit_file: true,
    execute: true,
  },
});

for await (const event of agent.streamWithEvents({
  prompt: 'Delete all test files',
  onApprovalRequest: async ({ toolName, args }) => {
    console.log(`\n⚠️  Tool "${toolName}" requires approval`);
    console.log('Arguments:', JSON.stringify(args, null, 2));

    // Prompt user for approval
    const answer = await promptUser('Approve? (y/n): ');
    return answer.toLowerCase() === 'y';
  },
})) {
  // Handle events...
}

const agent = createDeepAgent({
  model: anthropic('claude-sonnet-4-5-20250929'),
  summarization: {
    tokenThreshold: 170000,  // Trigger at 170k tokens
    keepMessages: 6,          // Keep 6 most recent messages
    model: anthropic('claude-haiku-4-5-20251001'), // Model for summarization
  },
});

const agent = createDeepAgent({
  model: anthropic('claude-sonnet-4-5-20250929'),
  enablePromptCaching: true, // Default: true for Anthropic models
});

for await (const event of agent.streamWithEvents({
  prompt: 'Build a web app',
})) {
  switch (event.type) {
    case 'text':
      // Streaming text chunks
      process.stdout.write(event.text);
      break;

    case 'step-start':
      // New reasoning step
      console.log(`\n--- Step ${event.step} ---`);
      break;

    case 'tool-call':
      // Tool being executed
      console.log(`Tool: ${event.toolName}`);
      break;

    case 'todos-changed':
      // Todo list updated
      console.log(`Todos: ${event.todos.length} total`);
      break;

    case 'file-written':
      // File created
      console.log(`Created: ${event.path}`);
      break;

    case 'subagent-start':
      // Subagent spawned
      console.log(`Subagent: ${event.subagentType}`);
      break;

    case 'done':
      // Task complete
      console.log('\n✅ Done!');
      break;
  }
}

# Set environment variable
export TAVILY_API_KEY=tvly-your-key-here

// Web tools are automatically available
const agent = createDeepAgent({
  model: anthropic('claude-sonnet-4-5-20250929'),
});

// Agent can now search the web
const result = await agent.generate({
  prompt: 'Search for recent AI news and summarize',
});

import { LocalSandbox } from 'ai-sdk-deep-agent';

const agent = createDeepAgent({
  model: anthropic('claude-sonnet-4-5-20250929'),
  backend: new LocalSandbox({
    cwd: './workspace',
    timeout: 60000, // 60 second timeout
  }),
});

// execute tool is automatically added
const result = await agent.generate({
  prompt: 'Initialize a Node.js project and install dependencies',
});

// ✅ Good: Match backend to use case
const agent = createDeepAgent({
  backend: new FilesystemBackend({ rootDir: './project' }),
  // Use for: Working with existing codebases

  backend: new StateBackend(),
  // Use for: Temporary scratch space

  backend: new CompositeBackend(stateBackend, {
    '/memories/': persistentBackend,
  }),
  // Use for: Hybrid ephemeral + persistent storage
});

// ✅ Good: Prevent context bloat
const agent = createDeepAgent({
  toolResultEvictionLimit: 20000,
});

// ✅ Good: Require approval for dangerous tools
const agent = createDeepAgent({
  interruptOn: {
    write_file: true,
    edit_file: true,
    execute: true,
  },
});

// ✅ Good: Define specialized subagents
const agent = createDeepAgent({
  subagents: [
    {
      name: 'researcher',
      description: 'Conducts in-depth research',
      systemPrompt: 'You are a research specialist...',
      tools: [webSearchTool],
    },
    {
      name: 'coder',
      description: 'Writes and reviews code',
      systemPrompt: 'You are a software engineer...',
      tools: [executeTool, fileTools],
    },
  ],
});

// ✅ Good: Stream events for debugging
for await (const event of agent.streamWithEvents({
  prompt: complexTask,
  onEvent: (event) => {
    // Log all events for debugging
    console.log('[EVENT]', event.type, event);
  },
})) {
  // Handle UI updates...
}