strata

Seu agente escreve o backend. A Strata prova que ele funciona.

Um servidor MCP que compõe módulos de backend verificados no seu código — lendo seu schema, seguindo suas convenções, conectando-os na ordem que o Express realmente exige — e então escreve um comando que inicia o aplicativo e exercita cada requisito contra um servidor ativo.

$ # your agent calls one tool, once
  strata_use  dir=./shop-api  task="product list API"
              capabilities=[ "cursor pagination with sorting",
                             "per-IP rate limiting",
                             "structured request logging" ]

  FILES CREATED
    server.js
    strata/lib.js       — the implementation these import from
    strata/verify.js    — boots the app and exercises the feature end to end

$ npm install && node strata/verify.js

  PASS  unit selftests — 3 passed, 0 failed
  PASS  server boots and answers /health
  PASS  correlation id honours an inbound x-request-id
  PASS  an authorization header is NOT written to the log
  PASS  a password in a request BODY is NOT written to the log
  PASS  a malformed body is a 4xx and leaks no stack trace to the caller
  PASS  /items walks pages by cursor without repeating a row
  PASS  a sort field that is not allowlisted is REJECTED, not honoured
  PASS  a burst past capacity yields 429 + Retry-After

  12/12 checks passed — the delivered feature works end to end.

Principais capacidades

• Composição ciente do schema — lê Prisma, Mongoose, Drizzle, TypeORM, Sequelize ou JS puro e conecta módulos à sua entidade real, campos e coluna de ID
• Ordenação correta de middleware — logging acima do parsing de corpo, rate limits acima das rotas, handlers de erro por último, imposta por classificação em vez de deixada ao modelo
• Verificador ponta a ponta gerado — strata/verify.js inicia o aplicativo em uma porta livre e exercita cada requisito contra ele
• Seis portões de admissão verificados por máquina — nenhum módulo chega ao seu projeto sem passar por todos eles
• Recusas honestas — recusa aproximadamente um terço das tarefas, onde compor custa mais do que escrever o código

$ # asked for something the library does not cover
  strata_use  task="slugify helper"  capabilities=["convert a string to a url slug"]

  No verified Strata recall covers "slugify helper". Build it from scratch the
  normal way — a clean hand-written implementation is the right outcome here,
  not a forced match.

• Local por construção — seu código-fonte e schema nunca saem da máquina; apenas o texto da tarefa é enviado

Os números

Uma tarefa de backend — uma API de produtos com paginação, rate limiting por IP e logging de requisições. Claude Haiku 4.5, três execuções por braço, média. Cada número é menor e a qualidade é maior.

Tokens são a sessão inteira: entrada, saída e o contexto em cache relido a cada turno. Em todas as 18 execuções desta bateria, 98–99% dos tokens de uma sessão são esse contexto relido — a saída é menos de 2%. Portanto, o comprimento da saída não é a alavanca; turnos são, e menos turnos é o mesmo que menos tokens é o mesmo que menos dinheiro.

O que as verificações falhas realmente eram

Uma pontuação é fácil de descartar. Estas são as falhas em si, reavaliadas a partir das árvores arquivadas. Cada uma é código que roda, responde 200-ou-201 e parece concluído.

Uma requisição malformada retorna seu stack trace

Uma requisição com corpo truncado. Ambos os aplicativos responderam 400 — apenas um deles é seguro.

