Program-of-Thought: Como Modelos Pequenos Superam Modelos Grandes

O prompting Chain-of-Thought (CoT) revolucionou a forma como os modelos de linguagem resolvem problemas complexos fazendo-os “pensar passo a passo”. Mas há uma falha fundamental: modelos de linguagem são terríveis em aritmética.

Entre Program-of-Thought (PoT) — uma técnica que atinge desempenho 12-15% melhor que Chain-of-Thought fazendo algo surpreendentemente simples: deixar os modelos escreverem código em vez de fazer matemática.

A Perspectiva Central

O artigo inovador “Program of Thoughts Prompting: Disentangling Computation from Reasoning“ revela uma perspectiva crítica: raciocínio e computação são habilidades diferentes.

Modelos de linguagem se destacam em:

• Compreender problemas
• Planejar estratégias de solução
• Expressar lógica em código

Modelos de linguagem têm dificuldade com:

• Aritmética de múltiplos dígitos
• Manter precisão através de etapas de cálculo
• Evitar erros acumulados

PoT separa essas preocupações: modelos fazem o raciocínio e escrevem código Python, enquanto um runtime determinístico (como unsandbox) executa os cálculos perfeitamente.

Chain-of-Thought vs Program-of-Thought

Chain-of-Thought (CoT)

Pergunta: Uma loja tinha 20 maçãs. Venderam 8, receberam mais 15,
depois venderam 12. Quantas maçãs restam?

Resposta CoT:
Deixe-me pensar passo a passo:
1. Começar com 20 maçãs
2. Depois de vender 8: 20 - 8 = 12 maçãs
3. Depois de receber 15: 12 + 15 = 27 maçãs
4. Depois de vender 12: 27 - 12 = 15 maçãs

Resposta: 15 maçãs

Problema: O modelo deve realizar aritmética e raciocínio. Pequenos erros se acumulam.

Program-of-Thought (PoT)

# Pergunta: Uma loja tinha 20 maçãs. Venderam 8, receberam mais 15,
# depois venderam 12. Quantas maçãs restam?

def solve():
    apples = 20
    apples -= 8  # Sold 8
    apples += 15  # Received 15
    apples -= 12  # Sold 12
    return apples

result = solve()
print(f"Remaining apples: {result}")

Execução (via unsandbox):

Remaining apples: 15

O modelo se concentra puramente em compreender e traduzir para código. O cálculo é delegado ao Python.

Por Que Isso Faz Modelos Pequenos Baterem Acima de Seu Peso

Aqui é onde fica emocionante para implantações práticas:

1. Modelos Quantizados Se Tornam Viáveis

Um modelo Llama 3.1 8B quantizado em 4 bits rodando localmente agora pode superar o GPT-4 em problemas matemáticos — não porque seja melhor em raciocínio, mas porque não precisa ser bom em aritmética.

# Até um modelo fortemente quantizado pode escrever isso corretamente:
def compound_interest(principal, rate, years):
    return principal * (1 + rate) ** years

# unsandbox executa com precisão perfeita

2. Inferência Mais Rápida, Custos Mais Baixos

Respostas PoT são tipicamente mais curtas que respostas CoT:

• CoT: ~500 tokens (mostrando todas as etapas de cálculo)
• PoT: ~150 tokens (apenas o código)

Economia de custos: 70% menos tokens de saída × modelos pequenos mais baratos = redução de custos de 10-20x

3. Resultados Determinísticos e Auditáveis

Diferente do CoT onde o modelo pode calcular 127 × 43 de forma diferente cada vez, PoT produz:

result = 127 * 43  # Sempre 5461, toda vez
print(result)

Isso é crítico para aplicações financeiras, científicas e de saúde onde a reprodutibilidade importa.

Exemplo do Mundo Real: Análise Financeira

Tarefa: Calcular a taxa interna de retorno (TIR) para uma série de fluxos de caixa.

Abordagem CoT (GPT-4):

Vamos calcular a TIR usando tentativa e erro...
Tentar r = 0.10: VPL = -$234.52
Tentar r = 0.12: VPL = $45.23
Tentar r = 0.115: VPL = -$12.34
...
[Modelo tem dificuldades com métodos numéricos iterativos]

