Seu agente solo? Multi-agent workflows (Anthropic revelou)

Seu agente solo? Multi-agent workflows (Anthropic revelou)

Notícia: Anthropic (empresa por trás do Claude) anunciou Dynamic Workflows ("flows") na AI Engineer NYC 2026. O quê é: Nova arquitetura pra orquestrar múltiplos Claude agents (não um agente, vários trabalhando juntos). Contexto: Anthropic mostrou como coordenar agents pra tarefas complexas (workflow = pipeline de agents especializados). Implicação: Seu agente WhatsApp (solitário, genérico) tá obsoleto. Competitors estão movendo pra multi-agent workflows (agents especializados coordenados). Você precisa fazer AGORA ou perder mercado.

Realidade: **

SEU AGENTE TODAY (SINGLE-AGENT, "SWISS ARMY KNIFE"):

ARCHITECTURE: ├─ 1 Agent (Claude/GPT genérico) ├─ Tenta fazer TUDO: │ ├─ Classificar customer intent ("Qual é o assunto?") │ ├─ Buscar dados no CRM ("Quem é o customer?") │ ├─ Validar documento ("É RG válido?") │ ├─ Processar pagamento ("Vou debitar a conta") │ ├─ Lidar com edge cases ("E se der erro?") │ └─ Escalar pro humano ("Deixa o Carlos resolver") │ └─ Result: 1 agente pra 6 funções (não especializado)

PROBLEM 1: QUALIDADE ├─ Agent é genérico (não expert em nada) ├─ Accuracy: 85% (acerta 17/20 intents) ├─ Hallucination: 8% (inventa dados) ├─ Cost: Alto (agent precisa pensar em TUDO) └─ Result: Mediocre em TODAS as tarefas

PROBLEM 2: LATÊNCIA ├─ Agent precisa processar TUDO em serie: │ ├─ 1. Entender intent: 200ms │ ├─ 2. Buscar dados: 300ms │ ├─ 3. Validar documento: 250ms │ ├─ 4. Processar pagamento: 500ms │ └─ Total: 1250ms (1.25 segundos) │ ├─ Customer esperando 1+ segundo por resposta ├─ Em hora pico (N customers): Pior (fila de requests) └─ Result: Lento, não escalável

PROBLEM 3: ESCALABILIDADE ├─ 1 Agent tem limite de capacidade (throughput) ├─ 100 concurrent requests: Agent tá no limite ├─ 1000 concurrent requests: Agente breaks (timeout) ├─ Solution: Aumentar compute (mais caro) ├─ Mas: Mesmo com mais compute, agente ainda genérico └─ Result: Escalabilidade linear (não exponencial)

PROBLEM 4: MANUTENÇÃO ├─ Agente faz tudo (monolith) ├─ Mudar lógica de intent classification: Afeta tudo ├─ Adicionar nova validação: Risk de quebrar outras coisas ├─ Debug: Difícil (qual step falhou?) └─ Result: Frágil (mudança = risco alto)

PROBLEM 5: EXPERTISE ├─ Specialist em intent classification? Nope (genérico) ├─ Specialist em payment validation? Nope (genérico) ├─ Specialist em customer service? Nope (genérico) ├─ Result: Mediocre em tudo └─ Quality suffers (no deep knowledge)

EXAMPLE: CUSTOMER SCENARIO (SINGLE AGENT FAIL)

Customer: "Quero abrir conta poupança e transferir R$ 5000 da minha outra conta."

Single-Agent (Claude) tries to handle: ├─ Step 1: Classificar intent │ ├─ Agent: "Intent é account opening + transfer" │ ├─ Accuracy: 90% (sometimes gets confused) │ └─ If wrong: Rest of flow breaks │ ├─ Step 2: Buscar dados do customer │ ├─ Agent: "Preciso buscar CRM. Qual é meu endpoint?" │ ├─ Problem: Agent não conhece CRM API (genérico) │ ├─ Agent: "Vou chutar endpoint..." (hallucination risk) │ └─ Result: Pode buscar dados errados │ ├─ Step 3: Validar documentos │ ├─ Agent: "Vou validar RG. Qual é o algoritmo?" │ ├─ Problem: Agent não é especialista em validação │ ├─ Agent: "Parece válido" (low confidence) │ └─ Result: Deixa passar documento fake │ ├─ Step 4: Processar transfer │ ├─ Agent: "Vou debitar conta source e creditar dest." │ ├─ Problem: Agent não conhece regras bancárias │ ├─ Agent: "Pronto, transferi R$ 5000" │ ├─ But: Não validou limite de transferência (rule break) │ └─ Result: Compliance risk │ ├─ Step 5: Notificar customer │ ├─ Agent: "Sua transfer foi processada" │ ├─ But: Se Step 4 falhou, notification é errada │ └─ Result: Customer confused │ └─ Overall: 60% success rate (failed in multiple places)

