Model Selection Guide

Choosing the right AI model for your document processing workload directly impacts cost, quality, and processing time. This guide helps you select between Alactic GPT-4o and GPT-4o mini based on your requirements.

Model Comparison

Quick Comparison Table

Feature	GPT-4o mini	GPT-4o
Input Cost	$0.150 / 1M tokens	$2.50 / 1M tokens
Output Cost	$0.600 / 1M tokens	$10.00 / 1M tokens
Cost Ratio	Baseline	16.7x more expensive
Context Window	128K tokens	128K tokens
Processing Speed	Faster (baseline)	Similar
Quality	Excellent	Superior
Best For	Straightforward extraction	Complex reasoning
Plans	All plans	Pro, Pro+, Enterprise

Detailed Specifications

Alactic GPT-4o mini:

• Model Architecture: Optimized GPT-4 variant
• Parameters: Not disclosed (smaller than GPT-4o)
• Training Data: 1 billion+ tokens (documents, forms, web content)
• Context Window: 128,000 tokens (~96,000 words or 380 pages)
• Max Output: 16,384 tokens (~12,000 words)
• Latency: ~0.4 seconds per request (within Azure region)
• Strengths:
  • Cost-effective for high-volume processing
  • Fast inference time
  • Excellent text extraction accuracy
  • Good summarization quality
  • Reliable entity recognition
• Weaknesses:
  • Less nuanced understanding of context
  • May miss subtle implications
  • Less creative in reformulation
  • Lower performance on ambiguous text

Alactic GPT-4o:

• Model Architecture: Full GPT-4 with document specialization
• Training Data: 1 billion+ tokens (same dataset as mini, but full model capacity)
• Context Window: 128,000 tokens (~96,000 words or 380 pages)
• Max Output: 16,384 tokens (~12,000 words)
• Latency: ~0.5 seconds per request (similar to mini)
• Strengths:
  • Superior reasoning and understanding
  • Better handling of complex documents
  • Nuanced interpretation of ambiguous text
  • Excellent at multi-step analysis
  • Creative reformulation and synthesis
  • Better multilingual performance
• Weaknesses:
  • 16.7x higher cost than mini
  • Only marginally slower than mini

When to Use Each Model

Use GPT-4o mini When:

1. Straightforward Text Extraction

Documents with clear, unambiguous text:

• Invoices and receipts
• Forms with structured data
• Simple articles and blog posts
• Product descriptions
• Email content
• Meeting notes

Example:

Input: Standard invoice with clearly labeled fields
(Vendor Name, Invoice Number, Date, Amount, Line Items)

GPT-4o mini:  Extracts all fields correctly
GPT-4o:  Also extracts correctly (but 16x cost)

Verdict: Use mini (same quality, much cheaper)

2. High-Volume Processing

When processing hundreds or thousands of documents:

• Batch processing workflows
• Regular scheduled jobs (daily invoice processing)
• Content aggregation pipelines
• Automated monitoring systems

Cost comparison (1,000 documents, avg 5,000 tokens each):

GPT-4o mini:
  1,000 × 5,000 tokens × $0.150 / 1M = $0.75

GPT-4o:
  1,000 × 5,000 tokens × $2.50 / 1M = $12.50

Savings: $11.75 (94% cost reduction)

3. Development and Testing

During development phase:

• Testing extraction accuracy
• Prototyping features
• Validating API integration
• Performance benchmarking

Rationale: Mini is cheaper for experimentation. Switch to GPT-4o only if quality insufficient.

4. Cost-Constrained Budgets

When minimizing costs is priority:

• Free Plan users (mini only option)
• Startups with limited budget
• Personal projects
• Non-critical workloads

5. Simple Summarization

Documents with straightforward content to summarize:

• News articles
• Blog posts
• Press releases
• Simple reports

Example:

Input: 1,000-word news article about new product launch

GPT-4o mini output:
"Company X launched Product Y, featuring A, B, and C.
Available starting March 1 for $99. CEO says it will
transform the industry."

GPT-4o output:
"Company X launched Product Y, featuring A, B, and C.
Available starting March 1 for $99. CEO says it will
transform the industry by addressing pain points D and E."

Difference: Minor additional context from GPT-4o.
Value: Probably not worth 16x cost.

Use GPT-4o When:

1. Complex Document Analysis

Documents requiring deep understanding:

• Legal contracts with nuanced clauses
• Technical research papers
• Medical reports
• Financial analysis reports
• Patents
• Academic dissertations

Example:

Input: Legal contract with complex indemnification clause

GPT-4o mini output:
"Section 5.2 covers indemnification. Party A must
indemnify Party B for losses."

GPT-4o output:
"Section 5.2 establishes asymmetric indemnification:
Party A indemnifies Party B for third-party claims
but NOT for Party B's own negligence (exception in 5.2.3).
This limits Party A's liability exposure."

