Sparda

Transforme qualquer base de código em um servidor MCP com um único comando. Express & FastAPI → pronto para Claude em 3 minutos.

GitHub

Experimente este MCPPatrocinado

Documentação

SPARDA

🇫🇷 Français — L'IA écrit. SPARDA prouve. Un gate déterministe et hors-ligne qui détecte quand une modif d'IA retire une garde, expose une route ou casse un invariant — sans clé API, directement dans la boucle d'édition de l'agent. Pour tout comprendre en 10 minutes (douleur, architecture, vision) : SPARDA-EXPLIQUE.md.

AI writes. SPARDA proves.

L'IA écrit. SPARDA prouve.

A camada de confiança para backends escritos por IA. O SPARDA compila seu backend — rotas, consultas de banco de dados, mutações de estado, guards, efeitos colaterais — em um único grafo de comportamento determinístico e, em seguida, prova estaticamente o que pode e o que não pode quebrar antes de você publicar: nenhuma mutação sem guard, nenhum invariante quebrado, nenhuma escrita agregada não atômica.

100% local · determinístico · zero chave de API · sem conta em nuvem. Ele falha ruidosamente diante de um risco real e, quando só consegue enxergar parte do seu aplicativo, diz PROVEN (PARTIAL) — nunca um verde falso. E quando consegue provar que nem sequer estava olhando para o seu aplicativo inteiro, diz PREMISE NOT VERIFIED e não afirma nada.

Prova em 60 segundos

A partir do seu aplicativo Express, FastAPI, Flask, Next.js, NestJS ou Medusa — nada para configurar:

npx sparda-mcp apocalypse   # prove the tree is safe to deploy — exit 1 on any real risk, or on an unverified premise
npx sparda-mcp prove        # the whole verdict: proof + coverage + shareable seal
npx sparda-mcp badge        # a README badge: proven · coverage% · routes

Por baixo dos panos, ele compila seu backend em um único grafo agnóstico de linguagem — o Unified Behavior Graph (UBG), serializado como .sparda/ubg.json sob a especificação SBIR (SPARDA Behavior IR) — e cada comando é uma passada sobre esse grafo.

A cunha — detectar uma edição de IA que remove um guard, no loop

A única coisa que uma revisão por diff de texto e um scanner de padrões estruturalmente não conseguem fazer: provar que essa edição específica removeu uma proteção que a versão anterior tinha. sparda gate compara o grafo de comportamento antes/depois de uma edição e bloqueia uma regressão — determinístico, offline, em menos de um segundo, exit 2 (o contrato PostToolUse do Claude Code que interrompe o loop de edição do agente). Veja isso de ponta a ponta em um único comando, sem configuração:

npm run wedge     # (from a clone)  — or drive it on your own app with `sparda gate --arm` then `sparda gate --hook`

  1. baseline armed on the guarded code   (POST /admin/delete-user · requireAdmin)
  2. an AI edit "simplifies" requireAdmin → a pass-through (still compiles, still 200s)
  3. sparda gate on the edit:
       ✗ [critical] GUARD_REMOVED — POST /admin/delete-user was guarded in the baseline
                    and is now reachable without any guard (src/app.js:11)
     ⏱  ~40 ms · deterministic · offline · no API key
     ⛔ exit 2 on --hook — Claude Code PostToolUse blocks the edit

Conecte-o ao Claude Code em uma linha — o plugin registra um hook PostToolUse que executa npx -y sparda-mcp gate --hook após cada Edit/Write, para que uma edição que remova um guard seja capturada antes de ser aplicada.

