// stratago.generator.v1 · florianópolis · 2026

Gerador de SaaS como agente

Um agente de IA que gera SaaS verticais completos — do código ao deploy — a partir de uma especificação declarativa. Base canônica fixa, domínio estendido via DSL, orquestrado por LangGraph + CrewAI.

DSL · Domain Spec Claude Skills LangGraph StateGraph CrewAI Crews LangFlow Antigravity · GCP Traefik · React · Postgres Neo4j · pgvector LPA₂v · DS · MACBETH · AHP
Ver arquitetura Plano de implementação
// 01 · arquitetura

Quatro camadas

Base canônica fixa + domínio gerado por agente. O plano BASE é reusável em qualquer SaaS; o plano DOMAIN nasce da DSL de especificação.

Base canônica · imutável
Auth JWT + OAuth Recuperação de senha Perfis de usuário Cadastro · onboarding Multi-tenant RBAC Monetização Stripe Wizard framework Dashboard shell Notificações Audit log i18n PT/EN/ES Design system Obsidiana
Infra topologia fixa
Traefik v3 + Let's Encrypt Docker Compose overlay Postgres + pgvector Redis Streams Neo4j ChromaDB Prometheus + Grafana Alembic migrations pytest > 80%
Domain gerado via DSL + agente
Entidades de domínio Rotas FastAPI específicas Componentes React Engines matemáticas Relatórios PDF ReportLab Ontologia OWL Sub-domínio Traefik Testes de integração
AI Layer motor de geração
Claude SKILL.md por artefato Specs como contratos Antigravity orchestration CrewAI crews por módulo LangGraph StateGraph LangFlow visual MCP tools LAG-Dedutivo validation
// 02 · domain specification language

STRATAGO-DSL v1

Contrato declarativo entre o arquiteto e o agente. Você escreve a spec — o agente gera o SaaS completo. Sintaxe YAML com herança, engines injetáveis e skills binding.

# stratago.spec.yaml · exemplo: ai_impact_simulator
domain: "ai_impact_simulator"
version: "1.0.0"
subdomain: "sim.stratago.com.br"

# herança da base canônica
extends: "stratago-base@latest"
base_modules:
  - auth
  - billing.stripe
  - profiles
  - dashboard.shell

# entidades do domínio
entities:
  - name: Profession
    fields: [name, cbo_code, ai_exposure, tasks]
    relations: [has_many: SimulationResult]

# engines matemáticas injetadas
engines:
  - DempsterShafer: {k_limit: 0.15}
  - MACBETH: {scale: cardinal, levels: 7}
  - FuzzyAHP: {method: buckley, cr_limit: 0.10}

# features geradas automaticamente
features:
  - wizard: {steps: [select, configure, results]}
  - pdf_report: {template: reportlab, pages: 8}
  - credits: {price_brl: 12, per: simulation}

# claude skills a invocar
claude_skills:
  - docx  # spec técnica Word
  - pptx  # pitch deck
  - frontend-design # UI Obsidiana
  - pdf   # relatório output

Herança via extends

Sintaxe inspirada em Docker Compose e HELM values. Override granular por módulo. A base canônica é sempre resolvida antes do domain spec.

Engines plug-in

Cada engine declarada em engines[] é instanciada pelo BackendCrew com seus parâmetros. DS, MACBETH, FuzzyAHP, LPA₂v, Petri — todos disponíveis.

Skills binding

Cada skill em claude_skills[] mapeia para um SKILL.md carregado antes da geração do artefato correspondente.

Fonte única de verdade

O stratago.spec.yaml é versionado no repositório. Qualquer re-geração parte dele.

// 03 · pipeline de geração

8 etapas

Da DSL ao deploy em produção. Cada etapa é um nó no LangGraph StateGraph com critérios de entrada, agente responsável e artefato de saída verificável.

01
DSL Parse
SpecParserAgent
→ generation_plan DAG
02
Validate
JSON Schema v1
→ spec_valid bool
03
Resolve
ExtendsMerger
→ merged spec
04
Ontology
OntologyCrew
→ OWL .ttl + SPARQL
05
Backend
BackendCrew
→ FastAPI + engines
06
Frontend
FrontendCrew
→ React + Zustand
07
Infra + Docs
InfraCrew + DocsCrew
→ compose + pptx + docx
08
Deploy
Antigravity · GCP
→ URL + smoke tests
// plantuml · referência
@startuml SaaSGeneratorPipeline
skinparam monochrome true · shadowing false

