When you've dragged the Run Agent action onto your Nintex canvas for the first time, it can feel a little overwhelming. You open the model dropdown and suddenly you're looking at a list of names. Haiku, Sonnet, Opus, GPT-4o, GPT-4o-mini, o1, o3. And you're sitting there wondering what any of this means and which one you're actually supposed to pick.

Here's the thing. The model you choose matters more than most people think. Go with one that's too powerful for the task and you're burning through tokens and budget for no reason. Go with one that's too lightweight and you'll get bad results, failed classifications, and frustrated users who walk away thinking AI "doesn't work."

The good news is this is a pretty easy fix. Once you understand the framework behind it, model selection starts to feel intuitive. Nintex gives you a broad range of models from both Anthropic (Claude) and OpenAI. That flexibility is genuinely powerful, and if you use it wisely, you'll get exceptional results out of it. This guide is how you use it wisely.

The Model Selection Framework

Before diving into specific models, here's the selection framework I use:

Ask three questions:

Complexity — How much reasoning does this task require?
Volume — How many times will this run per day/week/month?
Stakes — What's the cost of getting it wrong?

Scenario	Recommended Tier
Simple extraction, high volume, low stakes	Speed/Cost tier
Moderate reasoning, medium volume, medium stakes	Balanced tier
Complex analysis, lower volume, high stakes	Power tier
Multi-step logic, mathematical reasoning	Reasoning tier

Anthropic Models (Claude)

Anthropic's Claude family is known for strong instruction-following, nuanced understanding, and safety. They excel at tasks requiring careful reading, structured output, and handling ambiguity.

Speed/Cost Tier: Haiku

Model	Best For	Strengths	Limitations
claude-3-haiku	High-volume classification, simple extraction, routing	Fast, cheap, reliable for straightforward tasks	Struggles with nuance, complex reasoning
claude-haiku-4-5	Same as above, improved accuracy	Better instruction following than 3-haiku	Still not ideal for complex analysis

Ideal for:

Use Case	Description
Reading and parsing emails	Extract sender, subject, key dates, amounts, and intent
Reading account/customer data	Pull relevant fields from CRM records, summarize account status
Generating simple emails	Acknowledgment emails, status updates, templated responses with variable insertion
Classifying incoming tickets	P1/P2/P3/P4 severity, department routing, request type
Simple sentiment detection	Positive/negative/neutral on feedback or survey responses
Data validation	Check if fields meet expected formats, flag anomalies
Keyword-based routing	Direct requests to appropriate queues based on content

The bottom line on Haiku: Haiku is your high-volume workhorse for tasks that don't need deep thinking. It works best when the input is relatively clean, the decision logic is straightforward, and you care about speed and keeping costs down. Think of it as your first line of defense. It handles the bulk of routine work so your more powerful models, and your humans, can focus on the stuff that actually requires judgment. If your workflow is processing thousands of items and most of them follow predictable patterns, Haiku should be where you start.

Token economics: Haiku models cost roughly 10-20x less than Opus. For a workflow processing 10,000 items/month, this difference is significant.

When to upgrade: If you're seeing >10% error rate on classifications, or the task requires understanding context across multiple paragraphs.

Balanced Tier: Sonnet

Model	Best For	Strengths	Limitations
claude-3-sonnet	General-purpose workflow tasks	Good balance of speed and capability	Older, superseded by newer versions
claude-3-5-sonnet-latest	Most production workloads	Excellent reasoning, fast, cost-effective	May overthink simple tasks
claude-3-7-sonnet-latest	Complex document understanding	Improved over 3.5, strong at structured output	Higher latency than 3.5
claude-sonnet-4-0	Current production standard	State-of-the-art balanced performance	Costs more than 3.5
claude-sonnet-4-5	Cutting edge balanced	Best-in-class for the tier	Newest, less battle-tested

Ideal for:

Use Case	Description
Incident analysis and triage	Read incident details, assess severity, recommend response actions, identify affected systems
Document summarization	Condense lengthy reports, contracts, or correspondence into structured summaries
Drafting customer communications	Compose professional responses that require tone awareness and context understanding
Data enrichment with judgment	Augment records with inferred information (e.g., categorizing free-text fields)
Root cause hypothesis	Analyze symptoms and suggest potential causes for investigation
Human-in-the-loop preparation	Prepare recommendations for human reviewers with supporting rationale
Meeting notes and action items	Parse transcripts, extract decisions, assign follow-ups
Policy/procedure lookup	Find and apply relevant policies to specific situations
Multi-field extraction from complex documents	Invoices, contracts, applications with varying formats
Quality assurance checks	Review content against guidelines, flag issues with explanations

The bottom line on Sonnet: Sonnet is where most of your production workflows should probably live. It hits the sweet spot between capability and cost. It's powerful enough to handle tasks that require genuine understanding and judgment, but efficient enough that you can still run it at scale. When you need the AI to actually think and not just pattern-match, Sonnet delivers. It's particularly good at following complex instructions, keeping output formats consistent, and handling ambiguity without falling over. If you're not sure which model to use, start here. You can always scale down to Haiku if it turns out to be overkill, or move up to Opus if you need more firepower.

Token economics: Sonnet is the workhorse. It's where most production workflows should live. Costs roughly 5-10x less than Opus while handling 80%+ of tasks effectively.

My recommendation: Start with claude-3-5-sonnet-latest or claude-sonnet-4-0 for most workflows. They hit the sweet spot of capability, speed, and cost.

Power Tier: Opus

Model	Best For	Strengths	Limitations
claude-3-opus	Complex analysis, report generation	Deep reasoning, excellent writing	Slower, expensive
claude-opus-4-0	High-stakes decisions, nuanced judgment	Best Claude reasoning available	Significant cost, latency
claude-opus-4-1	Improved 4-series	Better than 4-0 on benchmarks	Same cost concerns
claude-opus-4-5	Frontier capability	Cutting-edge performance	Premium pricing

Ideal for:

Use Case	Description
Post-incident review generation	Create comprehensive post-mortems from timelines, logs, and conversation threads
Complex risk assessment	Evaluate multiple factors, weigh trade-offs, provide nuanced recommendations
Legal/compliance document analysis	Parse regulatory documents, identify obligations, flag risks
Executive-ready reports	Generate polished summaries and recommendations for leadership
Strategic recommendations	Synthesize unstructured data into actionable business insights
Contract review and comparison	Identify key terms, flag deviations from standards, summarize obligations
Sensitive customer escalations	Draft responses for high-stakes situations requiring empathy and precision
Audit preparation	Compile evidence, create narratives, ensure completeness
Policy interpretation	Apply complex rules to ambiguous situations with reasoned explanations
Research synthesis	Combine multiple sources into coherent analysis with citations

The bottom line on Opus: Opus is your heavy artillery. You're not going to deploy it for every task, but when you need it, nothing else comes close. This is the model you reach for in high-stakes situations where quality matters more than cost. Documents that go to regulators. Communications to your most important customers. Analysis that's going to inform major decisions. Opus is excellent at nuance, at holding complex context together, and at producing output that reads like it came from a senior professional. The trade-off is cost and latency, so you want to use it deliberately. Save Opus for the 10-15% of work where getting it right the first time is worth paying the premium.

Token economics: Opus is expensive. Use it when the value of accuracy justifies the cost, or when the task is low-volume but high-stakes.

When to use: When you're generating content that goes directly to executives, customers, or regulators. When errors have real consequences.

OpenAI Models

OpenAI's models are known for strong general capabilities, excellent code generation, and the unique "o-series" reasoning models. They offer more variety in the speed/cost tier.

Speed/Cost Tier: Mini/Nano