[!IMPORTANT]
A Prova de Compilação de Rotas — reproduza você mesmo. O SPARDA compila monstros reais de código aberto para seu grafo de comportamento com zero crashes, cada um em ≈1–2 segundos: Next.js Dub (579 rotas), NestJS Immich (281), MedusaJS (477). Ele resolve nativamente injeção de dependência profunda, controllers externos e handlers do Next.js. Um único comando clona-os e re-mede na sua máquina:
node bench/repro.mjs        # → bench/route-proof.json
Honestidade em primeiro lugar: compilar uma rota é um resultado de parser (o número acima); provar que é segura é um veredito separado por repositório — e a maioria dos aplicativos reais retorna NOT_PROVEN, que é o estado verdadeiro, não uma falha. (Nosso corpus completo de 25 repositórios compila sob estresse 3.565 rotas a ~150 rotas/s; isso exige o corpus verificado localmente.)

O que o grafo desbloqueia — 100% local, determinístico, 4 dependências com versão exata fixada, zero chave de API:

Comando	O que faz
`prove`	O veredito de confiança inteiro em um gesto — prova + cobertura + verificação de premissa + um selo compartilhável (`--json` / `--markdown`)
`apocalypse`	Prove o deploy — nenhum guard, invariante, transação ou limite de agregado pode ser quebrado (SARIF + gate de CI)
`heal`	Autocorreção, provada — o gate que o Copilot Autofix não tem: uma correção é enviada somente se o replay corresponder, `verify` ainda passar e `apocalypse` não encontrar novo risco / nenhum guard removido. Quem quer que tenha escrito a correção, a máquina a julga.
`badge`	O artefato compartilhável — um badge SVG autocontido + trecho de README (veredito · cobertura · rotas)
`dossier`	O relatório público — uma página HTML autocontida: veredito, riscos e os próprios pontos cegos do SPARDA
`ubg`	Compile o código-fonte para seu grafo de comportamento (Express · FastAPI · Flask · Next.js · NestJS · Medusa nativamente; qualquer stack via OpenAPI)
`timeless`	Viagem no tempo — grave uma requisição de produção, reproduza-a byte a byte idêntica, exporte o bug como teste
`mirror`	Execute o grafo — sirva o comportamento compilado via HTTP sem framework e sem código-fonte
`init` / `dev`	Runtime, opcional — exponha o grafo a clientes de IA como um servidor MCP ao vivo (+ Twin, Immune, Evolution)

O provador é o produto. O servidor MCP é uma saída do grafo, não o ponto central — o SPARDA compila o comportamento do sistema inteiro e depois prova, reproduz, corrige e (opcionalmente) serve.

Nomenclatura: SBIR é a especificação (o formato, como "JSON"); UBG é o grafo compilado em si (o artefato, ubg.json). O servidor MCP é uma saída do grafo, não o produto.

Opcional: exponha o grafo a clientes de IA (runtime MCP)

Além de provar, o SPARDA pode transformar seu aplicativo em execução em um servidor MCP ao vivo — o grafo, executável, com segurança de escrita e uma camada imune. Isso é opcional e separado do provador acima.

Escaneie + injete — execute uma vez, a partir do diretório do seu aplicativo:
```
npx sparda-mcp init
```
O SPARDA analisa suas rotas (AST), gera um router /mcp marcado, injeta-o no seu aplicativo (com um backup) e escreve sparda.json. Cada etapa é reversível.
Inicie seu aplicativo e depois inicie a ponte:
```
npx sparda-mcp dev
```
Conecte seu cliente. init imprime um bloco pronto para colar para claude_desktop_config.json, pré-preenchido com o nome e o caminho do seu aplicativo:
```
{
  "mcpServers": {
    "your-app": {
      "command": "npx",
      "args": ["sparda-mcp", "dev"],
      "cwd": "/absolute/path/to/your-app"
    }
  }
}
```
O Claude Code conecta-se à mesma ponte. É isso — seu aplicativo em execução agora é um conjunto de ferramentas MCP que sua IA pode chamar.

Experimente a Demonstração Autônoma

Para ver o SPARDA em ação instantaneamente sem modificar seu código-fonte:

npx sparda-mcp demo