COST ANALYSIS: ├─ Per request: $0.005 (5 API calls * $0.001) ├─ Volume: 10K requests/day ├─ Cost/day: $50 ├─ Cost/month: $1500 ├─ Problem: Genérico (not optimized) └─ Result: Expensive for mediocre quality

Critical insight: Seu agente solo é swiss army knife (faz tudo, bem em nada). Multi-agent workflows = especialistas coordenados (cada um expert em seu domínio). Anthropic Dynamic Workflows = solução. Você precisa fazer AGORA.

---

What are Dynamic Workflows? (The solution)

How multi-agent orchestration works

DYNAMIC WORKFLOWS (ANTHROPIC SOLUTION):

Core idea: ├─ Instead of 1 agent doing everything ├─ Use multiple agents (each specialized) ├─ Orchestrate workflow (pipeline of agents) ├─ Each agent focuses on its task └─ Result: Better quality, faster, cheaper

Example architecture (banking scenario):

SINGLE-AGENT (old, bad): ├─ Customer message → [Single Claude Agent] → Response └─ Agent tries to: intent + data + validation + process + notify (fails at all)

MULTI-AGENT WORKFLOW (new, good): ├─ Customer message │ └─ INPUT: "Quero abrir conta poupança e transferir R$ 5000" │ ├─ Agent 1: Intent Classifier (SPECIALIZED) │ ├─ Focus: Classify customer intent ONLY │ ├─ Training: Trained on 10K+ intents (specialized) │ ├─ Accuracy: 98% (vs 90% generic) │ ├─ Output: {intent: "account_opening + transfer", confidence: 0.98} │ └─ Pass to: Agent 2 │ ├─ Agent 2: Data Retrieval (SPECIALIZED) │ ├─ Focus: Fetch customer data from CRM │ ├─ Knowledge: Knows CRM API, database schema │ ├─ Accuracy: 100% (no hallucination, deterministic) │ ├─ Output: {customer_id: "12345", balance: "R$ 50000", accounts: [...]} │ └─ Pass to: Agent 3 │ ├─ Agent 3: Document Validator (SPECIALIZED) │ ├─ Focus: Validate customer documents │ ├─ Knowledge: RG rules, validation algorithms, fraud patterns │ ├─ Accuracy: 99% (trained on document data) │ ├─ Output: {rg_valid: true, rg_verified: "2024-10-15", fraud_risk: 0.01} │ └─ If invalid: Escalate to human (early exit) │ ├─ Agent 4: Policy Checker (SPECIALIZED) │ ├─ Focus: Validate business rules │ ├─ Knowledge: Transfer limits, compliance rules, regulations │ ├─ Accuracy: 100% (rule-based, deterministic) │ ├─ Output: {transfer_allowed: true, limit: "R$ 100000", can_proceed: true} │ └─ If denied: Explain why (policy) │ ├─ Agent 5: Payment Processor (SPECIALIZED) │ ├─ Focus: Execute payment │ ├─ Knowledge: Payment APIs, error handling, rollback │ ├─ Accuracy: 99.99% (payment-grade) │ ├─ Output: {transfer_id: "TXN-123", status: "completed", timestamp: "..."} │ └─ If error: Automatic rollback (safe) │ ├─ Agent 6: Notification Composer (SPECIALIZED) │ ├─ Focus: Compose response for customer │ ├─ Knowledge: Customer communication, tone, templates │ ├─ Accuracy: 95% (good UX) │ ├─ Output: "Sua conta poupança foi aberta! Transferência de R$ 5000 feita com sucesso. ID: TXN-123." │ └─ Send to: Customer │ └─ RESULT: 99% end-to-end success (each step optimized)

KEY DIFFERENCE: ├─ Single agent: 1 agent, 6 tasks, 60% success ├─ Multi-agent: 6 agents, 1 task each, 99% success └─ Result: 65% quality improvement