Model	Best For	Strengths	Limitations
gpt-4o-mini	High-volume simple tasks	Very fast, very cheap, surprisingly capable	Limited context understanding
gpt-4.1-mini	Same, newer version	Improved over 4o-mini	Still lightweight
gpt-4.1-nano	Extreme cost optimization	Cheapest option	Most limited capability
gpt-5-mini	Next-gen lightweight	Better than 4.1-mini	Newer, less proven
gpt-5-nano	Extreme cost optimization	Latest cheap option	Very lightweight

Ideal for:

Use Case	Description
Reading and parsing emails	Extract sender, dates, amounts, intent from incoming messages
Simple data extraction	Pull specific fields from structured or semi-structured text
JSON formatting and validation	Transform data into required formats, validate structure
Templated content generation	Fill in variables, generate standardized responses
Binary classification	Yes/no, approve/reject, relevant/not relevant decisions
Language detection	Identify language for routing to appropriate teams
PII detection	Flag potential sensitive data for review
Preprocessing for heavier models	Clean, format, or filter before escalating to Sonnet/Opus
Simple Q&A lookup	Answer factual questions from provided context
Tagging and labeling	Apply predefined categories to incoming content

The bottom line on Mini/Nano models: These models punch well above their weight. For straightforward, high-volume tasks where the logic is clear and the output is structured, they deliver remarkable value. The key is knowing where their limits are. They struggle with nuance, multi-step reasoning, and tasks that need deep context understanding. But for the 60-70% of workflow tasks that are essentially "read this, extract that, classify it, move on," Mini and Nano models will save you a significant chunk of budget while still maintaining accuracy. Start here, measure your error rates, and only upgrade when the task genuinely calls for it.

Token economics: These are your budget workhorses. GPT-4o-mini in particular offers remarkable capability for the price.

My recommendation: gpt-4o-mini is excellent value. Test it against Haiku for your specific use case and use whichever performs better.

Balanced Tier: GPT-4o / GPT-4-turbo / GPT-4.1 / GPT-5

Model	Best For	Strengths	Limitations
gpt-3.5-turbo	Legacy workflows, basic tasks	Cheap, fast, well-understood	Outdated, limited capability
gpt-4	Proven production workloads	Reliable, well-documented	Slower, superseded
gpt-4-turbo	Faster GPT-4	Better speed than base GPT-4	Still older generation
gpt-4o	Current standard	Multimodal, fast, capable	Costs more than turbo
gpt-4.1	Latest 4-series	Improved over 4o	Newer
gpt-5	Next generation	Significant capability jump	Premium pricing
gpt-5.1 / gpt-5.2	Frontier	Cutting-edge	Highest cost tier

Ideal for:

Use Case	Description
Code generation and review	Write scripts, review pull requests, suggest optimizations
Technical documentation	Generate API docs, user guides, troubleshooting articles
Data transformation logic	Write formulas, queries, or transformation rules
Image analysis (GPT-4o+)	Process screenshots, diagrams, receipts, ID documents
Complex data extraction	Handle varied document formats, messy inputs
Workflow logic generation	Suggest automation logic based on requirements
Technical support responses	Draft detailed troubleshooting guidance
Integration mapping	Analyze systems and suggest field mappings
Report generation	Create structured reports from raw data

The bottom line on GPT-4o/4.1/5: This is OpenAI's versatile middle tier, and it's particularly strong in technical domains. If your workflows involve code, structured data, or multimodal inputs like images, this is often going to be a better fit than Claude's Sonnet. GPT-4o is fast and capable, which makes it a solid choice for production workloads. The newer GPT-4.1 and GPT-5 models push things further, with GPT-5 representing a pretty significant jump in capability. Go with GPT-4o when you want proven reliability, GPT-4.1 when you need improved performance, and GPT-5 when you need cutting-edge capabilities and can justify the cost.

My recommendation: gpt-4o or gpt-4.1 for most OpenAI workloads. If you need bleeding edge, gpt-5 represents a significant jump.