Isso executa todo o ciclo de vida do MCP (detectar → analisar → gerar → injetar → remover) em um aplicativo de demonstração incluído em uma pasta temporária, em cerca de 10 segundos. Para o compilador em si, execute npx sparda-mcp ubg e depois apocalypse em qualquer aplicativo Express/FastAPI.

Relatório de Caixa-Preta

O SPARDA é projetado como um organismo local. Para ver o que ele lembra e quanto de computação reciclou:

npx sparda-mcp report

Isso imprime um painel de terminal agregando suas ferramentas expostas, opt-ins de escrita, decisões do diário de prova e ferramentas compostas cristalizadas.

Para escrever um painel HTML autocontido e offline em .sparda/report.html, acrescente o sinalizador --html:

npx sparda-mcp report --html

Para gerar JSON bruto para integração:

npx sparda-mcp report --json

Prova de Implantação: Apocalypse

O Grafo de Comportamento do SPARDA é um modelo formal do seu sistema. Em vez de esperar por falhas em tempo de execução ou confiar em vibrações de análise estática, você pode provar estaticamente a segurança do seu backend antes de qualquer implantação:

npx sparda-mcp apocalypse

Este comando lê o .sparda/ubg.json compilado (com zero análise de código-fonte em tempo de execução) e resolve cinco obrigações estáticas de correção:

Mutação sem Guard (Crítico): Sinaliza qualquer caminho de mutação que não cruze um guard de segurança.
Escrita Agregada Não Atômica (Alto): Sinaliza quando uma API escreve em múltiplas tabelas do mesmo Domínio de Consistência (Agregado) fora de um único escopo de transação.
Escrita Restrita Não Validada (Médio): Sinaliza escritas em colunas com invariantes declarados (CHECK, NOT NULL, UNIQUE — analisados do seu DDL .sql ou schema.prisma, enums do Prisma incluídos) sem validação prévia (Zod/Pydantic).
Efeito Observável Irreversível (Alto): Sinaliza ações fora do processo (como cobranças do Stripe) que ocorrem junto com escritas de estado sem um caminho estrutural de compensação (como catch-refund).
Desvio de Membro do Agregado (Info): Sinaliza mutação direta de uma tabela membro sem passar pela raiz do agregado.

Para salvar seu grafo atual como uma linha de base segura:

npx sparda-mcp apocalypse --save-baseline

Execuções subsequentes compararão o grafo candidato com essa linha de base para detectar vetores de regressão:

Exclusão de qualquer guard de segurança (Crítico).
Exclusão de um invariante SQL de banco de dados (Alto).
Expansão do raio de impacto da API (Médio).

Se qualquer achado Crítico ou Alto for encontrado, apocalypse sai com um código não zero para bloquear seu pipeline de CI.

Um passo no seu fluxo de trabalho — os achados chegam à aba de Segurança do GitHub (SARIF):

- uses: zakariagharzouli/sparda@main
  with:
    sarif: 'true'

Viagem no Tempo: Timeless

Toda requisição de produção é determinística entre seus efeitos — o compilador sabe exatamente onde o não determinismo vive (db, http, relógio, aleatório, uuid: os nós de efeito do grafo). O Timeless registra apenas esses pontos (alguns KB por requisição) e reproduz a requisição byte a byte idêntica contra seu código atual, com o banco de dados, webhooks e relógio virtualizados a partir da gravação:

npx sparda-mcp timeless                # list recorded flights
npx sparda-mcp timeless replay <id>    # re-fly it — byte-identical or loud divergence
npx sparda-mcp timeless export <id>    # the production bug is now a vitest test

A gravação é feita em duas linhas no seu aplicativo (ESM), com amostragem determinística e redação de GDPR integradas:

import { getFlightBox } from 'sparda-mcp/src/flight/box.js';
const box = getFlightBox(); box.arm();
app.use(box.middleware({ sample: 100 }));   // 1 request in 100; passwords/tokens redacted by default
const db = box.wrapClient(pgPool);           // your query client, tapped

