Agents

import { Agent } from '@cogitator-ai/core';

const agent = new Agent({
  name: 'researcher',
  model: 'anthropic/claude-sonnet-5-5',
  instructions: 'You are a research assistant. Find accurate information and cite sources.',
});

interface AgentConfig {
  id?: string;
  name: string;
  description?: string;
  model?: string; // default: llm.defaultModel of the Cogitator
  provider?: string;
  instructions: string;
  tools?: Tool[];
  skills?: Skill[]; // bundles of tools + instructions, merged in
  temperature?: number; // default: 0.7
  topP?: number;
  maxTokens?: number;
  stopSequences?: string[];
  responseFormat?: ResponseFormat;
  reasoning?: ReasoningConfig; // effort and summaries for reasoning models
  handoffs?: Array<Agent | Handoff>; // agents it can hand the conversation over to
  maxIterations?: number; // default: 10
  onIterationLimit?: 'answer' | 'stop'; // default: 'answer'
  timeout?: number; // default: limits.defaultTimeout of the Cogitator, else 120000 (2 min)
}

model: 'openai/gpt-6.1-sol';
model: 'anthropic/claude-sonnet-5-5';
model: 'ollama/llama3.3:latest';
model: 'google/gemini-3.8-flash';

const agent = new Agent({
  name: 'openrouter-agent',
  model: 'meta-llama/llama-3.3-70b-instruct',
  provider: 'openai',
  instructions: '...',
});

import { Agent, tool } from '@cogitator-ai/core';
import { z } from 'zod';

const searchWeb = tool({
  name: 'search_web',
  description: 'Search the internet for current information',
  parameters: z.object({
    query: z.string().describe('The search query'),
    limit: z.number().default(5),
  }),
  execute: async ({ query, limit }) => {
    const results = await searchAPI.search(query, limit);
    return results.map((r) => ({ title: r.title, url: r.url }));
  },
});

const researcher = new Agent({
  name: 'researcher',
  model: 'openai/gpt-6.1-sol',
  instructions: 'You are a research assistant. Use tools to find accurate information.',
  tools: [searchWeb],
  maxIterations: 15,
});

const analyzer = new Agent({
  name: 'analyzer',
  model: 'openai/gpt-6.1-sol',
  instructions: 'Analyze the given text and extract structured information.',
  responseFormat: {
    type: 'json_schema',
    schema: z.object({
      summary: z.string(),
      sentiment: z.enum(['positive', 'negative', 'neutral']),
      keyPoints: z.array(z.string()),
    }),
  },
});

const baseAgent = new Agent({
  name: 'coder',
  model: 'anthropic/claude-sonnet-5-5',
  instructions: 'You are a senior software engineer.',
  temperature: 0.3,
});

const creativeAgent = baseAgent.clone({
  name: 'creative-coder',
  temperature: 0.9,
});

const fastAgent = baseAgent.clone({
  model: 'anthropic/claude-haiku-4-5',
});

import { writeFile } from 'node:fs/promises';

const snapshot = agent.serialize();
await writeFile('agent.json', JSON.stringify(snapshot, null, 2));

import { readFile } from 'node:fs/promises';
import { Agent } from '@cogitator-ai/core';
import type { AgentSnapshot } from '@cogitator-ai/types';

const saved = JSON.parse(await readFile('agent.json', 'utf-8')) as AgentSnapshot;
const restored = Agent.deserialize(saved, {
  tools: [searchWeb, readUrl],
});

import { defineSkill } from '@cogitator-ai/core';

const weatherSkill = defineSkill({
  name: 'weather',
  version: '1.0.0',
  description: 'Current weather and forecasts',
  tools: [getWeather],
  instructions: 'Use get_weather for any question about the weather.',
  env: ['WEATHER_API_KEY'],
});

const assistant = new Agent({
  name: 'assistant',
  model: 'openai/gpt-6.1-sol',
  instructions: 'You are a helpful assistant.',
  skills: [weatherSkill],
});

import { agentAsTool } from '@cogitator-ai/core';

const researchTool = agentAsTool(cogitator, researcher, {
  name: 'research',
  description: 'Delegate a research task to the research agent',
});

const orchestrator = new Agent({
  name: 'orchestrator',
  model: 'openai/gpt-6.1-sol',
  instructions: 'You coordinate tasks. Use the research tool for information gathering.',
  tools: [researchTool],
});

const analyst = new Agent({
  name: 'analyst',
  model: 'anthropic/claude-opus-5-5',
  instructions: 'Answer questions about the quarterly numbers.',
  reasoning: { effort: 'high', summary: true },
});

const result = await cog.run(analyst, {
  input: 'Why did margins drop in Q3?',
  stream: true,
  onReasoning: (delta) => process.stdout.write(delta), // the summary, while it streams
});

result.reasoning; // the whole summary
result.usage.reasoningTokens; // thinking tokens, billed as output

const billing = new Agent({
  name: 'billing',
  description: 'Invoices, payments and refunds',
  model,
  instructions,
  tools: [lookupInvoice],
});
const support = new Agent({
  name: 'tech_support',
  description: 'Login problems and outages',
  model,
  instructions,
  tools: [serviceStatus],
});

const triage = new Agent({
  name: 'triage',
  model,
  instructions: 'Greet the customer and hand the conversation to the right specialist.',
  handoffs: [billing, support], // or { agent: billing, toolName: 'ask_billing', description: '...' }
});

const result = await cog.run(triage, {
  input: 'How much do I owe on INV-204?',
  onHandoff: console.log,
});
result.handoffs; // [{ from: 'triage', to: 'billing', reason: '...' }]
result.finalAgent; // 'billing' — send the next message of this thread to it