Reasoning Tier: o-series

This is unique to OpenAI. The o-series models are specifically designed for complex, multi-step reasoning tasks.

Model	Best For	Strengths	Limitations
o1-mini	Lightweight reasoning	Good at logic, math, code	Slower than standard models
o1-preview	Complex reasoning	Excellent multi-step logic	Significantly slower, expensive
o3-mini	Next-gen reasoning (light)	Improved over o1-mini	Still has latency
o4-mini	Latest reasoning (light)	Best lightweight reasoner	Newest

Ideal for:

Use Case	Description
Multi-condition approval logic	Evaluate complex business rules with multiple dependencies
Financial calculations with verification	Compute totals, validate against thresholds, check consistency
Compliance rule application	Apply regulatory requirements to specific scenarios with reasoning
Audit trail verification	Step through processes, verify each stage, identify gaps
Resource allocation optimization	Balance competing constraints, recommend optimal assignments
SLA breach prediction	Calculate timelines, factor in dependencies, flag risks
Contract term evaluation	Assess whether conditions are met based on multiple criteria
Troubleshooting decision trees	Navigate complex diagnostic logic systematically
Budget reconciliation	Match transactions, identify discrepancies, explain variances
Scheduling with constraints	Factor in availability, dependencies, priorities

The bottom line on o-series: The o-series models are fundamentally different from standard models. They're designed to think, not just respond. When you give an o-series model a complex problem, it doesn't just pattern-match its way to an answer. It works through the logic step by step, much like a human expert would. That makes them dramatically better at tasks involving math, multi-step reasoning, and complex rule application. The trade-off is speed and cost. These models are slower and more expensive. But for the right use cases, things like financial calculations, compliance checks, or any workflow where you need the AI to show its working, they're worth every token. If your standard models keep tripping over logical errors on a particular task, o-series is probably your answer.

Token economics: o-series models are slower and more expensive than their standard counterparts, but they produce dramatically better results on reasoning tasks. The ROI is clear when the task actually requires reasoning.

When to use: When standard models are making logical errors. When you need the model to think through a problem, not just pattern-match to an answer.

Temperature: When to turn up the dial

You'll notice a Temperature setting in your agent configuration. This controls how "creative" or "deterministic" the model's responses are. It's a small slider that can have a big impact on your results.

The basics:

Low temperature (0.0 - 0.3) — Model picks the most likely response. Consistent, predictable, repeatable.
Medium temperature (0.4 - 0.7) — Balanced. Some variety while staying grounded.
High temperature (0.8 - 1.0+) — Model explores less likely options. More creative, more varied, less predictable.

When to keep temperature low (0.1 - 0.3):

Use Case	Why Low Temperature
Classification tasks	You want the same input to produce the same output every time
Data extraction	Consistency matters more than creativity
JSON/structured output	Higher temperatures can break formatting
Compliance/audit workflows	Predictability is essential
Routing decisions	Deterministic behavior prevents confusion

When to consider raising temperature (0.5 - 0.8):

Use Case	Why Higher Temperature
Drafting customer communications	Avoids robotic, repetitive phrasing across multiple outputs
Creative content generation	Brainstorming, marketing copy, varied suggestions
Generating multiple options	When you want the model to propose different approaches
Conversational agents	More natural, human-like variation in responses

Model-specific considerations:

Haiku/Mini models — Keep temperature low (0.1-0.2). These models are already less nuanced, and higher temperatures can produce erratic results.
Sonnet/GPT-4o — Default to low (0.1-0.3) for structured tasks. Raise to 0.5-0.7 for drafting and communication tasks where you want natural variation.
Opus/GPT-5 — These models handle higher temperatures more gracefully. For creative or strategic work, 0.6-0.8 can produce excellent results.
o-series reasoning models — Keep temperature low. You want consistent, logical reasoning, not creative interpretation of math.