O loop fechado que ninguém mais tem: bug de produção → voo gravado → teste com falha → IA escreve a correção → apocalypse prova que a correção não quebra guard, invariante ou transação → deploy. A reprodução é por requisição (captura de corrida concorrente está fora do escopo da v1 — declarado, não escondido).

Autocorreção, Provada: `sparda heal`

O loop acima, como um gesto — e a máquina julga a correção, quem quer que a tenha escrito:

npx sparda-mcp heal <flightId>                       # diagnose + write the fix brief
# ...apply the fix (a human, or --agent "your-ai-cli")...
npx sparda-mcp heal <flightId> --check --expect '{"status":404}'

O briefing é construído a partir do próprio grafo — ele entrega ao corretor o file:line do handler, as capacidades que a correção não pode ampliar e os guards que ela não pode remover. Depois, o gate — o produto real — prova a correção em três eixos ao mesmo tempo:

Comportamento — a reprodução tolerante do voo gravado (mesmos insumos determinísticos) agora produz a resposta esperada, não o bug gravado. A correção pode reformular uma consulta (o tap é reclassificado, permitido); ela não pode mudar a ordem ou os tipos de efeitos.
Leis do compilador — verify ainda passa: o grafo continua sólido e determinístico.
Sem regressão — diff de apocalypse contra o grafo pré-correção congelado: zero novos achados críticos/altos, nenhum guard removido, nenhum raio de impacto ampliado.

✓ HEALED & PROVEN — same recorded inputs, correct output, zero law broken, zero protection lost. Ship it.

O portão é honesto em ambas as direções: um bug não corrigido, ou uma "correção" que silenciosamente remove uma proteção, o mantém fechado (exit 1). Essa é a diferença entre uma IA que escreve código plausível e um sistema que prova que o código está correto — a camada de confiança que falta na era dos agentes.

Qualquer Backend do Mundo: Redução para OpenAPI

O SPARDA analisa Express, FastAPI e Next.js nativamente — e qualquer outra stack através do formato que a indústria já concordou. Go, Java, Rails, Laravel, .NET: se tem uma especificação OpenAPI, ele compila.

npx sparda-mcp ubg --openapi openapi.json

Esquemas de segurança se tornam nós de bloqueio guard, esquemas de resposta se tornam retornos tipados, corpos de requisição declarados contam como entrada validada. Combine a especificação com seus arquivos .sql ou schema.prisma e a camada de estado completa — invariantes, agregados, máquinas de estado — é preenchida a partir da verdade declarada. (Especificações JSON na v1; recusamos analisar YAML pela metade com zero dependências.)

A VM Espelho: delete o framework, o app ainda responde

O grafo não é um diagrama — ele executa:

npx sparda-mcp mirror

MIRROR — the graph is serving. 3 entrypoint(s) on http://127.0.0.1:4477
  GET    /orders/{orderId}  → {amount, id, status}
  POST   /orders  🔒 bearerAuth  → {amount, id, status}

Sem Express. Sem FastAPI. Sem código-fonte — apenas ubg.json respondendo HTTP: proteções realmente negam (401), respostas renderizam os esquemas de retorno compilados, caminhos desconhecidos retornam 404 com a tabela de rotas completa. Times de front-end desenvolvem contra backends que ainda não foram implantados — ou que ainda não foram escritos (aponte mirror para uma especificação OpenAPI). Cada resposta carrega x-sparda-mirror: true; o espelho serve o comportamento declarado, nunca inventa valores de negócio.

Para desfazer tudo: npx sparda-mcp remove restaura seu código byte por byte.

A promessa — cada palavra é respaldada por um teste no CI