Resultado: Incorreto ou “Não consigo calcular isso com precisão”

Abordagem PoT (Llama 3.1 8B + unsandbox):

import numpy_financial as npf

def calculate_irr(cash_flows):
    """
    Calculate internal rate of return for cash flows
    cash_flows: list of cash flows, first element is initial investment (negative)
    """
    return npf.irr(cash_flows)

# Cash flows: -$1000 investment, then $300, $400, $500 returns
cash_flows = [-1000, 300, 400, 500]
irr = calculate_irr(cash_flows)

print(f"IRR: {irr:.2%}")

Resultado: IRR: 8.90% (matematicamente correto, toda vez)

Como unsandbox Habilita PoT em Escala

unsandbox é projetado especificamente para fluxos de trabalho Program-of-Thought:

1. Execução Zero-Trust

# Código do usuário roda em contêiner isolado
# Sem acesso ao sistema de arquivos, rede ou outros processos
# Limites automáticos de recursos previnem cálculos descontrolados

2. Suporte para mais de 42 Linguagens

Nem todos os modelos são melhores em Python. Alguns se destacam em:

• Julia para computação numérica
• R para análise estatística
• JavaScript para manipulação JSON
• Rust para cálculos críticos de desempenho

curl https://api.unsandbox.com/execute \
  -H "Authorization: Bearer unsb-sk-xxxxx-xxxxx-xxxxx-xxxxx" \
  -d '{
    "language": "julia",
    "code": "# Your Julia code here"
  }'

3. Execução em Menos de um Segundo

Latência média do fluxo de trabalho PoT:
- Modelo gera código: ~800ms
- unsandbox executa código: ~150ms
- Total: <1 segundo

Compare com CoT:
- Modelo gera raciocínio: ~2000ms
- Ainda pode estar errado

4. Decodificação de Auto-Consistência

Execute o mesmo prompt PoT 5 vezes, execute todas as amostras de código, retorne o resultado mais comum:

# Example: Self-consistency with voting
# Run multiple code samples and pick the most common result

results = []

# Sample 1
def solve1(): return 42 * 1.15
results.append(solve1())

# Sample 2
def solve2(): return 42 * 1.15
results.append(solve2())

# Sample 3 would fail: def solve3(): return 42 × 1.15  # Syntax error

# Sample 4
def solve4(): return 42 * 1.15
results.append(solve4())

# Sample 5 (model error)
def solve5(): return 42 * 1.51
results.append(solve5())

# Find consensus (most common result)
from collections import Counter
consensus = Counter(results).most_common(1)[0][0]
print(f"Consensus result: {consensus:.1f}")
# Output: Consensus result: 48.3

Resultado: Mesmo com erros ocasionais do modelo, votação por consenso + execução de código produz respostas corretas.

Padrões de Implementação

Aqui está um fluxo de trabalho PoT completo que funciona com qualquer modelo + unsandbox:

Guia de Seleção de Modelo

Modelos API (hospedados, pagamento por token):

• GPT-4.1 Nano: $0.10/1M entrada, $0.40/1M saída - A opção mais barata de todas
• GPT-4.1 Mini: $0.40/1M entrada, $1.60/1M saída - Melhor equilíbrio, contexto de 1M
• GPT-4o Mini: $0.00015/1K entrada, $0.0006/1K saída - OpenAI legacy

Modelos Locais (auto-hospedados, zero custos de API):

• Qwen 3 Coder 30B: Melhor precisão, precisa RTX 4090/3090 (24GB VRAM)
• Hermes-3-Llama-3.1-8B: Excelente seguimento de instruções, RTX 4090/3090

Implementação Universal

O padrão é idêntico para todos os modelos — apenas o endpoint do modelo muda:

import requests
from openai import OpenAI  # For API models, or use requests for local

# ===== CONFIGURATION: Choose your model =====
# All models use OpenAI-compatible /v1 endpoints - just change base_url!

# Option 1: OpenAI API models
BASE_URL = "https://api.openai.com/v1"
MODEL_NAME = "gpt-4.1-nano"  # or "gpt-4.1-mini" or "gpt-4o-mini"
API_KEY = "YOUR_OPENAI_KEY"