My default recommendation: Start at 0.1 for most agentic workflow tasks. It's the safe choice. Only raise the temperature when you're seeing outputs that feel too robotic/non-authentic, too repetitive, or when the use case genuinely benefits from variety. And when you do raise it, move in small increments. i.e 0.1 -> 0.3

Head-to-Head: Claude vs OpenAI

Dimension	Claude	OpenAI
Instruction following	Excellent — tends to follow complex instructions precisely	Good — occasionally deviates on edge cases
Writing quality	More natural, nuanced tone	Clear, sometimes formulaic
Code generation	Good	Excellent
Structured output (JSON)	Very reliable	Reliable
Reasoning (non o-series)	Strong	Good
Reasoning (o-series)	N/A	Best-in-class for complex logic
Multimodal (images)	Available on some models	Strong on GPT-4o+
Speed	Sonnet is very fast	4o-mini is very fast
Cost	Competitive	Competitive

My general guidance:

For document-heavy work and tasks that require careful instruction-following, Claude Sonnet is the default choice. When the work involves code or multimodal inputs, GPT-4o or 4o-mini tends to be the better fit. The o-series models are best saved for problems that specifically need multi-step reasoning. And for high-volume, simpler tasks where speed and cost matter most, Haiku or 4o-mini are your go-to options.

Use Case Quick Reference

Workflow Task	Recommended Model(s)	Why
Classify incoming tickets	claude-3-haiku, gpt-4o-mini	High volume, simple decision
Extract fields from documents	claude-3-haiku, gpt-4o-mini	Structured extraction
Triage and severity assessment	claude-3-5-sonnet, gpt-4o	Requires judgment
Draft customer communications	claude-3-5-sonnet, claude-sonnet-4-0	Writing quality matters
Analyze incident for root cause	claude-sonnet-4-0, gpt-4.1	Moderate reasoning required
Generate post-mortem reports	claude-opus-4-0, gpt-5	High stakes, quality critical
Complex approval logic (multi-condition)	o1-mini, o3-mini	Multi-step reasoning
Financial calculations with validation	o1-preview, o3-mini	Math + verification
Summarize legal documents	claude-opus-4-0	Nuance, accuracy critical
Route requests based on content	claude-3-haiku, gpt-4o-mini	Fast, simple
Human-in-the-loop prep (low confidence)	claude-3-5-sonnet	Balanced judgment
Code review/generation	gpt-4o, gpt-4.1, gpt-5.2-codex	OpenAI excels here

Agents Are Not Set and Forget

I want to be clear about something: deploying an agent is not the finish line. It's the starting line.

Too often I see organizations configure their agents, validate that they work in testing, push to production, and move on to the next project. Months later, they're surprised when costs have ballooned, accuracy has drifted, or the model they chose is now two generations behind.

Agents require ongoing attention. You need to:

Measure outputs: Are classifications still accurate? Has the error rate crept up? Are edge cases being handled correctly?
Observe actions: What decisions are your agents making? Are they aligned with business expectations? Are there patterns in failures?
Track token costs: Is consumption where you expected? Are certain workflows burning through budget? Could you scale down without sacrificing quality?
Verify governance: Are agents operating within policy? Are audit trails complete? Is sensitive data being handled appropriately?

This is especially true as models evolve. A workflow optimized for GPT-4o today might perform better and cheaper on GPT-4.1 tomorrow. A task you assigned to Sonnet might now be handled perfectly by Haiku at a fraction of the cost. But you won't know unless you're observing.

In a future post, I'll dive deeper into this. I'll walk through full use cases using different models, and share strategies for building observability into your agent deployments. How to set up measurement. How to know when it's time to scale up to a more powerful model. How to know when you can safely scale down and save budget. The goal is to give you a practical playbook for continuous optimization, not just initial deployment.

But please take this away and remember that the best agent strategy isn't "pick the right model." It's "pick a reasonable model, measure, and adapt."

Comments

Comments