Menu
Intelligent model selection for autonomous operations — balance capability, cost, and task requirements
Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Baseado na classificação ocupacional SOC
Discord slash commands, approval routing, channel policy, button interaction patterns for OpenClaw/ARI Discord integration
Obsidian vault integration patterns — vault-analyzer.ts, /ari-vault-* commands, morning briefing snippet, PARA structure, read-only enforcement
OpenClaw plugin development patterns — hooks, manifest structure, plugin SDK, APEX/CODEX enforcement
NOVA's P1 PayThePryce pipeline — market signal ingest, card detection, price monitoring, script generation, thumbnail generation, video assembly, approval gate
CHASE's P2 Pryceless Solutions pipeline — lead discovery, 5-criteria audit, LLM qualification, Prompt Forge 4-pass lock, demo generation, outreach approval gate
NOVA's thumbnail generation pipeline — Ideogram V3 via Fal.ai (primary) + DALL-E 3 fallback, 4-variant strategy, Pokemon TCG copyright rules,
| name | ari-model-selection |
| description | Intelligent model selection for autonomous operations — balance capability, cost, and task requirements |
| triggers | ["model selection","which model","use sonnet","use opus","token cost","cost optimization","/ari-model"] |
ARI autonomously selects the optimal model for each task based on:
| Model | Strengths | Token Cost | Use When |
|---|---|---|---|
| Claude Opus 4.5 | Deep reasoning, complex analysis, nuanced judgment | Highest | Complex decisions, architecture, security |
| Claude Sonnet 4 | Balanced capability, good at coding | Medium | Most development tasks, code generation |
| Claude Haiku 4 | Fast, efficient, pattern matching | Lowest | Simple queries, formatting, quick checks |
┌────────────────────────────────────────────────────────────────┐
│ MODEL SELECTION DECISION TREE │
├────────────────────────────────────────────────────────────────┤
│ │
│ Is this task... │
│ │ │
│ ├─► COMPLEX REASONING │
│ │ • Architecture decisions │
│ │ • Security analysis │
│ │ • Novel problem solving │
│ │ • Multi-step planning │
│ │ • Ambiguous requirements │
│ │ • Cross-domain synthesis │
│ │ └─► Use: OPUS │
│ │ │
│ ├─► STANDARD DEVELOPMENT │
│ │ • Code generation │
│ │ • Bug fixing │
│ │ • Test writing │
│ │ • Documentation │
│ │ • Code review │
│ │ • Refactoring │
│ │ └─► Use: SONNET (default) │
│ │ │
│ └─► SIMPLE/ROUTINE │
│ • File operations │
│ • Formatting │
│ • Simple lookups │
│ • Status checks │
│ • Quick answers │
│ └─► Use: HAIKU │
│ │
└────────────────────────────────────────────────────────────────┘
// The Task tool accepts a model parameter
// Use this to specify the appropriate model
// Complex architecture task → Opus
{
description: "Design authentication system",
prompt: "...",
subagent_type: "feature-dev:code-architect",
model: "opus" // High complexity requires Opus
}
// Standard coding task → Sonnet (default)
{
description: "Implement login endpoint",
prompt: "...",
subagent_type: "Bash",
model: "sonnet" // Standard development
}
// Quick exploration → Haiku
{
description: "Find all config files",
prompt: "...",
subagent_type: "Explore",
model: "haiku" // Simple search
}
┌─────────────────────────────────────────────────────────────────┐
│ TASK TYPE → MODEL MAPPING │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ALWAYS OPUS │
│ ─────────────────────────────────────────────────────────────── │
│ • Security audits and vulnerability analysis │
│ • Architectural decisions with long-term impact │
│ • Novel problem solving (no clear pattern to follow) │
│ • Constitutional/governance decisions │
│ • Complex multi-system integration design │
│ • Ambiguous requirements that need interpretation │
│ • High-stakes decisions (irreversible actions) │
│ • Cross-domain reasoning (e.g., code + security + UX) │
│ │
│ PREFER SONNET (default for most tasks) │
│ ─────────────────────────────────────────────────────────────── │
│ • Code generation from clear specifications │
│ • Test writing │
│ • Bug fixing (standard bugs) │
│ • Documentation │
│ • Code review (standard review) │
│ • Refactoring with clear patterns │
│ • Feature implementation with defined scope │
│ • API development │
│ │
│ USE HAIKU (cost optimization) │
│ ─────────────────────────────────────────────────────────────── │
│ • File exploration and search │
│ • Simple grep/glob operations │
│ • Formatting tasks │
│ • Status checks │
│ • Simple data transformations │
│ • Quick lookups in documentation │
│ • Syntax validation │
│ │
└─────────────────────────────────────────────────────────────────┘
Opus : ████████████████████ 100% (Baseline)
Sonnet : ████████ 40% (2.5x cheaper)
Haiku : ██ 10% (10x cheaper)
function calculateModelValue(task: Task): ModelRecommendation {
// Estimate task complexity
const complexity = assessComplexity(task);
// Estimate quality impact
const qualityImpact = estimateQualityDelta(task, 'opus', 'sonnet');
// Calculate cost difference
const costDelta = estimateTokenCost(task, 'opus') - estimateTokenCost(task, 'sonnet');
// Decision: Is the quality gain worth the cost?
if (qualityImpact > costDelta * costSensitivity) {
return { model: 'opus', reason: 'Quality gain justifies cost' };
} else if (complexity === 'low') {
return { model: 'haiku', reason: 'Simple task, maximize savings' };
} else {
return { model: 'sonnet', reason: 'Balanced capability/cost' };
}
}
┌─────────────────────────────────────────────────────────────────┐
│ 🔴 OPUS INDICATORS │
├─────────────────────────────────────────────────────────────────┤
│ │
│ LANGUAGE SIGNALS: │
│ • "Design the architecture for..." │
│ • "What's the best approach to..." │
│ • "Consider all the tradeoffs..." │
│ • "This is security-critical..." │
│ • "We need to think through..." │
│ • "The requirements are unclear..." │
│ │
│ TASK CHARACTERISTICS: │
│ • Multiple valid solutions exist │
│ • Requires weighing tradeoffs │
│ • Has long-term consequences │
│ • Involves multiple systems/domains │
│ • No clear pattern to follow │
│ • Stakeholder judgment required │
│ │
│ DOMAIN SIGNALS: │
│ • Security, authentication, authorization │
│ • Data migration with integrity requirements │
│ • Performance optimization (non-trivial) │
│ • Distributed systems coordination │
│ • Constitutional/governance decisions │
│ │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 🟡 SONNET INDICATORS (Default) │
├─────────────────────────────────────────────────────────────────┤
│ │
│ LANGUAGE SIGNALS: │
│ • "Implement this feature..." │
│ • "Write a function that..." │
│ • "Fix this bug..." │
│ • "Add tests for..." │
│ • "Create a component that..." │
│ │
│ TASK CHARACTERISTICS: │
│ • Clear specification provided │
│ • Similar patterns exist in codebase │
│ • Standard coding task │
│ • Known solution approach │
│ • Contained scope (single file/module) │
│ │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 🟢 HAIKU INDICATORS (Cost-Optimized) │
├─────────────────────────────────────────────────────────────────┤
│ │
│ LANGUAGE SIGNALS: │
│ • "Find all files that..." │
│ • "List the..." │
│ • "Check if..." │
│ • "Format this..." │
│ • "Search for..." │
│ │
│ TASK CHARACTERISTICS: │
│ • Single operation │
│ • Pattern matching / lookup │
│ • No judgment required │
│ • Deterministic output expected │
│ • Speed is more important than depth │
│ │
└─────────────────────────────────────────────────────────────────┘
When ARI operates autonomously (via scheduler, daemon, or spawned agents), it should:
async function executeAutonomousTask(task: ScheduledTask) {
// Step 1: Analyze task complexity
const analysis = analyzeTaskComplexity(task);
// Step 2: Select appropriate model
const model = selectModel(analysis);
// Step 3: Log decision for transparency
this.eventBus.emit('audit:log', {
action: 'model_selected',
details: {
task: task.name,
model,
reason: analysis.reason,
estimatedTokens: analysis.estimatedTokens,
estimatedCost: analysis.estimatedCost,
}
});
// Step 4: Execute with selected model
return await executeWithModel(task, model);
}
interface CostTracking {
daily: {
opus: number;
sonnet: number;
haiku: number;
};
weekly: {
totalCost: number;
savingsFromDowngrade: number;
qualityImpactFromDowngrade: number;
};
}
// After task completion, evaluate if model choice was appropriate
function evaluateModelChoice(task: Task, result: Result, modelUsed: Model) {
const qualityMet = result.quality >= task.qualityThreshold;
const withinBudget = result.cost <= task.costBudget;
// Record for future optimization
recordModelOutcome({
taskType: task.type,
model: modelUsed,
success: qualityMet && withinBudget,
actualCost: result.cost,
qualityScore: result.quality,
});
}
// Task: Review authentication system for vulnerabilities
// Analysis: Security-critical, requires nuanced judgment
// Decision: OPUS
{
description: "Security audit of auth system",
prompt: "Review the authentication implementation in src/kernel/... for security vulnerabilities",
subagent_type: "ari-security-auditor",
model: "opus" // Security = always Opus
}
// Task: Implement a new API endpoint
// Analysis: Standard coding, clear specification
// Decision: SONNET
{
description: "Implement /api/users endpoint",
prompt: "Create a CRUD endpoint for users following existing patterns in src/api/routes.ts",
subagent_type: "general-purpose",
model: "sonnet" // Standard development
}
// Task: Find all TypeScript files with certain pattern
// Analysis: Simple search, no reasoning required
// Decision: HAIKU
{
description: "Find config files",
prompt: "Find all files matching *.config.ts",
subagent_type: "Explore",
model: "haiku" // Fast, simple, cheap
}
// In agent spawning logic
async function spawnAgent(config: AgentConfig): Promise<Agent> {
// Determine optimal model
const model = determineOptimalModel({
taskType: config.subagent_type,
taskDescription: config.description,
taskPrompt: config.prompt,
previousAttempts: config.retryCount || 0,
});
// Spawn with selected model
return await Task({
...config,
model,
});
}
function determineOptimalModel(context: ModelSelectionContext): 'opus' | 'sonnet' | 'haiku' {
// Security/governance → Opus
if (isSecuritySensitive(context)) return 'opus';
// Previous failure → upgrade
if (context.previousAttempts > 0) return upgradeModel(context.currentModel);
// Simple exploration → Haiku
if (context.taskType === 'Explore' && isSimpleSearch(context.taskPrompt)) {
return 'haiku';
}
// Default → Sonnet
return 'sonnet';
}
┌─────────────────────────────────────────────────────────────────┐
│ MODEL USAGE (Last 7 Days) │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Opus ██████░░░░░░░░░░░░░░ 30% │ $12.50 │ High-value tasks │
│ Sonnet ████████████░░░░░░░░ 55% │ $8.25 │ Standard work │
│ Haiku ███░░░░░░░░░░░░░░░░░ 15% │ $0.50 │ Quick operations │
│ │
│ Total: $21.25 (vs. $45.00 if all Opus = 53% savings) │
│ │
│ Quality Impact: None detected (all quality gates passed) │
│ │
└─────────────────────────────────────────────────────────────────┘
┌────────────────────────────────────────────────────────────────┐
│ │
│ 1. DEFAULT TO SONNET │
│ Most tasks don't need Opus. Start at Sonnet. │
│ │
│ 2. UPGRADE FOR COMPLEXITY │
│ When judgment, tradeoffs, or security matter → Opus. │
│ │
│ 3. DOWNGRADE FOR SPEED │
│ Simple searches, lookups, formatting → Haiku. │
│ │
│ 4. TRACK AND LEARN │
│ Monitor outcomes. Adjust thresholds based on results. │
│ │
│ 5. WHEN IN DOUBT, UPGRADE │
│ Quality failures are more expensive than token costs. │
│ │
└────────────────────────────────────────────────────────────────┘