start
:load_spec → YAML parse;
:parse_and_validate → JSON Schema;
if (spec_valid?) then (sim)
  :resolve_extends → base merge;
  :emit_generation_plan → DAG JSON; / checkpoint 1
  fork
    :ontology_crew → OWL/SPARQL;
  fork again
    :backend_crew → FastAPI + engines;
  fork again
    :frontend_crew → React + UI;
  end fork
  :join_artifacts → valida outputs; / checkpoint 2
  :infra_crew → Docker + Traefik;
  :docs_crew → SKILL.md artifacts;
  :deploy → Antigravity + smoke; / checkpoint 3
else (não)
  :error_report → path + msg;
endif
stop
@enduml
// 04 · orquestração multi-agente

Hipóteses de
implementação

Três estratégias de orquestração, cada uma com trade-offs distintos. Recomendação: LangGraph + CrewAI para produção.

recomendado · produção
LangGraph + CrewAI
LangGraph como state machine do pipeline. CrewAI como executor de cada nó — crew especializada por etapa. Checkpointing Redis entre fases. Maior controle de fluxo com retry granular.
✓ retry por nó · checkpoint · debug visual · rollback
→ mais código de orquestração
prototipagem · demos
LangFlow
Pipeline completo no LangFlow com nós visuais. Cada agente é um custom component. Ideal para prototipagem rápida e demos com clientes — SMTTDE, SEBRAE, municípios.
✓ visual · sem código de orquestração · exportável JSON
→ difícil versionar · menos controle de erro
deploy · escalabilidade
Antigravity
Antigravity como camada de deploy e execução assíncrona. Recebe o GenerationPlan JSON e distribui tasks em workers GCP Cloud Run. Scaling automático por domínio.
✓ deploy nativo GCP · queue built-in · auto scaling
→ dependência de infra externa
// crews por módulo
SpecCrew
SpecParser · DomainValidator · PlanEmitter
yaml_loader · schema_validator · dag_builder
OntologyCrew
ClassBuilder · RelationMapper · SPARQLWriter
owlready2 · text2onto_wrapper · fuseki_client
BackendCrew
ModelBuilder · EndpointWriter · TestWriter
fastapi_codegen · alembic_gen · pytest_scaffold
FrontendCrew
ComponentArchitect · StoreBuilder · DesignReviewer
react_scaffold · zustand_gen · skill_loader
InfraCrew
DockerComposer · TraefikRouter · EnvManager
compose_template · traefik_config · secrets_vault
DocsCrew
SpecWriter · DeckBuilder · SkillMapper
docx_skill · pptx_skill · skill_md_writer
// 05 · langgraph stategraph

GeneratorState
+ edges

TypedDict compartilhado entre todos os nós. Três checkpoints Redis. Edges condicionais com roteamento baseado em estado.

from langgraph.graph import StateGraph, Send
from typing import TypedDict

class GeneratorState(TypedDict):
  spec_path: str
  spec_raw: str
  spec_parsed: dict
  spec_valid: bool
  errors: list[str]
  generation_plan: dict
  artifacts: dict # ontology|backend|frontend
  infra_config: dict
  docs_paths: list[str]
  deploy_url: str | None
  smoke_passed: bool
  retry_count: int

# roteamento condicional
def route_after_parse(state):
  if not state["spec_valid"]:
    return "error_report"
  return "resolve_extends"

def fan_out_crews(state):
  return [
    Send("ontology_crew", state),
    Send("backend_crew", state),
    Send("frontend_crew", state),
  ]

def route_after_join(state):
  if all_ready(state["artifacts"]):
    return "infra_crew"
  if state["retry_count"] < 3:
    return "fan_out_crews"
  return "error_report"

Edges condicionais

parse_and_validate → ?
spec_valid == False → error_report → END err
spec_valid == True → resolve_extends
emit_generation_plan → fork
Send API dispara 3 crews em paralelo
checkpoint 1 antes do fork
join_artifacts → ?
all_ready → infra_crew
retry_count < 3 → fan_out_crews (retry)
retry_count ≥ 3 → error_report
deploy → ?
smoke_passed → END ✓
smoke fail → docs_crew (re-gera)
checkpoints Redis
gen:{run_id}:plan  → após emit_generation_plan
gen:{run_id}:artifacts  → após join_artifacts
gen:{run_id}:deployed  → após deploy ✓
// 06 · stack técnica