Difference: GPT-4o identifies nuance and exception.
Value: Critical for legal analysis. Worth 16x cost.

2. Multi-Step Reasoning

Tasks requiring logical inference:

• Analyzing cause-effect relationships
• Identifying inconsistencies across documents
• Comparing multiple documents for discrepancies
• Drawing conclusions not explicitly stated

Example:

Input: Financial report showing declining revenue but
increasing expenses, combined with CEO statement about
"strong growth trajectory"

GPT-4o mini:
"Revenue decreased 12%. Expenses increased 8%.
CEO remains optimistic."

GPT-4o:
"Despite CEO's optimistic statement, financials show
concerning trend: declining revenue (-12%) with rising
expenses (+8%) indicates potential profitability crisis.
CEO's assessment contradicts objective data."

Difference: GPT-4o identifies contradiction and implication.
Value: Essential for critical analysis.

3. Ambiguous or Poorly Formatted Text

Documents with unclear structure:

• Scanned PDFs with OCR errors
• Handwritten notes (if digitized)
• Poorly formatted reports
• Documents with lots of jargon/abbreviations

4. Multilingual Documents

Documents mixing multiple languages or requiring translation:

• International contracts
• Academic papers with non-English references
• Global business reports

GPT-4o advantages:

• Better understanding of language nuance
• More accurate translation
• Better handling of code-switching

5. Creative Synthesis

Tasks requiring reformulation or creative output:

• Writing executive summaries (not just extraction)
• Generating insights from data
• Creating structured outlines from unstructured text
• Comparative analysis with original conclusions

6. Mission-Critical Workloads

Where accuracy is paramount:

• Legal discovery
• Medical diagnosis support
• Financial due diligence
• Regulatory compliance
• Safety-critical applications

Rationale: Extra cost is insurance against errors. Even 1% accuracy improvement may justify 16x cost if errors are costly.

Decision Framework

Cost-Benefit Analysis

Formula:

Use GPT-4o if: (Value of Improved Quality) > (16x Cost Increase)

Example 1: Invoice Processing

Scenario:

• Processing 1,000 invoices per month
• Average: 5,000 tokens per invoice

Cost calculation:

• Mini: $0.75/month
• GPT-4o: $12.50/month
• Difference: $11.75/month

Quality difference:

• Mini accuracy: 99.5%
• GPT-4o accuracy: 99.8%
• Improvement: 0.3% (3 fewer errors per 1,000)

Value of improvement:

• Cost to manually fix error: $2 (5 minutes @ $24/hour)
• Value of 3 fewer errors: 3 × $2 = $6/month

Decision: $6 value < $11.75 cost → Use mini

Example 2: Legal Contract Analysis

Scenario:

• Analyzing 10 contracts per month
• Average: 20,000 tokens per contract

Cost calculation:

• Mini: $0.03/month
• GPT-4o: $0.50/month
• Difference: $0.47/month

Quality difference:

• Mini: May miss 1 nuanced clause per 10 contracts
• GPT-4o: Catches all nuances

Value of improvement:

• Cost of missing important clause: Potentially $10,000+ (legal liability)
• Value of catching 1 additional issue: $10,000

Decision: $10,000 value >> $0.47 cost → Use GPT-4o

Model Selection Checklist

Answer these questions to choose model:

1. Is this a high-volume workflow (100+ documents)?

• Yes → Prefer mini (cost adds up)
• No → Consider GPT-4o (cost difference minimal)

2. Is the document structure straightforward?

• Yes → Use mini
• No → Consider GPT-4o

3. Do I need deep reasoning or inference?

• No → Use mini
• Yes → Use GPT-4o

4. What's the cost of an error?

• Low (less than $10) → Use mini
• High (more than $100) → Use GPT-4o

5. Is this a Free Plan deployment?

• Yes → Must use mini (GPT-4o not available)
• No → Can choose either

6. Am I testing/developing or in production?

• Testing → Use mini
• Production with critical workload → Consider GPT-4o

Hybrid Strategies

Strategy 1: Tiered Processing

Use different models for different document types:

High-value documents (contracts, legal, financial):
  → GPT-4o

Low-value documents (receipts, simple forms):
  → GPT-4o mini

Implementation:

def select_model(document_type):
    high_value_types = ['contract', 'legal', 'financial', 'medical']
    
    if document_type in high_value_types:
        return 'gpt-4o'
    else:
        return 'gpt-4o-mini'

# Usage
model = select_model(doc.type)
result = process_document(doc, model=model)

Benefit: Optimize cost while maintaining quality where it matters.

Strategy 2: Cascading Models

Try mini first, escalate to GPT-4o if confidence low:

1. Process with GPT-4o mini
2. Check confidence score
3. If confidence < 80%, reprocess with GPT-4o

Implementation:

# First pass with mini
result_mini = process_document(doc, model='gpt-4o-mini')

