convez.ai
AgenteAutomaçãoAvançado
avasis-ai

SynthCode

avasis-ai/synthcode

Agente IA com verificação simbólica de seis gates para produção

Ver no GitHub
InicialPluginScore · de 0 a 100

Framework TypeScript para sintetizar qualquer LLM em um agente de IA pronto para produção. Implementa verificação neurossimbólica com seis gates simbólicos que validam cada saída do modelo em ~3-8ms, garantindo segurança e confiabilidade sem dependências externas.

Instalação

$npx convez-ai avasis-ai/synthcode

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
3
Forks
1
Acompanhando
1
Saúde
42%
Último commit
há 6 meses
Versão
—
Issues abertas
0
Contribuidores
4

Casos de uso

  • Construir agentes autônomos verificados para tarefas críticas
  • Integrar LLMs com garantias de segurança em produção
  • Debugging e auditoria de saídas de modelos com rastreamento de gates

Veredito

SynthCode é uma solução sofisticada para quem precisa de agentes LLM confiáveis em produção. A arquitetura neurossimbólica e os 269 testes validados demonstram maturidade, embora exija expertise TypeScript avançada para aproveitar seu potencial máximo.

README

A tradução para o português deste README ainda está na fila.


Install

# TUI -- the full experience
npx @avasis-ai/synthcode-tui@latest

# Framework -- programmatic API
bun add @avasis-ai/synthcode

Screenshots

The Six Gates

GateVerifiesLatency
StructureAST well-formedness, syntax validity~1ms
ScopeVariable bindings, lexical resolution~2ms
TypeType consistency, inference chains~3ms
SafetySide-effect boundaries, mutation control~2ms
Control FlowReachability, termination guarantees~3ms
SemanticLogical coherence, intent alignment~5ms

Features

  • Dual-path verification -- neural output passes six symbolic gates before touching your codebase
  • Zero-dependency framework -- 10KB gzipped, no runtime deps
  • Agentic chat -- up to 15 autonomous rounds with inline gate feedback
  • Six screen modes -- chat, gates, code view, world model, trust boundary, playground
  • Provider-agnostic -- Gemini, Groq, OpenRouter, OpenAI, Ollama
  • 269 tests -- 300+ consecutive CI runs, zero failures
  • OpenTUI engine -- built on Zig+TS for native terminal performance

Quick Start

TUI:

npx @avasis-ai/synthcode-tui@latest

Framework:

import { Agent, BashTool, DualPathVerifier } from "@avasis-ai/synthcode";
import { OllamaProvider } from "@avasis-ai/synthcode/llm";

const agent = new Agent({
  model: new OllamaProvider({ model: "qwen3:32b" }),
  tools: [BashTool],
  dualPathVerifier: new DualPathVerifier(),
});

for await (const event of agent.run("List all TypeScript files in src/")) {
  if (event.type === "text") process.stdout.write(event.text);
}

Architecture

  LLM Output
      |
      v
 +----------+   +-------+   +------+   +--------+   +------------+   +----------+
 | Structure|-->| Scope |--->| Type |--->| Safety |--->| ControlFlow|--->| Semantic |
 +----------+   +-------+   +------+   +--------+   +------------+   +----------|
      |                                                               |
      v                                                               v
   REJECT                                                          ACCEPT

Framework API

import {
  Agent, BashTool, FileReadTool, FileWriteTool,
  DualPathVerifier, WorldModel, CostTracker, CircuitBreaker,
  AnthropicProvider, OpenAIProvider, OllamaProvider,
} from "@avasis-ai/synthcode";

const agent = new Agent({
  model: new AnthropicProvider({ model: "claude-sonnet-4-20250514" }),
  tools: [BashTool, FileReadTool, FileWriteTool],
  dualPathVerifier: new DualPathVerifier(),
  costTracker: new CostTracker(),
});
npx @avasis-ai/synthcode "Explain this codebase"              # auto-detect
npx @avasis-ai/synthcode "Refactor this" --ollama qwen3:32b   # local
npx @avasis-ai/synthcode adapt catalog                         # 30+ models

Agent Patterns

SynthCode is designed for autonomous agents that run 24/7. Here are common patterns:

Error Handling & Resilience

Autonomous agents must handle failures gracefully:

import { createResilientTool, ErrorLogger, CircuitBreaker } from "@avasis-ai/synthcode";

// Wrap tools with retry logic and circuit breaking
const bashTool = createResilientTool(
  new BashTool(),
  new ErrorLogger(),
  new CircuitBreaker(),
  { maxRetries: 3 }
);

// The agent continues even when tools fail temporarily

See examples/error-handling.ts for a complete implementation with:

  • Automatic retry with exponential backoff
  • Circuit breaker pattern for failing tools
  • Structured error logging for debugging
  • Graceful degradation when tools are unavailable

Continuous Monitoring

Track agent performance over time:

const costTracker = new CostTracker();
const agent = new Agent({
  model: anthropic("claude-3-5-sonnet-20241022"),
  tools: [BashTool, FileReadTool],
  costTracker, // Tracks tokens, cost, and usage metrics
});

// Get stats anytime
const stats = costTracker.getStats();
console.log(`Total cost: $${stats.totalCost}`);

Memory & Context

Persistent memory for long-running agents:

import { SQLiteStore } from "@avasis-ai/synthcode/memory";

const memory = new SQLiteStore({ path: "./agent-memory.db" });

// Agent remembers conversations across restarts
const agent = new Agent({
  model: anthropic("claude-3-5-sonnet-20241022"),
  tools: [BashTool],
  memory, // Persist context to disk
});

Autonomous Loops

Run agents continuously:

import { agentLoop } from "@avasis-ai/synthcode";

for await (const result of agentLoop(agent, {
  maxTurns: 15,
  timeout: 5 * 60 * 1000, // 5 minute timeout
  onTurn: async (turn, events) => {
    // Hook into each turn for monitoring
    console.log(`Turn ${turn}:`, events.length, "events");
  }
})) {
  if (result.done) break;
  // Continue loop
}

Examples

Feature Comparison

SynthCodeClaude CodeCursorAider
Symbolic verificationYesNoNoNo
Dual-path gatesYesNoNoNo
Zero dependencies10KBNoNoNo
Terminal-native TUIYesYesNoYes
Provider-agnostic5+NoPartialPartial
Open sourceMITNoNoApache

avasis-ai/synthcode -- MIT License -- Built by Avasis AI


⚡ SynthCode Pro

8 verification gates that catch AI hallucinations in 7.2ms.

The OSS version has 6 gates. Pro adds:

  • Gate 7: Self-Consistency — samples multiple completions, checks agreement
  • Gate 8: Red-Team Adversarial — adversarial prompt stress-tests every response
  • Neurosymbolic Router — auto-routes between neural and symbolic execution
  • Knowledge Graph + Episodic Memory — persistent context across sessions
  • Production Toolkit — OpenTelemetry, rate limiting, semantic caching, fallback chains
  • 5 Agent Templates — research, coding, support, analysis, multi-agent orchestration

269 tests passing. Full TypeScript source. Ships on npm (@avasis-ai/synthcode-pro).

Plans:

TierPriceIncludes
Starter$496 core gates + 5 templates + docs
Full Access$149All 8 gates + router + memory + toolkit
Complete Bundle$199Pro + 500 Prompts + AI Lab Lifetime

Launch promo: Use LAUNCH20 for $30 off Full Access → $119 · FIRST10 for $75 off → $74 (first 10 buyers)

→ Get SynthCode Pro


More from Avasis

Ver o original no GitHub

Bom para

Relacionados