# Option 2: Free uncloseai.com - Hermes 8B (tested, works!)
# BASE_URL = "https://hermes.ai.unturf.com/v1"
# MODEL_NAME = "adamo1139/Hermes-3-Llama-3.1-8B-FP8-Dynamic"
# API_KEY = "not-needed"

# Option 3: Free uncloseai.com - Qwen Coder 30B (tested, works!)
# BASE_URL = "https://qwen.ai.unturf.com/v1"
# MODEL_NAME = "hf.co/unsloth/Qwen3-Coder-30B-A3B-Instruct-GGUF:Q4_K_M"
# API_KEY = "not-needed"

# Option 4: Local Ollama (port 11434)
# BASE_URL = "http://localhost:11434/v1"
# MODEL_NAME = "qwen3-coder:30b-q4"
# API_KEY = "ollama"

# Option 5: Local vLLM (port 18888)
# BASE_URL = "http://localhost:18888/v1"
# MODEL_NAME = "adamo1139/Hermes-3-Llama-3.1-8B-FP8-Dynamic"
# API_KEY = "token-abc123"

# unsandbox API key (get free key at unsandbox.com)
UNSANDBOX_KEY = "unsb-sk-xxxxx-xxxxx-xxxxx-xxxxx"

# ===== STEP 1: Generate Code =====
# Same code works for ALL models - just change base_url above!
problem = """Solve this problem by writing Python code.
Output ONLY the code, no explanations.

Problem: A company's revenue grew 15% annually for 3 years,
starting from $1.2M. What's the revenue in year 3?"""

client = OpenAI(api_key=API_KEY, base_url=BASE_URL)
response = client.chat.completions.create(
    model=MODEL_NAME,
    max_tokens=2048,
    messages=[{"role": "user", "content": problem}]
)
code = response.choices[0].message.content

# ===== STEP 2: Execute via unsandbox =====
exec_response = requests.post(
    "https://api.unsandbox.com/execute",
    headers={"Authorization": f"Bearer {UNSANDBOX_KEY}"},
    json={"language": "python", "code": code, "timeout": 5}
)

result = exec_response.json()
print(result["stdout"])  # $1,825,305.00

Análise de Custos por Modelo

Nota: unsandbox custa $0.000023 por requisição para todos os planos (Dev, Production, Business) - você paga mais por limites de taxa mais altos, não por preços por requisição.

Níveis de preços unsandbox (custo por requisição em utilização total):

Perspectiva chave: Modelos locais eliminam completamente os custos de API — você paga apenas pela execução unsandbox ($0.000023/consulta).

Benchmarks: Modelos Pequenos vs Modelos Grandes

A pesquisa do artigo PoT mostra melhorias dramáticas:

Perspectiva chave: A melhoria é maior em problemas mais difíceis onde aritmética de múltiplas etapas acumula erros.

Por Que PoT Funciona com Modelos Modernos (2025)

A pesquisa original usou modelos da era GPT-3, mas a técnica é ainda mais poderosa hoje:

• Modelos locais menores (Qwen 3 Coder 30B, Hermes-3-Llama-3.1-8B) podem gerar código Python correto
• Execução de código via unsandbox elimina completamente erros aritméticos
• Custo dramaticamente menor: Modelos locais + unsandbox (~$0.000023/consulta) vs API GPT-4 ($0.02-0.05/consulta)
• Privacidade preservada: Geração de código acontece localmente, apenas execução vai para unsandbox

A perspectiva chave: você não precisa de um modelo massivo para escrever código correto - você só precisa que ele entenda o problema e expresse a lógica. O cálculo real é tratado pelo Python, que nunca comete erros.

Velocidade: Modelos Quantizados Menores São Mais Rápidos

Aqui está a parte contraintuitiva: modelos quantizados te dão respostas corretas mais rápido que modelos API grandes.

Comparação de Latência (Mesmo Problema)

Por que modelos quantizados são mais rápidos:

1. Pegada de memória menor → geração de token mais rápida (Q4/FP8 roda inteiramente no cache da GPU)
2. Saídas mais curtas → Código é mais conciso que explicações aritméticas passo a passo
3. Sem latência de API → Inferência local elimina viagens de ida e volta pela rede
4. Execução paralela → unsandbox pode executar múltiplos trechos de código simultaneamente

