Seu agent treina em lixo (dados = qualidade)

Seu agent treina em lixo (dados = qualidade)

Cenário que ninguém fala (mas está destruindo seu agent):

Você tem SaaS com agent (suporte, vendas, automação).

Agent precisa ser treinado (fine-tuning, RAG, RLHF).

Training data vem de:

Source 1: Customer conversations (messy, inconsistent) Source 2: Internal docs (outdated, contradictory) Source 3: Support tickets (incomplete, poorly labeled) Source 4: Sales scripts (generic, not optimized) Source 5: Social media (noisy, off-topic)

Result: Training data = 70% garbage, 30% useful

What happens to your agent:

Garbage in → Agent learns from garbage → Garbage out

Agent behavior:

• Gives wrong answers (trained on wrong data)
• Doesn't understand context (data poorly labeled)
• Misses nuances (training set too small)
• Hallucinates (no good examples to learn from)
• Frustrates customers (quality is bad)

Customer experience: "Agent never understands my question" "Agent gives irrelevant answers" "Agent sounds robotic (not trained on real conversations)" "I just want to talk to a human" → Customer leaves (agent failed)

The real problem:

Data preparation is HARD:

1. Search: Find relevant data (90% of data is irrelevant) Problem: Can't manually search 10,000 documents

2. Curation: Pick the good stuff (remove garbage) Problem: What counts as "good"? (subjective)

3. Annotation: Label data ("this is a complaint", "this is a question") Problem: Manual labeling = 1000 hours for 10k examples

4. Evaluation: Measure quality (does training actually work?) Problem: You don't know if agent improved or got worse

Result: Most teams skip these steps (too hard, too slow) Consequence: Agent trains on unprocessed garbage Outcome: Agent quality = terrible

Then: Voxel51 releases 3.0

What changed:

Old model (2025):

• Search tool (separate)
• Curation tool (separate)
• Annotation tool (separate)
• Evaluation tool (separate) → Need to manually connect them → Slow, error-prone, manual

New model (2026):

• Unified platform
• All tools in one system
• Workflow automated
• Results integrated → Search → Curation → Annotation → Evaluation (seamless) → Fast, automatic, data flows

Impact:

Old workflow (manual):

1. Search data (2 hours)
2. Export to CSV
3. Clean in spreadsheet (4 hours)
4. Label manually (10 hours)
5. Export to annotation tool
6. Train model (1 hour)
7. Manually check results
8. Fix mistakes

Total time: 20+ hours Quality: 60% (manual mistakes) Cost: 1 engineer for 1 week

New workflow (unified):

1. Import data to Voxel51
2. Run search operator (automatic)
3. Run curation operator (automatic)
4. Run annotation operator (automatic)
5. Train model (automatic)
6. Get evaluation results (automatic)

Total time: 2 hours Quality: 90% (less manual work) Cost: 1 engineer for 1 day

The competitive advantage:

You (using Voxel51 3.0):

• Train agent on clean data
• Agent quality = 90%
• Training time = 2 hours/week
• Can iterate fast (test new data, retrain)
• Agent improves weekly

Competitor (manual process):

• Train agent on messy data
• Agent quality = 60%
• Training time = 20 hours/week
• Can't iterate (too slow)
• Agent stuck (no improvements)

Result: You win (better agent, faster iteration, lower cost)

---

The data quality problem (why agents fail)

GIGO: Garbage In, Garbage Out (the law of AI)

The principle:

Agent quality = f(training data quality)

If training data is:

• 50% garbage → Agent quality = 50% garbage
• 70% garbage → Agent quality = 70% garbage
• 90% garbage → Agent quality = 90% garbage

You cannot improve agent without improving data.

Corollary: Spending more on LLM doesn't help (if training data is bad, model learns bad behavior)

Example: Support agent

Scenario: Train support agent on customer conversations

Training data: Conversation 1: "I have a problem. Fix it." → (no context, vague) Conversation 2: "Billing question: duplicate charge." → (clear) Conversation 3: "asdfghjk i hate ur product" → (emotional, useless) Conversation 4: "How do I reset password?" → (clear) Conversation 5: "[internal note: customer angry, flag for manager]" → (internal, not customer)

Garbage count: 3/5 = 60%

What agent learns:

• Sometimes problem is unclear (from #1)
• Sometimes problem is clear (from #2, #4)
• Sometimes customer is angry (from #3)
• Sometimes there's context we shouldn't see (from #5)

Result: Agent is confused (mixed signals) Agent behavior: Inconsistent, sometimes good, sometimes bad

Example: Sales agent

Scenario: Train sales agent on successful sales conversations

Training data: Conversation 1: "Here's the price. Buy now." → (low context, closing) Conversation 2: "Tell me about your use case..." → (discovery) Conversation 3: "I'm not authorized to offer discounts" → (constraint) Conversation 4: "Let me schedule a demo" → (next step) Conversation 5: "I don't actually work here, this is a mistake" → (garbage)

Garbage count: 1/5 = 20% (still significant!)

What agent learns:

• Sometimes ask about use case (discovery)
• Sometimes close fast (#1)
• Sometimes push constraints (#3)
• Sometimes suggest demo (#4)
• Sometimes... says random stuff? (#5)

Result: Agent is confused (mixed strategies) Agent behavior: Unpredictable, sometimes closes fast, sometimes discovers, sometimes stuck

The data quality challenges (why it's hard)

Challenge 1: Data is messy

Real-world data:

• Typos ("helo" instead of "hello")
• Abbreviations ("tnx" instead of "thanks")
• Sarcasm ("Great, another problem" = complaint, not praise)
• Multi-language (customer switches mid-conversation)
• Emojis (🤬 = very angry)
• Incomplete (customer never finished thought)
• Off-topic (customer talks about weather, then asks question)

Agent learns: Messy behavior (mirrors training data) Result: Agent sounds messy, unprofessional, confused

Challenge 2: Data is biased

Example: Support conversations

• 80% of data = English speakers (agent learns English bias)
• 70% of data = US customers (agent learns US-centric answers)
• 90% of data = happy customers (agent doesn't know how to handle angry ones)
• 100% of data = technical customers (agent doesn't know how to explain to non-technical)

Agent learns: Biases from training data Result: Agent fails on: Portuguese customers, Brazilian context, angry customers, non-technical customers

Challenge 3: Data is unlabeled

Example: Raw support tickets Ticket 1: "My account doesn't work" Label: ??? (could be technical issue, billing issue, access issue)

Ticket 2: "I'm angry about service" Label: ??? (complaint? feedback? demand for refund?)

Ticket 3: "How do I do X?" Label: ??? (question? confusion? request?)

Without labels:

• Agent doesn't learn categories
• Agent doesn't know how to classify new tickets
• Agent doesn't know what action to take

Result: Agent can't route tickets, can't prioritize, can't respond appropriately

Challenge 4: Data is incomplete

Example: Sales conversation Rep: "What's your budget?" Customer: [doesn't respond] Rep: "Are you still there?" Customer: [never replies]

Incomplete conversation:

• Agent learns: "If customer doesn't respond, don't know what to do"
• Agent has no training for this scenario
• Agent freezes or gives up

Result: Agent can't handle incomplete interactions (common in real life)

---

The Voxel51 3.0 solution (unified data platform)

What Voxel51 3.0 does

The platform (end-to-end):

Step 1: Search Input: "Find all support conversations about billing" Output: 500 relevant conversations (out of 10,000) Problem solved: Don't train on irrelevant data

Step 2: Curation Input: 500 conversations Process: Filter out: - Duplicates - Spam - Incomplete - Off-topic Output: 300 clean conversations Problem solved: Remove garbage before training

Step 3: Annotation Input: 300 conversations Process: Automatically label: - Conversation type (support, sales, feedback) - Sentiment (angry, happy, neutral) - Category (billing, technical, general) - Resolution (solved, escalated, pending) Output: 300 labeled conversations Problem solved: Training data now has labels

Step 4: Evaluation Input: Agent trained on 300 conversations Process: Test agent on: - New conversations (accuracy) - Edge cases (robustness) - Different languages (generalization) Output: Quality metrics (80% accurate, 5% errors, etc) Problem solved: Know if agent is good before deploying

Key feature: Agents (MCP tools + operators)

Voxel51 Agent = automated helper

45+ MCP tools:

• Search operators (find specific data)
• Filter operators (remove bad data)
• Transform operators (format data)
• Annotation operators (label data)
• Evaluation operators (measure quality)

80+ operators:

• Premade workflows for common tasks
• "Find and clean billing conversations" (one-click)
• "Label sentiment in all support tickets" (one-click)
• "Evaluate agent on test set" (one-click)

18 open-source skills:

• Prebuilt integrations (connect to your tools)
• Salesforce integration (pull conversations)
• Slack integration (pull conversations)
• GitHub integration (pull issue discussions)

Result: Complex workflows = simple clicks

How this changes your agent quality

Before Voxel51 3.0 (manual process):

Week 1: Collect data

• Export conversations from Salesforce (2 hours)
• Export from Slack (1 hour)
• Export from support system (2 hours)
• Total: 5 hours of data collection
• Result: 10,000 raw, unprocessed conversations

Week 2: Clean data

• Manually remove duplicates (4 hours)
• Manually remove spam (2 hours)
• Manually check for completeness (3 hours)
• Total: 9 hours of manual work
• Result: 6,000 conversations (40% removed)
• Quality: 70% (still some garbage)

Week 3: Label data

• Manually label each conversation (20 hours!)
• Train agent on labeled data (2 hours)
• Total: 22 hours
• Result: Agent trained on 6,000 labeled conversations
• Quality: 70% (reflects training data quality)

Total process: 36 hours (1 full-time engineer for 1 week) Data quality: 70% Agent quality: 70%

After Voxel51 3.0 (unified platform):

Week 1: Setup integrations

• Connect Salesforce to Voxel51 (30 minutes)
• Connect Slack to Voxel51 (30 minutes)
• Connect support system to Voxel51 (30 minutes)
• Total: 1.5 hours
• Result: Data automatically flows to Voxel51

Week 2: Run workflows

• Click "Search billing conversations" (1 minute)
• Click "Remove duplicates and spam" (2 minutes)
• Click "Auto-label sentiment and category" (2 minutes)
• Click "Train agent" (1 minute)
• Total: 6 minutes
• Result: Agent trained on 7,500 clean, labeled conversations
• Quality: 90% (automatic cleaning and labeling)

Week 3: Evaluate

• Click "Evaluate agent on test set" (1 minute)
• Review results (30 minutes)
• Identify improvements (30 minutes)
• Retrain with improvements (1 minute)
• Total: 2 hours
• Result: Agent quality improved from 90% → 92%

Total process: 3.5 hours (1 engineer for 1 day, not 1 week) Data quality: 90% Agent quality: 90% (vs 70% before)

Improvement: 28% better quality, 90% less time

---

The competitive advantage (data quality = moat)

Why data quality matters (more than model size)

Common misconception:

"Better model = better agent"

Reality: "Better training data = better agent"

Example: GPT-4 Mini (small) + clean data = 90% quality GPT-3.5 (old) + garbage data = 40% quality

Small model + good data > Large model + bad data

The leverage point:

Model capability = fixed (you don't control OpenAI or Anthropic) Training data = controllable (you own your data)

Where you have control = where you win

You can't:

• Make OpenAI release better models
• Control Claude's architecture
• Speed up DeepSeek's research

You CAN:

• Collect better training data
• Clean your training data
• Label your training data
• Evaluate your training data

Result: Data quality = your competitive moat

Building the moat (long-term advantage)

Why data compound over time:

Month 1:

• Train agent on 10,000 clean conversations
• Agent quality: 80%

Month 2:

• Collect 5,000 new conversations
• Clean with Voxel51 3.0 (fast)
• Retrain agent on 15,000 total
• Agent quality: 82% (improved)

Month 3:

• Collect 5,000 new conversations
• Clean + retrain
• Agent quality: 84%

Month 6:

• Total data: 30,000 clean conversations
• Agent quality: 88%

Month 12:

• Total data: 60,000 clean conversations
• Agent quality: 92%

Competitor (no data pipeline):

• Month 12: Still at 70% (stagnant)
• Can't retrain fast (no unified pipeline)
• Data keeps getting worse (garbage accumulates)

Result: You get 92%, they stay at 70% Advantage: Compounding over time (gets bigger every month)

Why competitors can't catch up:

Competitor wants to copy your approach:

1. Implement Voxel51 3.0 (1 week)
2. Collect data (slow, no historical data)
3. Clean data (1 week)
4. Retrain (1 week)
5. Total: 3 weeks to get to current level

Meanwhile, you:

• Keep collecting data (5,000 new/month)
• Keep retraining (every 2 weeks)
• Keep improving (92% → 93% → 94%)
• They get 80%, you're already at 94%

Result: Competitor can never catch up Advantage: Permanent (data advantage grows)

---

The action plan (move to unified data platform)

Step 1: Audit current data (2 weeks)

What to measure:

1. Data quantity

   • How many conversations do you have?
   • Where are they stored? (Salesforce, Slack, support system, emails)
   • What format? (JSON, CSV, text, audio)

2. Data quality

   • How many are duplicates? (estimate %)
   • How many are spam/garbage? (estimate %)
   • How many are incomplete? (estimate %)
   • How many are labeled? (estimate %)

3. Data coverage

   • What languages? (English only, or multilingual)
   • What customer types? (all types, or biased)
   • What scenarios? (support only, or sales + support + feedback)

4. Current agent quality

   • What's current accuracy? (measure baseline)
   • What are common failures? (identify patterns)
   • What's limiting improvement? (data, model, infrastructure)

Step 2: Implement Voxel51 3.0 (4-6 weeks)

Setup:

1. Get access

   • Sign up for Voxel51 3.0 (free tier available)
   • Create project
   • Invite team

2. Connect data sources

   • Salesforce integration (30 min)
   • Slack integration (30 min)
   • Support system integration (1-2 hours)
   • Email integration (optional)

3. Create workflows

   • "Search" workflow (find relevant conversations)
   • "Clean" workflow (remove garbage)
   • "Label" workflow (annotate automatically)
   • "Evaluate" workflow (measure quality)

4. Train agent

   • Export cleaned data from Voxel51
   • Fine-tune agent on cleaned data
   • Evaluate quality improvement

Timeline:

Week 1: Setup (integrations, connectors) Week 2: Data collection (pull all conversations) Week 3: Workflows (clean, label, evaluate) Week 4: Training (fine-tune agent, measure quality) Week 5-6: Refinement (iterate, improve)

Step 3: Establish iteration cycle (ongoing)

Weekly process:

1. Monday: Collect new data (auto-run integrations)
2. Tuesday: Clean data (auto-run curation workflow)
3. Wednesday: Label data (auto-run annotation workflow)
4. Thursday: Train agent (retrain on new data)
5. Friday: Evaluate (measure quality)
6. If quality improved: Deploy new agent
7. If quality stayed same: Investigate why

Metrics to track:

1. Data metrics

   • Total conversations (should grow 5,000+/month)
   • Quality score (should stay 90%+)
   • Labeling accuracy (should stay 95%+)

2. Agent metrics

   • Accuracy (should improve 1-2% monthly)
   • Resolution rate (should improve)
   • Customer satisfaction (should improve)

3. Efficiency metrics

   • Time to retrain (should be < 1 hour)
   • Time to label (should be < 2 hours for 5k conversations)
   • Cost per conversation (should decrease)

---

Conclusion: Data quality = agent quality (move to unified platform)

The fundamental truth:

Agent quality = training data quality

If you want better agents: → Invest in better training data → Invest in data infrastructure → Invest in data curation

Not: → Bigger model (expensive, not always better) → More prompting (diminishing returns) → More fine-tuning (garbage in, garbage out)

The Voxel51 3.0 insight:

Data preparation was hard:

• Search (manual)
• Curation (manual)
• Annotation (manual)
• Evaluation (manual)

Now it's easy:

• Unified platform
• Automated workflows
• 6 minutes instead of 36 hours
• 90% quality instead of 70%

Result: Agent quality unlocked by data infrastructure

Your competitive advantage:

If you move to unified data platform NOW:

• 6 months ahead = 92% quality vs competitors' 70%
• 12 months ahead = 95% quality vs competitors' 75%
• Permanent moat = data compounds (they can't catch up)

If you wait:

• Everyone implements eventually
• Data advantage disappears
• Back to competing on price/marketing
• Margins collapse

→ OpenClaw: Agent training data, quality assurance, multimodal platform, data curation, annotation automation, unified pipeline

Seu agent treina em lixo. Voxel51 3.0 muda isso. Hora de unificar seus dados 🚀