Seu agent preenche formulários agora (Clairic)

Seu agent preenche formulários agora (Clairic)

What just happened (October 2026):

Cloudflare announced:

"Clairic: A new class of extraction models (System One speed, extraction accuracy)."

"Extract data from unstructured documents 10x faster and cheaper."

"Now available on Workers AI (production-ready)."

What this means for your agent:

Before (current): Customer uploads NF: PDF (unstructured) Agent: "I see a document" (can't extract data) Human: Must manually read NF (5 minutes) Extract: Amount, CNPJ, date (error-prone) Result: Support agent wasted on data entry Cost per document: R$50 (human time)

After (Clairic): Customer uploads NF: PDF (unstructured) Agent: Runs Clairic (extraction model) Clairic: Reads PDF, outputs JSON JSON: {amount: 1500.00, cnpj: "12.345.678/0001-90", date: "2026-10-20"} Result: Structured data ready for system Cost per document: R$0.50 (API call) Speed: 2 seconds (vs. 5 minutes)

Difference: Speed: 150x faster Cost: 100x cheaper Accuracy: 99%+ (vs. 85% manual) Agent: Finally automated (paperwork gone)

---

What is Clairic (and why it's a game-changer)

Definition: Extraction model ≠ Chat model

Key difference:

Chat models (Claude, GPT-4): Input: "What's in this document?" Output: "The document contains..." Format: Natural language (messy) Accuracy: ~80% (interpretation) Cost: $3 per 1M tokens (expensive) Speed: 5-10 seconds per document

Extraction models (Clairic): Input: "Extract data from this document" Output: {field: value, field: value} Format: Structured JSON (clean) Accuracy: ~99% (machine-readable) Cost: $0.50 per 1M tokens (cheap) Speed: 0.5-2 seconds per document

Practical difference: Chat: "Contains invoice for R$1.500" Extraction: {amount: 1500.00, currency: BRL}

Chat: Hard to use in system (needs parsing) Extraction: Ready for database (plug-and-play)

Why Clairic is different (System One class):

System One models (new category): Design: Specialized (not general-purpose) Speed: Ultra-fast (sub-second latency) Cost: Ultra-cheap (99%+ savings) Quality: Task-specific optimization

Examples:

1. Extraction: Read documents (Clairic)
2. Routing: Classify intent (coming)
3. Summarization: Ultra-fast summary (coming)
4. Coding: Generate code (coming)

Value proposition: Instead of: Use GPT-4 for everything (slow, expensive) Now: Use specialized model for each task (fast, cheap) Result: Same quality, 10x speed, 100x cost savings

---

The paperwork problem (what Clairic solves)

Your agent's dirty secret: Form-filling is 40% of work

Reality of support agents (typical company):

Support agent daily tasks: ✓ Answer customer questions: 30% ✓ Escalate to specialist: 20% ✗ Fill forms with customer data: 25% ✗ Extract info from documents: 15% ✓ Other: 10%

Billable time: 30% (answering) Wasted time: 40% (data entry)

Annual impact (10 agents): Payroll: R$600.000/year Wasted on paperwork: R$240.000/year ROI: If you automate paperwork → Save R$240k/year

Common paperwork scenarios:

Scenario 1: NF (Invoice) Customer: "Can you process my invoice?" Agent: Opens PDF Agent: Reads CNPJ, amount, date Agent: Types into system Time: 5-10 minutes Error rate: ~15% (typos, misreads)

Scenario 2: RG/CPF (ID verification) Customer: "I'm registering a new account" Agent: Opens government ID image Agent: Extracts name, document number Agent: Validates in system Time: 3-5 minutes Error rate: ~10% (low resolution images)

Scenario 3: Bank statement (Extrato) Customer: "Can you review my bank statement?" Agent: Reads statement PDF Agent: Identifies transactions, balance Agent: Summarizes for analysis Time: 10-15 minutes Error rate: ~20% (complex layouts)

Scenario 4: Contract review (Contrato) Customer: "Can you check my contract?" Agent: Reads contract PDF (10-20 pages) Agent: Finds key terms (payment, dates, clauses) Agent: Summarizes findings Time: 20-30 minutes Error rate: ~30% (legal language)

Why chat models fail at extraction

The problem:

Chat model limitations:

1. Slow: 5-10 seconds per document (customer waiting)
2. Expensive: $3/1M tokens (document costs R$10-50)
3. Inconsistent: Sometimes returns text, sometimes JSON
4. Hallucination: Makes up data (20% error rate)
5. Context limit: Can't handle 100-page documents

Example failure: Document: Invoice for R$1.500,00 Chat model returns: "The amount is approximately 1500 reais" Problem: System can't parse "approximately" Result: Manual verification needed (defeats purpose)

Why extraction models fix this:

Extraction model advantages:

1. Fast: 0.5-2 seconds (no waiting)
2. Cheap: $0.50/1M tokens (document costs R$0.10-0.50)
3. Consistent: Always returns JSON schema
4. Accurate: 99%+ (minimal hallucination)
5. Scalable: Process 100 documents per second

Example success: Document: Invoice for R$1.500,00 Extraction returns: {amount: 1500.00, currency: "BRL", format: "invoice"} Result: System auto-processes (zero manual work)

---

How Clairic works (practical example)

Real use case: Support agent handling customer documents

Scenario: Customer submits expense report

Step 1: Customer uploads document File: Relatório_Despesas_Outubro.pdf Content: Unstructured (mix of text, tables, dates)

Step 2: Agent calls Clairic API Input: document: [PDF binary] extraction_schema: { date: "string", total_amount: "float", category: "string", vendor: "string", receipt_number: "string" }

Step 3: Clairic processes (0.8 seconds) Output: { "date": "2026-10-15", "total_amount": 457.50, "category": "travel", "vendor": "LATAM Airlines", "receipt_number": "ABC123456" }

Step 4: Agent validates result Check: Amount matches, date valid, receipt number exists Result: Approved automatically

Step 5: System processes Action: Creates expense entry (no human touch) Time: 1.2 seconds total Cost: R$0.25 per document

Before (chat model): Time: 10 minutes (human data entry) Cost: R$15 (agent time) Error rate: 15%

After (Clairic): Time: 1.2 seconds (automated) Cost: R$0.25 (API call) Error rate: <1%

Annual impact (1000 expenses/month): Before: 10,000 minutes/year (160 hours/month) + R$180k/year After: 20 minutes/year + R$300/year Savings: 159+ hours/year + R$180k/year

---

Real-world agent use cases (Clairic enabled)

1. Customer onboarding (ID verification)

Current flow: Customer: Uploads CPF/RG image Agent: "What's your full name?" Customer: Provides name (manual verification needed) Agent: Checks if matches document Problem: Slow, error-prone, manual

With Clairic: Customer: Uploads CPF/RG image Agent: Runs Clairic (0.3 seconds) Clairic: Extracts {name, cpf, birthdate, address} Agent: Auto-fills form, validates Result: Instant verification (no manual work)

2. Insurance claims (document validation)

Current flow: Customer: Submits claim + supporting docs Agent: Manually reviews 10 documents (20 minutes) Agent: Extracts key info (policy number, amount, date) Agent: Fills claim form manually (error-prone) Problem: Slow, expensive, error-prone

With Clairic: Customer: Submits claim + supporting docs Agent: Runs Clairic on all documents (2 seconds) Clairic: Extracts all relevant data from each doc Agent: Auto-validates, auto-fills claim Result: Instant processing (no manual work)

3. Invoice processing (AP automation)

Current flow: Vendor: Sends invoice AP agent: Manually enters invoice data (5 minutes) Agent: Checks against PO, matches items Agent: Approves payment (error-prone) Problem: Slow, expensive, fraud risk

With Clairic: Vendor: Sends invoice Agent: Runs Clairic (0.5 seconds) Clairic: Extracts {amount, vendor, items, due_date} Agent: Auto-matches PO, validates Result: Instant approval (no manual work, fraud-proof)

4. Compliance documentation (KYC/AML)

Current flow: Customer: Submits KYC documents Compliance agent: Reviews 5-10 documents (30 minutes) Agent: Extracts key info (name, address, beneficial owner) Agent: Validates against sanctions lists (manual) Problem: Slow, expensive, compliance risk

With Clairic: Customer: Submits KYC documents Agent: Runs Clairic on all documents (1 second) Clairic: Extracts all required fields Agent: Auto-validates against sanctions (API call) Result: Instant compliance check (no risk)

---

Implementation: How to add Clairic to your agent

Step 1: Choose your platform (Clairic is on Cloudflare Workers AI)

Options:

1. Cloudflare Workers AI (officially supported)

   • Host: @cf/cloudflare/clairic
   • Cost: Included in Workers AI plan
   • Speed: Ultra-fast (edge computing)
   • Best for: Production agents

2. Self-hosted (open-weights, coming soon)

   • Host: Your infrastructure
   • Cost: GPU cost only
   • Speed: Depends on hardware
   • Best for: Private data, on-premise

3. Other providers (when available)

   • Bedrock: Coming (AWS)
   • Replicate: Coming (third-party)
   • HuggingFace: Coming (community)

Step 2: Define your extraction schema

Example: Invoice extraction

{ "invoice_number": "string", "issue_date": "date (YYYY-MM-DD)", "due_date": "date (YYYY-MM-DD)", "vendor_name": "string", "vendor_cnpj": "string", "total_amount": "float", "currency": "string (BRL, USD, etc)", "line_items": [ { "description": "string", "quantity": "float", "unit_price": "float", "total": "float" } ], "payment_terms": "string", "notes": "string or null" }

Step 3: Call Clairic API (simple example)

javascript // Pseudo-code: How to call Clairic

const extractData = async (documentBuffer, schema) => { const response = await fetch( 'https://api.cloudflare.com/client/v4/ai/extract', { method: 'POST', headers: { 'Authorization': Bearer ${API_TOKEN}, 'Content-Type': 'application/json' }, body: JSON.stringify({ model: 'clairic', document: documentBuffer, schema: schema }) } );

const result = await response.json(); return result.data; // Returns structured JSON };

// Usage in your agent: const invoiceData = await extractData( pdfBuffer, invoiceSchema );

console.log(invoiceData); // Output: // { // invoice_number: "INV-2026-001", // total_amount: 1500.00, // due_date: "2026-11-20", // ... // }

Step 4: Integrate with your agent workflow

Agent flow:

1. User uploads document
2. Agent: Call Clairic (0.5s)
3. Clairic: Returns JSON
4. Agent: Validates data
5. Agent: Updates system
6. User: Sees result (instant)

Code pattern: async function handleDocumentUpload(document) { try { // Step 1: Extract const data = await clairic.extract(document);

  // Step 2: Validate
  const validated = validateData(data);
  
  // Step 3: Store
  await database.insert(validated);
  
  // Step 4: Respond
  return { success: true, data: validated };
} catch (error) {
  return { success: false, error: error.message };
}

}

---

Cost-benefit analysis (why you should use Clairic now)

Scenario: 50-person support team

Current state (manual data entry): Team: 50 agents Time on forms: 40% (2 hours/day per agent) Payroll: R$50.000/month (total) Cost of paperwork: R$20.000/month (40% of payroll) Annual cost: R$240.000 Documents processed: 200/day × 50 agents = 10,000/month Error rate: 15% (1,500 errors/month)

With Clairic: API cost: R$0.25 per document Documents: 10,000/month Monthly API cost: R$2.500 Time saved: 1.5 hours/day per agent Payroll saved: R$15.000/month Net savings: R$15.000 - R$2.500 = R$12.500/month Annual savings: R$150.000 Error reduction: 99% (10 errors/month vs. 1,500)

ROI: Investment: Cloudflare Workers AI subscription (~R$500/month) Annual investment: R$6.000 Annual savings: R$150.000 ROI: 25x (2,500% return) Payback period: 2-3 weeks

Hidden benefits

✓ Speed: 150x faster (5 min → 2 sec) ✓ Accuracy: 99%+ vs 85% (error reduction) ✓ Scalability: Process 100x more documents (same team) ✓ Customer experience: Instant processing (vs waiting) ✓ Compliance: Audit trail (automated, traceable) ✓ Employee satisfaction: No more boring data entry

---

Conclusion: Extraction models = agent evolution

Summary:

Clairic (Cloudflare extraction model): ✓ Fast: 0.5-2 seconds per document ✓ Cheap: R$0.25 per document ✓ Accurate: 99%+ (vs 85% manual) ✓ Reliable: Structured JSON output ✓ Scalable: Process 10,000+ docs/day

Your agent impact: Before: "I see a document" (useless) After: Extracts all data automatically (game-changer)

Business impact: Before: 40% of work is data entry (waste) After: 0% data entry (fully automated)

Financial impact: Before: R$240k/year on paperwork After: R$2.5k/year (99% savings) ROI: 25x within 12 months

The question for your company:

Your agent:

• Handling documents? (Probably yes)
• Extracting data manually? (Almost certainly)
• Wasting money on form-filling? (Definitely)

Clairic proves: Extraction is now instant (0.5-2 seconds) Extraction is now cheap (R$0.25/document) Extraction is now accurate (99%)

Will you: Option A: Keep manual extraction (waste R$240k/year) Option B: Automate with Clairic (save R$150k/year, 25x ROI)

→ OpenClaw: Agent automation, document extraction, form-filling automation, Clairic integration, agent workflows, data extraction models, compliance automation, customer onboarding automation

Seu agent: Finalmente automatiza paperwork. Clairic está pronto. 📄✅