# Check confidence
if result_mini['confidence'] < 0.80:
    # Retry with GPT-4o
    result = process_document(doc, model='gpt-4o')
else:
    result = result_mini

# Cost: Most documents use mini, only uncertain ones use GPT-4o

Benefit: Get GPT-4o quality for difficult documents while using mini pricing for easy ones.

Typical savings: 70-90% of documents processed with mini, 10-30% with GPT-4o.

Strategy 3: Sampling and Validation

Use GPT-4o for sample, mini for bulk:

1. Process 10 documents with GPT-4o (establish quality baseline)
2. Process same 10 documents with GPT-4o mini
3. Compare accuracy
4. If mini accuracy acceptable (>95%), use mini for remaining 990

Benefit: Validate mini quality before committing to large batch.

Cost: Minimal overhead (10 extra GPT-4o calls) to ensure quality.

Performance Considerations

Processing Speed

Actual benchmarks (within Azure region):

Document Size	GPT-4o mini	GPT-4o	Difference
1 page (500 tokens)	0.8s	1.0s	+25%
10 pages (5,000 tokens)	2.1s	2.5s	+19%
50 pages (25,000 tokens)	8.3s	9.1s	+10%
100 pages (50,000 tokens)	15.7s	17.2s	+10%

Insight: GPT-4o is only slightly slower (10-25%). Speed difference minimal in practice.

When speed matters:

• Real-time applications (user waiting for result)
• High-volume batch processing (shave 10% off total time)

Recommendation: Speed difference rarely justifies model choice. Prioritize quality and cost.

Token Consumption

Both models have same context window (128K tokens) but may use tokens differently:

Input tokens: Same (both models see same document)

Output tokens: Can differ significantly

Example (10-page research paper):

GPT-4o mini output (Summary):
  250 tokens

GPT-4o output (Summary):
  350 tokens (more detailed, nuanced)

Cost difference:
  Mini: 250 × $0.600/1M = $0.00015
  GPT-4o: 350 × $10.00/1M = $0.0035

GPT-4o uses 40% more output tokens AND costs 16.7x per token.
Combined effect: ~23x higher output cost.

Tip: GPT-4o generates more verbose outputs. If you need concise summaries, specify in prompt: "Provide a concise 100-word summary."

Switching Models

Reprocessing with Different Model

If unsatisfied with mini results, reprocess with GPT-4o:

Via Dashboard:

1. Find document in results
2. Click "Reprocess"
3. Change model to GPT-4o
4. Click "Process"
5. Compare results

Via API:

# Reprocess document with different model
curl -X POST https://<vm-ip>/api/v1/reprocess \
  -H "X-Deployment-Key: ak-xxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "document_id": "doc_abc123",
    "model": "gpt-4o"
  }'

Cost: Charged for both processing attempts (mini + GPT-4o).

Changing Default Model

Set default model in Settings:

1. Go to Settings → Model Configuration
2. Select "Default Model"
3. Choose: GPT-4o mini or GPT-4o
4. Save changes
5. All future processing uses this model (unless overridden)

Frequently Asked Questions

Q: Can I mix models in a batch job?
A: No. Batch jobs use single model for all documents. To mix, submit separate batches.

Q: Does GPT-4o support larger documents?
A: No. Both models have same 128K token context window. Neither is better for large documents.

Q: Is GPT-4o mini a older/outdated model?
A: No. Both are current models with same training data (1B+ tokens). Mini is optimized for efficiency, not legacy.

Q: Can I use GPT-4o on Free Plan?
A: No. GPT-4o requires Pro, Pro+, or Enterprise plan.

Q: Which model should I default to?
A: GPT-4o mini. Use GPT-4o only when mini quality is insufficient. This minimizes costs.

Q: Does model choice affect vector embeddings?
A: No. Embeddings generated separately using text-embedding-3-large (same for both models).

Q: Can I switch models mid-batch?
A: No. If batch processing with mini, all documents in batch use mini. Cannot change mid-batch.

Q: Do both models support all languages?
A: Yes, but GPT-4o has better multilingual performance, especially for less common languages.

Best Practices

1. Start with Mini, Escalate if Needed

• Default to GPT-4o mini
• Review sample results
• Switch to GPT-4o only if quality insufficient

2. Document Your Model Choice

• Record which model used for each job
• Track quality metrics (accuracy, completeness)
• Justify GPT-4o usage (for cost accountability)

3. Monitor Costs by Model

• Track spending breakdown: mini vs GPT-4o
• Calculate % of budget spent on GPT-4o
• Optimize if GPT-4o >50% of spend (unless justified)

4. Test Both Models on Representative Sample

• Before large batch, test 10 documents with each model
• Compare quality objectively
• Choose model based on data, not assumptions

5. Review and Optimize Quarterly

• Every quarter, review model usage
• Check if quality requirements changed
• Adjust model strategy accordingly

Related Documentation

• Models Overview
• Token Management
• Cost Optimization
• API Reference