Três minutos, um comando. Varredura AST, geração de roteador, injeção reversível — sem configuração.
Experimente de graça, saia de graça. npx sparda-mcp remove restaura seu código byte por byte (testado em JS, TS, Python, até arquivos CRLF do Windows). Sem rastros, sem aprisionamento.
A IA não pode escrever até você permitir. Todo POST/PUT/DELETE está desabilitado por padrão; você habilita por ferramenta, e sua escolha sobrevive a cada nova execução.
Seu app se defende sozinho. Uma rota que falha 3 vezes seguidas é colocada em quarentena — a IA não consegue martelar sua produção quebrada. Anomalias de latência são sinalizadas. Zero LLM necessário.
Nada sai da sua máquina. Sem telemetria para nós, sem nuvem, autenticação por chave local, 4 dependências com versões exatamente fixadas.
O que ela aprende nunca se perde. Diagnósticos, descrições, configurações — versionados com seu git, sobrevivendo a cada reinicialização.

O que não prometemos: os limites honestos em docs/SECURITY.md.

Como funciona

npx sparda-mcp init analisa seu código (AST), extrai cada rota e injeta um roteador marcado e mínimo (/mcp) no seu app — totalmente reversível com npx sparda-mcp remove.
Chamadas de ferramenta executam dentro do processo vivo do seu app — pools de banco aquecidos, cadeia de autenticação real, dados reais. O SPARDA não adiciona infraestrutura: computação vem do seu processo hospedeiro, inteligência do modelo do próprio cliente de IA (amostragem MCP), armazenamento de sparda.json + git.
Ferramentas de escrita (POST/PUT/DELETE) estão desabilitadas por padrão. Você opta por ativá-las individualmente em sparda.json — suas escolhas sobrevivem a novas execuções.
Docstrings suspeitas são sanitizadas antes de chegarem à IA (defesa contra injeção de prompt).
npx sparda-mcp doctor --app audita seu código em busca de desvios: detecta ferramentas obsoletas (IA vendo fantasmas), rotas dessincronizadas, desvios de esquema via impressões digitais e configurações zumbis. Problemas de alta gravidade geram um código de saída diferente de zero para seu pipeline de CI.
npx sparda-mcp seed export/import permite empacotar e compartilhar o "genoma" do seu app (memória semântica, fluxos de trabalho, anticorpos) com segurança, transferindo memória imunológica entre ambientes ou stacks semelhantes com zero vazamento de dados.
npx sparda-mcp twin inicia um servidor simulado e seguro do seu backend na porta original. Ele atende chamadas GET a partir de exemplares aprendidos (formatos de resposta observados e dados simulados) e retorna escritas simuladas com 202 sem nunca tocar seu banco de dados real ou APIs de produção. Aprenda exemplares executando npx sparda-mcp twin --learn.
npx sparda-mcp grammar mapeia o grafo de sequências válidas de chamadas de ferramenta (circuitos observados e hipóteses candidatas) para prevenir alucinação de rotas pelo LLM.
npx sparda-mcp evolve muta cadeias candidatas e as testa contra o gêmeo em memória, promovendo cadeias bem-sucedidas a sugestões de fluxo de trabalho evoluídas.

O que o SPARDA dá à sua IA

Operar, não apenas ler

Cada rota se torna uma ferramenta que executa contra seu processo vivo — autenticação real, dados reais, conexões aquecidas. Uma chamada para sparda_get_context entrega à IA o panorama completo e vivo: ferramentas habilitadas, fluxos de trabalho sugeridos, telemetria de runtime, estado de quarentena e memória imunológica — para que cada sessão retome de onde a última parou.

Segurança de escrita: a IA não pode escrever até você permitir

Escritas (POST/PUT/DELETE) vêm desabilitadas. Habilite-as por ferramenta em sparda.json; sua escolha sobrevive a cada reinicialização.
Uma escrita habilitada nunca é executada na primeira chamada. O SPARDA retorna um envelope awaiting_confirmation — um token de uso único mais uma prévia da ação — e confirma apenas após um passo explícito de confirmação.
Quando seu cliente suporta elicitação MCP, esse prompt de confirmação aparece na própria interface da IA.
Prova após a escrita: toda escrita bem-sucedida é seguida por uma releitura do mesmo recurso, para que a IA — e você — vejam o efeito real, não um palpite otimista.