Technical flow (how workflow orchestration works):

python

Dynamic Workflow Definition (Anthropic)

workflow = DynamicWorkflow(name="banking_account_opening")

Define agents (each specialized)

intent_classifier = Agent( name="intent_classifier", model="claude-opus", system_prompt="You are an expert at classifying customer banking intents...", tools=[] )

data_retriever = Agent( name="data_retriever", model="claude-opus", system_prompt="You are an expert at fetching customer data from CRM...", tools=["get_customer", "get_accounts", "get_balance"] )

doc_validator = Agent( name="doc_validator", model="claude-opus", system_prompt="You are an expert at validating documents...", tools=["validate_rg", "check_fraud_patterns"] )

policy_checker = Agent( name="policy_checker", model="claude-opus", system_prompt="You are an expert at enforcing banking policies...", tools=["check_transfer_limits", "check_compliance"] )

payment_processor = Agent( name="payment_processor", model="claude-opus", system_prompt="You are an expert at processing payments safely...", tools=["execute_transfer", "rollback"] )

notifier = Agent( name="notifier", model="claude-opus", system_prompt="You are an expert at composing customer notifications...", tools=["send_message"] )

Define workflow (orchestration logic)

workflow.add_step(intent_classifier, input="customer_message") workflow.add_step(data_retriever, input="customer_id") workflow.add_step(doc_validator, input="documents") workflow.add_step(policy_checker, input="transfer_request") workflow.add_step(payment_processor, input="validated_request") workflow.add_step(notifier, input="transaction_result")

Conditional logic (if this, then that)

workflow.add_condition( if_agent="doc_validator", if_output="fraud_risk > 0.5", then_action="escalate_to_human" )

workflow.add_condition( if_agent="policy_checker", if_output="can_proceed == false", then_action="send_error_message" )

Execute workflow

result = workflow.execute(customer_message="Quero abrir conta...")

BENEFITS OF DYNAMIC WORKFLOWS:

├─ Quality: 99% (each agent specialized) ├─ Latency: Can parallelize (some agents run concurrently) ├─ Cost: Optimized (each agent only does its task) ├─ Scalability: Horizontal (add more agent instances) ├─ Maintainability: Modular (change one agent, not all) ├─ Debugging: Easy (see which step failed) ├─ Expertise: Deep (each agent is expert) └─ Reliability: High (error handling per agent)

---

Why multi-agent beats single-agent

Comparison: quality, speed, cost

METRIC 1: ACCURACY

Single Agent (generic Claude): ├─ Intent classification: 90% ├─ Data retrieval: 85% ├─ Document validation: 85% ├─ Policy checking: 80% ├─ Payment processing: 90% └─ End-to-end: 0.90 * 0.85 * 0.85 * 0.80 * 0.90 = 52% ❌

Multi-Agent (specialized agents): ├─ Intent classification agent: 98% ├─ Data retrieval agent: 100% (deterministic) ├─ Document validation agent: 99% ├─ Policy checking agent: 100% (rule-based) ├─ Payment processing agent: 99.9% └─ End-to-end: 0.98 * 1.0 * 0.99 * 1.0 * 0.999 = 97% ✓

Improvement: 52% → 97% = +87% (nearly 2x better)

METRIC 2: LATENCY

Single Agent (serial processing): ├─ Intent: 200ms ├─ Data: 300ms ├─ Validate: 250ms ├─ Policy: 200ms ├─ Payment: 500ms ├─ Notify: 150ms └─ Total: 1600ms (serial, one after another) ❌

Multi-Agent (parallel processing): ├─ Intent + Data + Validate (parallel): max(200, 300, 250) = 300ms ├─ Policy (depends on Data): 200ms ├─ Payment (depends on Policy): 500ms ├─ Notify (depends on Payment): 150ms └─ Total: 300 + 200 + 500 + 150 = 1150ms (optimized) ✓

Improvement: 1600ms → 1150ms = -28% (faster)

METRIC 3: COST

Single Agent (wasteful): ├─ Model: claude-opus (expensive, for simple tasks) ├─ Tokens per request: 5000 (doing everything) ├─ Cost per request: $0.005 ├─ Volume: 10K requests/day ├─ Cost/day: $50 ├─ Cost/month: $1500 ❌ (expensive for mediocre quality)