<!DOCTYPE html>
<html lang="en"><head><title>Error</title></head>
<body>
<pre>SyntaxError: Unexpected end of JSON input
    at JSON.parse (&lt;anonymous&gt;)
    at parse (C:\Users\...\node_modules\body-parser
              \lib\types\json.js:96:19)
    at C:\Users\...\body-parser\lib\read.js:128:18
    at AsyncResource.runInAsyncScope (node:async_...

{
  "error": "malformed JSON in request body",
  "details": [
    { "field": "body",
      "message": "could not be parsed as JSON" }
  ]
}

Falhou em 6 de 6 execuções sem auxílio, em ambas as tarefas. Passou em 6 de 6 com Strata. O avaliador registra como LEAKS STACK TRACE; nada na saída da própria sessão menciona isso.

Um pedido repetido com corpo diferente foi aceito mesmo assim

POST /orders   Idempotency-Key: k-1   {"items":[ A ]}   →   201 Created
POST /orders   Idempotency-Key: k-1   {"items":[ B ]}   →   200 OK   ← order A returned

Essa é a metade sutil da idempotência, e a metade que uma implementação ingênua perde completamente. O cliente pediu um pedido diferente e foi informado de que sua requisição foi bem-sucedida. Nada gera erro, nada registra log. O Pedido B simplesmente nunca existe, e o chamador segura um 200 dizendo que existe. A resposta correta é 409 ou 422.

Falhou em 3 de 3 execuções sem auxílio. Passou em 3 de 3 com Strata.

A API ignorou o tamanho de página solicitado

GET /products?limit=5   →   200 OK, 10 items

Paginação que retorna o que bem entende. Nada gera erro, nada registra log, e o bug chega a quem consome esse endpoint. Uma execução sem auxílio em três.

O schema do banco de dados foi editado, sem ser pedido

A tarefa era "se um cliente repetir a mesma requisição de pedido, não deve criar dois pedidos." Nunca menciona o modelo de dados. Uma execução sem auxílio em três reescreveu prisma/schema.prisma; nenhuma execução com Strata tocou nele.

O problema mais amplo é que você não pode prever quais arquivos voltam alterados. Em três execuções do mesmo prompt, o braço sem auxílio tocou seis arquivos diferentes — e apenas três deles em todas as execuções. Strata tocou os mesmos dez arquivos nas três execuções: uma pegada idêntica, execução após execução.

Execute três vezes. Obtenha a mesma resposta três vezes.

Zero variância nas tarefas que a biblioteca cobre. Três execuções do mesmo prompt retornam a mesma pontuação, três vezes em três — contra uma dispersão de 26,9 pontos sem ela.

Esse 14% não é um artefato de avaliação; ele se repete na reavaliação. Essa sessão inventou uma API de pedidos cujo endpoint de criação rejeitou todas as formas de requisição que recebeu, e como tudo o mais depende da criação de um pedido, cinco verificações colapsaram de uma vez. Um precipício, não um resultado ligeiramente pior — e nada na saída da própria sessão diz que isso aconteceu.

Onde não ajuda

Pagamentos está no quadro com suas falhas intactas. Ambos os braços entregaram um build que não roda: uma execução sem auxílio nunca escreveu um ponto de entrada, e uma execução com Strata fixou bullmq@5.81.3 ao lado de um redis@4.7.1 incompatível, que não pode ser instalado. Ambos os pacotes são escolha do modelo — Strata cobre o webhook e nada mais nessa tarefa, e a proporção de custo fica em 0,95×, um empate.

Essa é a regra que todo o quadro obedece: a vantagem acompanha o quanto da tarefa a biblioteca cobre. Onde a cobertura é alta, os números acima se mantêm. Onde é uma capacidade entre quatro, Strata é aproximadamente grátis e aproximadamente neutra.

Strata também recusa diretamente quando uma tarefa está abaixo do ponto em que compor supera escrever — cerca de um terço das vezes.

Método

As verificações foram escritas a partir do prompt da tarefa sozinho e congeladas antes da primeira execução. Cada verificação tem um controle negativo provando que pode falhar. A avaliação é uma suíte separada — nunca strata/verify.js, que Strata gera e que estaria marcando seu próprio trabalho. Cada árvore de saída é arquivada.

n=3, Claude Haiku 4.5, um modelo por célula. Nada aqui fala sobre Sonnet ou Opus. Os números de custo e tokens mudam com o modelo e o prompt; os números de consistência não mudam.

Método completo, pontuações por execução e cada defeito de instrumento encontrado no caminho: docs/BENCHMARK.md.

Início rápido

Pré-requisitos: Node.js ≥ 18 e qualquer cliente MCP — Claude Code, Cursor, Windsurf, VS Code ou Claude Desktop.

// .mcp.json  (or claude_desktop_config.json for Claude Desktop)
{
  "mcpServers": {
    "strata": { "command": "npx", "args": ["-y", "stratalib"] }
  }
}

Reinicie o cliente e peça um recurso de backend que precise de várias partes:

Add cursor pagination, per-IP rate limiting and request logging to the products API.

Strata lê o projeto, compõe os módulos, escreve os arquivos e imprime o que criou e o que modificou. Então:

npm install && node strata/verify.js

[!NOTE] Sem chave de API e sem conta. Os módulos são servidos do hub; o texto da tarefa é a única coisa enviada. Seu código-fonte, schema e arquivos permanecem na sua máquina.

A ferramenta

Strata registra exatamente uma ferramenta. Cada ferramenta em um schema MCP é cobrada a cada turno, então a superfície é mantida em uma que faz todo o trabalho.

strata_use

Retorna os arquivos criados e modificados, as exportações disponíveis de cada módulo e o comando para verificar o resultado.

Como funciona

1 · Lê o projeto — localiza o ORM e extrai a entidade real: campos, tipos, enums e a coluna de ID real. Determinístico, em Node, antes de o modelo ver um byte. Onde a entidade não pode ser identificada com confiança, Strata deixa um slot em vez de adivinhar.

2 · Seleciona módulos — cada frase de capacidade é pontuada contra a biblioteca, e qualquer correspondência apenas por vocabulário compartilhado é descartada. Menos de dois módulos sobreviventes acionam uma recusa.

3 · Compõe — módulos contribuem para o aplicativo em vez de possuí-lo, cada contribuição carregando uma classificação que fixa sua posição na cadeia de middleware. Uma requisição malformada lança erro durante o parsing de corpo, então o logging monta acima dele; inverta isso e a requisição mais digna de rastreamento é a que perde seu id de correlação.

4 · Escreve o verificador — strata/verify.js executa a suíte de cada módulo, inicia o aplicativo em uma porta livre e exercita cada requisito contra ele. Construído contra sua entidade, então as verificações rodam em seus campos e suas rotas.

Portões de admissão

Cada módulo passa por seis portões verificados por máquina antes de poder ser servido. Um módulo que falha é descartado, não reparado — corrigir manualmente módulos gerados retorna a cobertura ao artesanato e impede que ela escale.

O portão adversarial é o que importa. Cada módulo escrito à mão nesta biblioteca foi lançado com um bug real que seus próprios testes não pegaram — um 404 que resetava a contagem de falhas de um circuit breaker, uma restrição de enum descartada, um id de requisição controlado por atacante ecoado em um cabeçalho de resposta. Uma suíte confirmatória admite exatamente esses.

Layout do repositório

Os módulos são servidos do hub; o texto da tarefa é a única coisa enviada. Seu código-fonte, schema e arquivos permanecem na sua máquina.

Documentação

Desenvolvimento

npm install
node --max-old-space-size=8192 node_modules/typescript/bin/tsc -p tsconfig.mcp.json   # build
node scripts/admit-recall.js recalls/<domain>/<name>/v1                                # run the gates
node benchmark/quality/negative-control.js                                             # prove the checks can fail
node benchmark/run-quality-battery.js --tasks catalog --max 3                           # collect runs

STRATA_MODE=local compõe contra um checkout local do recalls/ em vez do hub — necessário ao testar um módulo que ainda não foi implantado.

Agradecimentos

Construído sobre o Model Context Protocol, Express, Prisma, Mongoose, Drizzle, TypeORM e Sequelize.

Licença

AGPL-3.0-or-later. Consulte LICENSE.