Seu app se defende sozinho — zero LLM no caminho crítico

Quarentena. Uma ferramenta que retorna 3 5xx consecutivos é colocada em quarentena: chamadas adicionais recebem um 503 com um motivo e um atraso de nova tentativa em vez de martelar sua rota quebrada. Após um período de resfriamento, ela se abre parcialmente para uma única sonda.
Sinalizadores de latência e anomalia. O roteador aprende a linha de base de cada rota e sinaliza desvios localmente, em algumas linhas de matemática.
Diagnóstico adaptativo, apenas em surpresa. Uma falha genuinamente nova acorda o modelo do próprio cliente de IA para diagnosticá-la uma vez; o diagnóstico é armazenado em cache como um "anticorpo" em sparda.json, então a mesma falha posteriormente custa zero tokens. Clonar seu código não clona sua memória imunológica.

Uma camada de inteligência gratuita, zero chave de API

Na primeira conexão, o modelo do próprio cliente de IA (via amostragem MCP) reescreve rotas brutas em descrições de ferramentas em linguagem de negócio e propõe fluxos de trabalho em várias etapas — armazenados em cache em sparda.json e expostos como prompts MCP. Nada para configurar, nada para pagar.

Fica mais barato quanto mais você usa

Reciclagem de respostas. Quando uma leitura continua retornando a mesma resposta, o SPARDA atende a próxima chamada idêntica diretamente da memória — sem tocar seu app hospedeiro. Apenas leituras; escritas sempre atingem o hospedeiro.
Um medidor de reciclagem. GET /mcp/stats conta quantas chamadas foram respondidas pelo conhecimento do próprio SPARDA versus quantas pagaram pela rota do hospedeiro. Ele lê 0% no primeiro dia e se preenche com o uso — uma medida, nunca uma promessa.

Ferramentas que ninguém escreveu — Labs, opt-in, DESLIGADO por padrão

Ative com "labs": { "recordSequences": true } em sparda.json. O SPARDA então percebe quando a saída de uma ferramenta alimenta a entrada da próxima e registra o circuito — apenas estrutura (nomes de ferramentas, nomes de argumentos, contagens), nunca seus dados. Um circuito somente leitura visto vezes suficientes cristaliza em uma ferramenta composta, anunciada no meio da sessão: uma chamada executa a cadeia inteira, alimentando automaticamente cada etapa a partir da resposta real da etapa anterior. Rotas de escrita nunca são absorvidas — sua confirmação por chamada sempre permanece.

Contexto vivo e telemetria

GET /mcp/stats (chamadas/erros por ferramenta, "pureza" da ferramenta, estado de quarentena) e GET /mcp/events (erros, anomalias de latência, diagnósticos em cache) expõem exatamente o que seu app está fazendo — apresentados à IA como notificações ao vivo.

Feito para clientes de IA: a Skill integrada

O SPARDA vem com uma Skill de Agente (SKILL.md) que ensina a qualquer cliente de IA compatível como conduzir um servidor SPARDA ao seu máximo potencial — chame sparda_get_context primeiro, explore a reciclagem de respostas, respeite a quarentena, prefira circuitos cristalizados em vez de refazer uma cadeia e siga o protocolo de confirmação de escrita em duas fases. A lista viva de ferramentas por projeto sempre vem de sparda_get_context em tempo de execução, então a orientação nunca fica desatualizada.

Frameworks suportados