Multi-Agent (optimized): ├─ Intent classifier: claude-haiku (cheap, simple task) = 200 tokens, $0.0002 ├─ Data retriever: deterministic (no LLM needed) = 0 tokens, $0 ├─ Doc validator: claude-sonnet (medium, specialized) = 1000 tokens, $0.001 ├─ Policy checker: rule-based (no LLM) = 0 tokens, $0 ├─ Payment processor: deterministic (no LLM) = 0 tokens, $0 ├─ Notifier: claude-haiku (cheap) = 500 tokens, $0.0005 ├─ Total: 1700 tokens, $0.0015 ├─ Cost per request: $0.0015 ├─ Volume: 10K requests/day ├─ Cost/day: $15 ├─ Cost/month: $450 ✓ (cheaper + better quality!)

Improvement: $1500 → $450 = -70% (way cheaper)

METRIC 4: SCALABILITY

Single Agent: ├─ Capacity: 100 concurrent requests (Claude API limit) ├─ Peak traffic (1000 requests): OVERLOAD (10x capacity) ├─ Response: Timeout (customer gets error) ├─ Solution: Increase Claude API quota (costs more) └─ Problem: Scaling is linear (more money = more compute)

Multi-Agent: ├─ Capacity per agent type: │ ├─ Intent classifier: 1000 concurrent (lightweight model) │ ├─ Data retriever: 10000 concurrent (no model, deterministic) │ ├─ Doc validator: 500 concurrent (heavyweight) │ ├─ Policy checker: 10000 concurrent (no model, rules) │ ├─ Payment processor: 10000 concurrent (deterministic) │ └─ Notifier: 1000 concurrent (lightweight) │ ├─ Bottleneck: Doc validator (500 concurrent) ├─ Peak traffic (1000 requests): 2 instances of doc validator = 1000 concurrent ├─ Response: OK (scales horizontally) └─ Solution: Add more doc validator instances (cheap, specific scaling)

Improvement: Single bottleneck → distributed, scalable

METRIC 5: MAINTAINABILITY

Single Agent: ├─ Problem: Need to improve intent classification accuracy ├─ Action: Change system prompt (affects whole agent) ├─ Risk: Breaks data retrieval, validation, etc (monolith) ├─ Testing: Need to test all 6 tasks (regression risk) ├─ Deployment: All or nothing (risky) └─ Result: Tight coupling, fragile

Multi-Agent: ├─ Problem: Need to improve intent classification accuracy ├─ Action: Improve intent_classifier agent only ├─ Risk: Zero (other agents unaffected) ├─ Testing: Test intent_classifier only (isolated) ├─ Deployment: Update 1 agent, rest unchanged (safe) └─ Result: Loose coupling, modular, safe

BOTTOM LINE:

Single Agent: ├─ Accuracy: 52% ❌ ├─ Latency: 1600ms ❌ ├─ Cost: $1500/month ❌ ├─ Scalability: Limited ❌ ├─ Maintainability: Fragile ❌ └─ Verdict: Not suitable for production

Multi-Agent: ├─ Accuracy: 97% ✓ ├─ Latency: 1150ms ✓ ├─ Cost: $450/month ✓ ├─ Scalability: Excellent ✓ ├─ Maintainability: Modular ✓ └─ Verdict: Production-ready, enterprise-grade

Winner: Multi-Agent (better at EVERYTHING)

---

How to implement Dynamic Workflows (practical guide)

Step-by-step implementation

STEP 1: UNDERSTAND YOUR WORKFLOW (1 hour)