Impacto no mundo real:

Processando 100 problemas matemáticos:

GPT-4 CoT:       100 × 3,500ms = 350 segundos (5,8 minutos)
Hermes-3 FP8 PoT: 100 × 550ms = 55 segundos (< 1 minuto)

Você obtém respostas corretas 6× mais rápido a 1/200 do custo usando um modelo quantizado em uma GPU consumidor.

Além da Matemática: Outras Aplicações PoT

1. Análise de Dados

# Model generates pandas code for business intelligence queries
import pandas as pd

df = pd.read_csv('sales_data.csv')
monthly_revenue = df.groupby(df['date'].dt.month)['revenue'].sum()
growth_rate = monthly_revenue.pct_change().mean()

print(f"Average monthly growth: {growth_rate:.2%}")

2. Computação Científica

# Physics simulations the model can't do in its "head"
import numpy as np
from scipy.integrate import odeint

def projectile_motion(state, t, g=9.81):
    x, vx, y, vy = state
    return [vx, 0, vy, -g]

# Solve trajectory
solution = odeint(projectile_motion, [0, 10, 0, 15], np.linspace(0, 3, 100))
max_height = solution[:, 2].max()
print(f"Max height: {max_height:.2f} meters")

3. Manipulação de Strings

# Complex regex/parsing that models hallucinate
import re

def extract_emails(text):
    pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
    return re.findall(pattern, text)

text = "Contact us at hello@example.com or support@test.org for help"
emails = extract_emails(text)
print(f"Found {len(emails)} emails: {emails}")
# Output: Found 2 emails: ['hello@example.com', 'support@test.org']

A Economia do PoT

Para uma empresa processando 1M consultas/mês:

CoT Tradicional com GPT-4:

• Entrada: 500 tokens × $0.01/1K = $5,000
• Saída: 800 tokens × $0.03/1K = $24,000
• Total: $29,000/mês

PoT com Qwen 3 Coder 30B (Q4_K_M) + unsandbox:

• Modelo (auto-hospedado em RTX 4090): ~$0/mês (você já possui a GPU)
• Entrada: 500 tokens × $0.00 = $0
• Saída: 200 tokens × $0.00 = $0
• Execução unsandbox: 1M × $0.000023 = $23/mês
• Total: $23/mês

Economia: $28,977/mês (99,9% de redução de custos)

Além disso:

• 3x mais rápido (modelo menor + saída mais curta)
• Mais preciso em tarefas numéricas
• Resultados determinísticos
• Privacidade completa (rodar modelos localmente)

Dicas de Implementação

1. Template de Prompt de Sistema

You are a mathematical reasoning assistant.
When solving problems:
1. Write Python code to solve the problem
2. Use descriptive variable names
3. Add comments explaining your logic
4. Output ONLY executable code
5. End with a print() statement showing the result

DO NOT:
- Show arithmetic in comments
- Explain your reasoning in natural language
- Approximate or estimate - write exact calculations

2. Auto-Correção com Feedback stderr/stdout

A funcionalidade matadora: unsandbox retorna tanto stdout quanto stderr, habilitando auto-correção automática:

def solve_with_retry(problem, model_client, max_retries=3):
    """
    Generate code, execute it, and retry with error feedback if it fails.
    """
    for attempt in range(max_retries):
        # Step 1: Generate code
        response = model_client.chat.completions.create(
            model="gpt-4.1-nano",
            max_tokens=2048,
            messages=[{
                "role": "user",
                "content": f"Solve this problem by writing Python code.\nOutput ONLY the code.\n\n{problem}"
            }]
        )

        code = response.choices[0].message.content

        # Step 2: Execute via unsandbox
        result = requests.post(
            "https://api.unsandbox.com/execute",
            headers={"Authorization": "Bearer unsb-sk-xxxx"},
            json={"language": "python", "code": code, "timeout": 5}
        ).json()

        # Step 3: Check for errors
        if result.get("stderr") == "" and result.get("stdout"):
            # Success!
            return result["stdout"]

        # Step 4: Retry with error feedback
        error_msg = result.get("stderr", "No output produced")
        problem = f"""
Previous attempt failed with error:
{error_msg}

Failed code:
{code}

Original problem: {problem}

Fix the syntax or logic error and write corrected Python code.
"""

    return None  # Failed after max retries