Next.js App Router (13/14/15) — injeção baseada em arquivos. O SPARDA cria um manipulador de rota catch-all. Ele resolve nativamente manipuladores encapsulados (export const POST = withAuth(h)) e cadeias de efeitos profundas.
NestJS — injeção de roteador baseada em AST. Resolve profundamente Injeção de Dependência multi-hop (Controller → Service → Repository), DI herdada e imports baseUrl/paths. Suporta Prisma, TypeORM e Kysely.
Express 4/5 (JS/TS, ESM/CJS) — injeção de roteador baseada em AST. Resolve profundamente controllers externos, esquemas Mongoose e re-exports de barrel. Usa varredura dinâmica de árvore para encontrar pontos de entrada não padrão (bootstrap.ts, etc).
MedusaJS — ingestão AST nativa de roteamento complexo de e-commerce.
Qualquer Backend do Mundo (Go, Java, Rails, Laravel) — Compila perfeitamente a partir de especificações OpenAPI 3.x.
FastAPI (Python >= 3.9) — injeção de roteador baseada em AST.

Postura de segurança (honesta)

4 dependências de runtime, com versões exatamente fixadas.
Resolução Dinâmica de Chave Local. O roteador gerado não contém segredos embutidos. Ele resolve chaves de autorização em tempo de execução a partir da variável de ambiente SPARDA_LOCAL_KEY ou do arquivo local ignorado pelo git .sparda/key, e falha fechado (503) quando nenhum é encontrado. Para setups personalizados de produção ou staging, você pode sobrescrever esse comportamento expondo SPARDA_LOCAL_KEY no seu ambiente.
Chave local em cada chamada do roteador; proteção contra loop de auto-referência; timeouts de 30s; truncamento de saída de 8 KB.
Injeção posicionada por AST com backup e re-análise pós-injeção; npx sparda-mcp remove deixa um diff git limpo.
Persistência sem valores: o SPARDA registra estrutura (nomes de ferramentas, nomes de campos, impressões digitais), nunca seus payloads.

Modelo de ameaça completo e lacunas conhecidas: docs/SECURITY.md.

Documentação

docs/ARCHITECTURE.md — como init, o roteador injetado e a ponte se encaixam, além do esquema sparda.json.
docs/SECURITY.md — modelo de ameaça, defesas e lacunas conhecidas honestas.
docs/TESTING.md — como as promessas acima são mantidas honestas no CI.
docs/ERRORS.md — a base de conhecimento de erros.

Além do núcleo aberto

O SPARDA é gratuito, inclusive em produção (veja a Licença). Capacidades em escala de equipe — políticas de acesso granular por pessoa e um log de auditoria assinado e à prova de adulteração — estão planejadas para um futuro nível pago. O núcleo aberto se sustenta sozinho; nada aqui é capado para forçar uma venda.

Licença

Business Source License 1.1 — gratuito para uso, inclusive em produção. Você não pode revender o SPARDA ou oferecê-lo como um serviço comercial concorrente. Cada versão converte para Apache 2.0 quatro anos após seu lançamento.

Por Residual Labs

Sparda

Documentação

SPARDA

AI writes. SPARDA proves.

Prova em 60 segundos

A cunha — detectar uma edição de IA que remove um guard, no loop

Opcional: exponha o grafo a clientes de IA (runtime MCP)

Experimente a Demonstração Autônoma

Relatório de Caixa-Preta

Prova de Implantação: Apocalypse

Viagem no Tempo: Timeless

Autocorreção, Provada: sparda heal

Qualquer Backend do Mundo: Redução para OpenAPI

A VM Espelho: delete o framework, o app ainda responde

A promessa — cada palavra é respaldada por um teste no CI

Como funciona

O que o SPARDA dá à sua IA

Operar, não apenas ler

Segurança de escrita: a IA não pode escrever até você permitir

Seu app se defende sozinho — zero LLM no caminho crítico

Uma camada de inteligência gratuita, zero chave de API

Fica mais barato quanto mais você usa

Ferramentas que ninguém escreveu — Labs, opt-in, DESLIGADO por padrão

Contexto vivo e telemetria

Feito para clientes de IA: a Skill integrada

Frameworks suportados

Postura de segurança (honesta)

Documentação

Além do núcleo aberto

Licença

Autocorreção, Provada: `sparda heal`