Question: What are the steps your single agent takes? ├─ Example (banking): │ 1. Classify intent (what does customer want?) │ 2. Retrieve data (who is customer?) │ 3. Validate documents (is customer legitimate?) │ 4. Check policies (can we do this?) │ 5. Execute action (process payment/account opening) │ 6. Notify customer (tell them what happened) │ ├─ Your workflow (fill in): │ 1. ___________ │ 2. ___________ │ 3. ___________ │ 4. ___________ │ 5. ___________ │ 6. ___________ │ └─ Output: List of steps (you'll create 1 agent per step)

STEP 2: DESIGN AGENT SPECIALIZATION (2 hours)

For each step, define: ├─ Agent name ├─ What it does (focused task) ├─ What model to use (haiku/sonnet/opus, not always opus) ├─ What tools it has (APIs, databases, deterministic functions) ├─ Success criteria (how do we know it worked?) └─ Error handling (what if it fails?)

Example (intent classification agent): ├─ Name: intent_classifier ├─ Task: Classify customer message into one of 10 intents ├─ Model: claude-haiku (cheap, lightweight task) ├─ Tools: None (just classification) ├─ Success: confidence > 0.9 ├─ Error: confidence < 0.9 → escalate to human └─ Training data: 5000+ examples (fine-tune prompt)

STEP 3: BUILD AGENTS (4 hours)

python

Using Anthropic Managed Agents API

from anthropic import Anthropic

client = Anthropic()

Agent 1: Intent Classifier

intent_classifier = client.agents.create( name="intent_classifier", description="Classifies customer banking intents", instructions="You are an expert at understanding customer banking requests. Classify into: account_opening, transfer, balance_inquiry, etc.", model="claude-3-haiku" )

Agent 2: Data Retriever (deterministic, no need for LLM)

Implement as function (not agent)

def retrieve_customer_data(customer_id): return crm.get_customer(customer_id)

Agent 3: Document Validator

doc_validator = client.agents.create( name="doc_validator", description="Validates customer documents", instructions="You are an expert at validating RG, CPF, and other documents...", model="claude-3-sonnet", tools=[ { "name": "validate_rg", "description": "Validate RG document", "input_schema": {...} }, { "name": "check_fraud_patterns", "description": "Check for fraud patterns", "input_schema": {...} } ] )

... (Agent 4, 5, 6...)

STEP 4: DEFINE WORKFLOW ORCHESTRATION (2 hours)

python

Dynamic Workflow Definition

def create_banking_workflow(): workflow_steps = []

  # Step 1: Classify intent
  step1 = {
      "name": "classify_intent",
      "agent_id": intent_classifier.id,
      "input_source": "customer_message",
      "output_name": "intent"
  }
  workflow_steps.append(step1)

  # Step 2: Retrieve data
  step2 = {
      "name": "get_customer_data",
      "type": "function",  # Not an agent, deterministic
      "function": retrieve_customer_data,
      "input_source": "customer_id",  # From initial request
      "output_name": "customer_data"
  }
  workflow_steps.append(step2)

  # Step 3: Validate documents
  step3 = {
      "name": "validate_docs",
      "agent_id": doc_validator.id,
      "input_source": ["customer_data", "documents"],
      "output_name": "validation_result",
      "error_handling": {
          "if_fraud_risk_high": "escalate_to_human"
      }
  }
  workflow_steps.append(step3)

  # ... (More steps)

  return workflow_steps

Execute workflow

def execute_workflow(customer_message, customer_id, documents): workflow = create_banking_workflow()

  # Store results
  results = {}
  
  for step in workflow:
      if step["type"] == "agent":
          # Call Anthropic agent
          response = client.agents.invoke(
              agent_id=step["agent_id"],
              input=get_step_input(step, results)
          )
          results[step["output_name"]] = response
      else:  # function
          # Call deterministic function
          output = step["function"](*get_step_input(step, results))
          results[step["output_name"]] = output

      # Check for errors
      if has_error(results[step["output_name"]]):
          handle_error(step, results)
          break  # Stop workflow
  
  return results

STEP 5: TEST & ITERATE (2 hours)

python

Test workflow

test_cases = [ { "name": "Happy path (account opening)", "input": "Quero abrir conta poupança", "expected": "account_opened", "success": True }, { "name": "Fraud detection", "input": "Quero abrir conta com RG fake", "expected": "escalated_to_human", "success": True }, { "name": "Policy violation", "input": "Quero transferir R$ 1 milhão (acima do limite)", "expected": "transfer_denied", "success": True } ]

for test in test_cases: result = execute_workflow( customer_message=test["input"], customer_id="12345", documents=[] )

  if result["final_status"] == test["expected"]:
      print(f"✓ {test['name']}")
  else:
      print(f"✗ {test['name']} (got {result['final_status']})")

STEP 6: DEPLOY (1 hour)

├─ Deploy workflow (Anthropic API, production) ├─ Monitor (logs, errors, latency) ├─ Iterate (improve agents based on real data) └─ Scale (add more agent instances as needed)

---

Real-world results (what to expect)

Before vs after metrics

METRIC 1: ACCURACY (success rate)

Before (single agent): 52% After (multi-agent): 97% Improvement: +87%

Real impact: ├─ 100 customer requests ├─ Before: 52 succeed, 48 fail (escalated to human) ├─ After: 97 succeed, 3 fail (mostly fraud detection) ├─ Human escalation: 48 → 3 (94% reduction) └─ Cost: Massive savings (humans not needed)

METRIC 2: LATENCY (response time)

Before (single agent): 1600ms After (multi-agent): 1150ms Improvement: -28% (faster)

Real impact: ├─ Customer perceives: Less waiting ├─ UX: Better (snappier) ├─ Satisfaction: Higher ├─ Churn: Lower (customers prefer fast agents) └─ Competitive: You're faster than competitors

METRIC 3: COST (operational cost)

Before (single agent): $1500/month (10K requests/day) After (multi-agent): $450/month Improvement: -70% (way cheaper!)

Real impact: ├─ Margins: Better ├─ Profitability: Higher ├─ Pricing: Can be more competitive ├─ Volume: Can handle 3x more requests for same cost └─ ROI: Payback in <1 month

METRIC 4: QUALITY OF RESPONSES

Before: Generic, mediocre advice (agent doesn't specialize) After: Expert-level advice (each agent is specialist)

Example: ├─ Before: "Você pode transferir, acho..." ├─ After: "Você pode transferir até R$ 100.000/dia. Seu saldo permite R$ 5.000. Processando..." └─ Difference: Confidence, specificity, accuracy

METRIC 5: RELIABILITY (errors, failures)

Before: Cascading failures (one step fails → whole workflow fails) After: Graceful degradation (one agent fails → skip/escalate, continue)

Example: ├─ Before: Payment API timeout → whole agent fails → customer error ├─ After: Payment agent has retry logic → escalates to human → customer gets help └─ Difference: Reliability, customer experience

METRIC 6: COMPLIANCE & RISK

Before: Low (agent might violate policies) After: High (rule-based policy agent enforces compliance)

Example: ├─ Before: Agent transfers beyond customer limit (oops!) ├─ After: Policy agent blocks transfer, explains why └─ Difference: Regulatory compliance, avoided fines

---

Conclusão: Multi-agent workflows são o futuro

Fatos:

✓ Single agent = generalist (mediocre at everything) ✓ Multi-agent = specialists (expert at tasks) ✓ Anthropic Dynamic Workflows = solution (just announced) ✓ Quality improvement = 52% → 97% (+87%) ✓ Cost improvement = $1500 → $450 (-70%) ✓ Latency = faster (parallel processing) ✓ Scalability = horizontal (modular) ✓ Maintainability = modular (safe changes) ✓ Message: "Your single agent is obsolete. Multi-agent workflows are the future. Anthropic showed the way. Move NOW or get left behind."

ACTION ITEMS (THIS MONTH):

1. TODAY: Analyze your current agente workflow (what steps?)
2. TODAY: Identify 3-5 agent specializations (intent, validation, processing, etc)
3. TOMORROW: Check Anthropic Dynamic Workflows docs (new feature)
4. TOMORROW: Check if your current setup can support multi-agent
5. NEXT WEEK: Design multi-agent architecture
6. NEXT WEEK: Build agents (one by one)
7. WEEK 3: Implement workflow orchestration
8. WEEK 3: Test and measure improvement
9. WEEK 4: Deploy to production
10. WEEK 4: Monitor and optimize
11. MONTH 2: Scale (add more agents/specializations)

Problem resolved when: └─ Accuracy = 97% (vs 52%) └─ Cost = 70% lower └─ Latency = faster └─ Quality = expert-level └─ Scalability = horizontal └─ Reliability = high └─ Result: Multi-agent workflows live, performance massively improved

→ OpenClaw: Dynamic Workflows para Seu Agente WhatsApp (Multi-Agent Architecture)

Seu agente single é swiss army knife (faz tudo, bem em nada). Multi-agent workflows (Anthropic Dynamic Workflows) = especialistas coordenados. Qualidade 97% (vs 52%). Custo -70%. Latência melhor. Escalável horizontalmente. Anthropic anunciou a solução. Você precisa implementar AGORA (este mês, não próximo trimestre). Seus competitors já estão se movendo. Move HOJE. 🚀⚡