Exemplo real:

Tentativa 1: Modelo escreve `printt(result)` → stderr: "NameError: name 'printt' is not defined"
Tentativa 2: Modelo corrige o erro de digitação → `print(result)` → Sucesso!

Isso melhora drasticamente a precisão para modelos menores que ocasionalmente cometem erros de sintaxe.

3. Validação

# Run simple assertion tests
def validate_solution(code, expected_properties):
    result = execute_code_via_unsandbox(code)

    assert isinstance(result, (int, float)), "Result must be numeric"
    assert result > 0, "Result must be positive"
    assert result < 1_000_000, "Result seems unreasonably large"

    return result

Limitações e Direções Futuras

Limitações Atuais

1. Qualidade de Geração de Código: Modelos pequenos às vezes geram código sintaticamente incorreto

   • Solução: Votação multi-amostra, lógica de retry ou fine-tuning do modelo

2. Compreensão do Problema: Modelos podem interpretar mal questões ambíguas

   • Solução: Clarificação de prompt, exemplos few-shot

3. Algoritmos Complexos: Modelos têm dificuldade com desafios algorítmicos novos

   • Solução: Fornecer funções de biblioteca, dividir em sub-problemas

O Futuro: Chain-of-Code

Pesquisa emergente mostra resultados ainda melhores com abordagens híbridas:

# Step 1: Natural language reasoning
# "I need to find the compound annual growth rate..."

# Step 2: Code for calculations
def cagr(start_value, end_value, years):
    return (end_value / start_value) ** (1 / years) - 1

# Step 3: Natural language interpretation
# "A CAGR of 12.5% means the investment grew by about 12.5% per year"

Isso combina os pontos fortes de ambas as abordagens.

Experimente Você Mesmo

Início Rápido com unsandbox:

1. Obtenha uma chave API gratuita: unsandbox.com

2. Execute sua primeira consulta PoT:

   curl https://api.unsandbox.com/execute \
   -H "Authorization: Bearer YOUR_KEY" \
   -H "Content-Type: application/json" \
   -d '{
    "language": "python",
    "code": "def compound_growth(principal, rate, years):\n    return principal * (1 + rate) ** years\n\nresult = compound_growth(10000, 0.07, 10)\nprint(f\"Final value: ${result:,.2f}\")"
   }'

3. Integre com seu LLM:

   # See full example in our docs:
   # https://unsandbox.com/docs/python

Prompts de Exemplo

Experimente estes com seu modelo preferido + unsandbox:

1. Finanças: “Calculate the present value of receiving $10,000 annually for 20 years at a 5% discount rate”

2. Estatísticas: “Generate 1000 random samples from a normal distribution with mean=100, std=15. What percentage fall between 85 and 115?”

3. Física: “A ball is thrown at 20 m/s at a 45° angle. How far does it travel before hitting the ground?”

Conclusão

Program-of-Thought representa uma mudança de paradigma: pare de pedir aos modelos para fazer matemática; peça para escreverem código.

As implicações são profundas:

• Modelos menores se tornam viáveis para produção
• Modelos quantizados igualam ou excedem o desempenho de modelos grandes
• Custos caem em 90-99%
• Resultados se tornam determinísticos e auditáveis
• Implantação local é prática (não são necessárias GPUs massivas)

Com unsandbox fornecendo execução de código segura e rápida em mais de 42 linguagens, PoT não é mais uma técnica de pesquisa — é uma estratégia pronta para produção para construir sistemas de IA precisos e acessíveis.

O futuro não são modelos maiores. É arquitetura mais inteligente.

Recursos:

• Original PoT Paper
• unsandbox API Documentation
• Pricing for Agents
• 42+ Supported Languages

Experimente Program-of-Thought: Obtenha uma chave API gratuita em unsandbox.com — 1 requisição a cada 42 segundos, perfeito para experimentação.