12 tecnologias

Stack consolidada do STRATAGO — cada peça testada em produção nos módulos existentes.

TRK
Traefik v3
Proxy reverso · Let's Encrypt · sub-domínio por módulo
RCT
React 18 + Vite
TypeScript · Zustand · design Obsidiana & Âmbar
API
FastAPI async
asyncpg · Pydantic v2 · engines injetadas
PG
Postgres + pgvector
Schema isolado por domínio · Alembic migrations
N4J
Neo4j
Grafos de domínio · ontologia navegável · Cypher
RDS
Redis Streams
Cache + event streaming · checkpoint LangGraph
PRO
Prometheus + Grafana
Observability · métricas por domínio · alertas
CHR
ChromaDB
Vector store RAG · coleção por domínio
CLd
Claude Sonnet 4
LLM · SKILL.md + specs · MCP tools
CRW
CrewAI
Crews especializadas · agents + tools por crew
LGR
LangGraph
StateGraph · checkpointing · conditional edges
AGV
Antigravity · GCP
Deploy automatizado · Cloud Run · smoke tests
// 07 · plano de implementação

8 sprints · 16 semanas

Da DSL parser ao gerador completo em produção. Cada sprint entrega um artefato verificável.

S1 DSL Core sem 1–2
Definir JSON Schema STRATAGO-DSL v1
Parser YAML com validação e erros por path
Lógica de resolução de extends (deep merge)
CLI: stratago parse spec.yaml
Testes unitários schema + merge
→ stratago_dsl.py + test suite
S2 StateGraph sem 3–4
GeneratorState TypedDict com todos os campos
StateGraph: nós load_spec, parse, validate, resolve
Edges condicionais de roteamento de erro
Checkpointing Redis (3 pontos)
Testes de integração do grafo
→ generator_graph.py
S3 Crews Base sem 5–6
SpecCrew: SpecParser + PlanEmitter
OntologyCrew: ClassBuilder + SPARQLWriter
emit_generation_plan → DAG JSON
Fork paralelo via Send API
join_artifacts com retry logic
→ crews/spec + crews/ontology
S4 BackendCrew sem 7–8
ModelBuilder: Pydantic + SQLAlchemy por entidade
EndpointWriter: rotas FastAPI async
Engine injector: DS, MACBETH, FuzzyAHP, LPA₂v
Alembic migration generator
TestWriter: pytest fixtures > 80% coverage
→ crews/backend + engine_injector.py
S5 FrontendCrew sem 9–10
ComponentArchitect: React 18 + TypeScript scaffold
StoreBuilder: Zustand store a partir de endpoints
Wizard generator para features wizard[]
DesignReviewer: valida contra SKILL.md frontend-design
Sub-domínio Traefik por módulo
→ crews/frontend + wizard_gen.py
S6 InfraCrew sem 11–12
DockerComposer: compose overlay por domínio
TraefikRouter: certresolver + labels
EnvManager: secrets vault + .env gerado
Prometheus scrape config por serviço
Health check endpoints
→ crews/infra + compose_templates/
S7 DocsCrew sem 13–14
SkillMapper: carrega SKILL.md antes de gerar
SpecWriter: docx técnico via docx skill
DeckBuilder: pptx 12 slides via pptx skill
SKILL.md do domínio para reutilização
PDF report template via pdf skill
→ crews/docs + domain_skill_gen.py
S8 Deploy + CLI sem 15–16
Antigravity integration: push GCP Cloud Run
Smoke test runner: healthcheck + auth + sim
CLI completa: stratago generate spec.yaml
LangFlow export do pipeline
Documentação: README + SKILL.md do Generator
→ stratago-generator v1.0 · produção
// próximos passos

Pronto para
gerar o
primeiro SaaS

Comece pelo Sprint 1 — o DSL parser é o bloco fundamental. Com ele validado, os demais sprints seguem em sequência natural até o gerador completo em produção.

Gerar StateGraph Python Gerar SKILL.md
domínios já implementados
AI Impact Simulator ✓ Stratago Harness ✓ Valuation Module ✓ Urban Intelligence Loyalty Engine Creative Economy Hub