Por que eu comecei esse projeto

Tudo começou com uma frustração real. Eu estava estudando treinamento de LLMs e consegui resultados muito bons — fiz uma micro-LLM de 0.5B atingir 100% de acurácia matemática usando Raciocínio Latente e TV-DSL. Depois disso, comecei a trabalhar em algo mais ambicioso: mesclar 5 arquiteturas de llm que eu imaginei e já havia testado separadamente, usando diferentes formas de pensamento e raciocinio para criar algo novo(Como o LLM cuspir um DNA @!12, que seria correspondente a "Oi, como você está" sem precisar gerar todos os tokens com uma lingua intermediaria). Mas esbarrei num muro: treinar um LLM de 1B-7B do zero ia me custar mais de R$ 1.000 só em compute, e os conceitos que eu estava testando (que estão em repositórios privados) ainda não estavam maduros o suficiente para justificar esse gasto.

Então mudei a direção. Pensei: antes de treinar meu próprio modelo, eu preciso de uma ferramenta que trabalhe do jeito que eu preciso, sem ficar dependente de terceiros. Eu estava usando o Antigravity, o Claude Code, estudando o Void... e percebi que eu estava construindo projetos inteiros em cima de ferramentas que eu não controlava totalmente e não sabia como funcionava na palma da mão. Se elas mudassem o preço, a política de acesso, ou simplesmente sumissem, eu iria diminuir minha produtividade e estudos abruptamente.

O crom-agente nasceu dessa necessidade: construir o meu próprio agente autônomo de código que eventualmente me torne independente dessas mesmas ferramentas que me ajudaram a criá-lo. Uma espécie de bootstrapping — o projeto nasce com ajuda externa, mas amadurece até dispensá-la.

📐 O que eu estudei e o que copiei

Eu não inventei nada do nada. Estudei a fundo como as ferramentas que eu mais usava funcionavam por dentro e extraí a lógica de cada uma:

Antigravity (IDE, SDK e Antigravity 2): Estudei toda a estrutura em camadas. A ideia de ter um Daemon persistente rodando em segundo plano, se comunicando via gRPC/WebSockets com uma IDE e um SDK separado, veio diretamente de como o Antigravity organiza seus componentes. Copiei essa filosofia de micro-módulos independentes — cada parte do sistema é um repositório separado, com responsabilidade única.

Claude Code: Estudei o fluxo de execução no terminal, como ele diferencia um processo de build que termina de um servidor HTTP que fica rodando, e o tratamento de Prompt Caching para reduzir custos quando o histórico de chat fica gigante. Mas o Claude Code é preso ao ecossistema da Anthropic e roda em Node.js — eu queria algo compilado, rápido e multi-provedor.

Void (Fork Open Source do VS Code): Analisei como eles integraram IA direto no buffer do editor, aplicando substituições de código em tempo real via diff, sem passar pelas limitações de uma extensão convencional. Esse estudo é a base para o futuro crom-agente-ide — o nosso fork do VS Code especializado para o agente.

O SDK do Antigravity também foi uma referência direta. A forma como ele abstrai a comunicação entre o cliente e o daemon, mantendo o estado da sessão mesmo quando o serviço reinicia, foi algo que repliquei no crom-agente-sdk.

🏗️ A Arquitetura em Camadas

O ecossistema foi dividido em camadas independentes. Cada uma é um repositório separado no GitHub:

flowchart TD
    subgraph CLOUD ["Camada Cloud"]
        Site["cromia-site"]
        CloudPortal["crom-agente-cloud"]
        API["cromia-api"]
        
        Site -->|Docs| CloudPortal
        CloudPortal -->|Auth e VPS| API
    end

    subgraph PROVIDERS ["Provedores de LLM"]
        Ollama["Ollama (Local)"]
        OpenRouter["OpenRouter"]
        CromIA["CromIA Cloud"]
        Qualquer["Qualquer Provedor OpenAI-Compatible"]
    end

    API -->|Roteamento| OpenRouter
    API -->|Roteamento| CromIA

    subgraph LOCAL ["Máquina do Usuário"]
        Daemon["crom-agente (Go)"]
        SDK["crom-agente-sdk (TS/Go)"]
        
        Daemon -->|Via API| API
        Daemon -->|Direto, sem nuvem| Ollama
        Daemon -->|Qualquer endpoint| Qualquer
        
        subgraph INTERFACES ["Interfaces"]
            CLI["crom-agente-cli (Terminal)"]
            App["crom-agente-app (Desktop)"]
            IDE["crom-agente-ide (VS Code Fork)"]
        end

        CLI --> SDK
        App --> SDK
        IDE --> SDK
        
        SDK -->|IPC / WebSocket / gRPC| Daemon
    end

    style Site fill:#1e1e2f,stroke:#ff007f,stroke-width:2px,color:#fff
    style CloudPortal fill:#1e1e2f,stroke:#ff007f,stroke-width:2px,color:#fff
    style API fill:#1e1e2f,stroke:#ff007f,stroke-width:2px,color:#fff
    style Daemon fill:#0f172a,stroke:#3b82f6,stroke-width:2px,color:#fff
    style SDK fill:#0f172a,stroke:#3b82f6,stroke-width:2px,color:#fff
    style CLI fill:#1c1917,stroke:#10b981,stroke-width:2px,color:#fff
    style App fill:#1c1917,stroke:#10b981,stroke-width:2px,color:#fff
    style IDE fill:#1c1917,stroke:#10b981,stroke-width:2px,color:#fff

Camada 1 — O Core: `crom-agente`

https://github.com/MrJc01/crom-agente
O daemon escrito em Go que roda localmente. Ele executa o loop ReAct (Reasoning and Acting), gerencia ferramentas no terminal via PTY com sandbox, e suporta múltiplos agentes rodando em paralelo usando goroutines.

Camada 2 — O SDK: `crom-agente-sdk`

https://github.com/MrJc01/crom-agente-sdk
Wrappers em TypeScript e Go que abstraem a comunicação com o daemon. Qualquer interface (CLI, App, IDE, ou algo que alguém da comunidade queira criar) usa o SDK para se conectar ao agente via IPC, WebSocket ou gRPC.

Camada 3 — As Interfaces

crom-agente-cli: TUI no terminal usando Charmbracelet (bubbletea/lipgloss). https://github.com/MrJc01/crom-agente-cli
crom-agente-app: Aplicação desktop feita em Tauri + React com dark mode e acompanhamento visual do loop do agente.
https://github.com/MrJc01/crom-agente-app (PRIVADO)
crom-agente-ide: O objetivo futuro — um fork do VS Code totalmente modificado para integrar o agente no nível do editor, não como extensão, mas como parte nativa da IDE. O objetivo é especializar o agente em código e suprimir a minha própria necessidade de usar Cursor, Antigravity ou qualquer outra IDE de terceiros.
https://github.com/MrJc01/crom-agente-ide (PRIVADO)

Camada 4 — A Cloud: `cromia-api` e `crom-agente-cloud`

https://github.com/MrJc01/cromia-api
https://github.com/MrJc01/crom-agente-cloud (PRIVADO)
A API Gateway em Go que roteia chamadas para os provedores de LLM, autentica o usuário, mede tokens em tempo real via streaming SSE e cobra em Croms (a moeda interna do projeto). O painel cloud é onde o usuário gerencia sua conta, compra saldo e pode provisionar um agente rodando numa VPS 24/7.

Provedores: Use o que quiser

O agente não te prende a nenhum provedor. Você pode usar:

Ollama rodando na sua máquina, sem internet.
OpenRouter para acessar dezenas de modelos diferentes.
A própria CromIA Cloud como roteador de IA que também ajuda a financiar atualizações do projeto.
Qualquer endpoint compatível com a API OpenAI — é só configurar a URL e a chave.

🧠 O Loop ReAct

Toda execução do agente segue o padrão ReAct: o modelo pensa, decide uma ação, o daemon executa dentro do sandbox, e o resultado volta pro modelo para a próxima iteração. Ações sensíveis (como rodar comandos no terminal) passam por aprovação do usuário (HITL — Human-in-the-Loop).

sequenceDiagram
    autonumber
    participant Dev as Usuário
    participant Daemon as crom-agente
    participant SDK as SDK
    participant LLM as Provedor LLM

    Dev->>SDK: Envia tarefa
    SDK->>Daemon: Solicita execução via IPC
    
    loop Loop ReAct
        Daemon->>LLM: Envia histórico e lista de ferramentas
        LLM-->>Daemon: Resposta com texto ou chamada de ferramenta
        
        alt Ferramenta requer permissão
            Daemon->>Dev: Pede autorização
            Dev-->>Daemon: Aprova ou recusa
        end
        
        alt Permissão concedida
            Daemon->>Daemon: Executa no sandbox
            Daemon->>Daemon: Captura saída
        end
        
        Daemon->>Daemon: Injeta resultado no histórico
    end
    
    Daemon-->>Dev: Tarefa concluída

📦 Repositórios — O que é Público e o que é Privado

Repositórios Públicos (Acessíveis agora)

Repositório	Descrição	Link
crom-agente	O daemon core do agente em Go	GitHub
crom-agente-sdk	SDK em TypeScript e Go para integração	GitHub
crom-agente-cli	Interface de terminal TUI (Charmbracelet)	GitHub
cromia-api	API Gateway / Proxy de LLMs / Billing	GitHub
cromia-site	Site institucional (PHP/Yii2)	GitHub

Repositórios Privados (Por enquanto)

Repositório	Descrição	Motivo
crom-agente-app	Aplicação desktop (Tauri + React)	Em amadurecimento, será aberto na meta
crom-agente-cloud	Infraestrutura cloud, Docker, painel de usuário	Sustentabilidade financeira do projeto
crom-agente-ide	Fork do VS Code com integração nativa do agente	Em estágio de amadurecimento

📜 Licenciamento

A licença atual do projeto é privada. Mas o objetivo final é MIT.

A razão de manter uma licença restritiva neste momento não é para desmotivar ninguém — é estratégia. O projeto ainda está em alpha, e precisamos garantir que o ecossistema amadureça financeiramente antes de abrir tudo. Quando as metas forem atingidas, a licença vira MIT e qualquer pessoa pode usar, modificar e distribuir sem restrição.

Se você pretende usar o crom-agente para criar um produto comercial e sabe que o faturamento vai ultrapassar o que a licença atual permite, entre em contato comigo diretamente em mrj.crom@gmail.com. Conversamos, ajustamos uma licença que funcione para os dois lados, e seguimos em frente. O objetivo nunca foi travar o acesso — é manter o controle enquanto o projeto ainda não é estável.

🎯 Metas e o Caminho para o MIT

Temos duas metas claras para liberar tudo sob a licença MIT:

Meta de Lucro: R$ 10.000.000 (dez milhões de reais) em receita gerada pelo projeto.
Meta de Doações: R$ 5.000.000 (cinco milhões de reais) em doações da comunidade.

Atingindo qualquer uma das duas, a licença vira MIT.

Como o dinheiro será usado

90% vai para investimento em hardware e pesquisa — compra de GPUs para treinamento de modelos de IA do zero no Brasil, manutenção de servidores e infraestrutura.
10% vai para garantir uma renda mínima para os desenvolvedores que mantêm o projeto vivo no dia a dia.

O contexto por trás dessas metas

Eu estudei e publiquei sobre treinamento de LLMs. Consegui resultados com modelos pequenos. Depois comecei a trabalhar em 5 arquiteturas mescladas para algo maior, mas o custo de treinar um modelo de 7B do zero (mais de R$ 1.000 em cada tentativa) tornou inviável continuar sem uma fonte de receita própria. Os conceitos que desenvolvi estão em repositórios privados e ainda não estão prontos para uso.

Por isso mudei o foco: antes de treinar o modelo, eu preciso do produto que paga pelo treinamento. O crom-agente é esse produto. O lucro gerado por ele vai diretamente para o financiamento do treinamento de modelos nacionais, usando os dados que já temos (como o crom-tabnews-db com 20.857 posts) e as técnicas que já validamos (como o Think-Vetor).

🎥 Vídeos de Testes em Execução

Para ver o agente funcionando na prática:

Acessos

https://ia.crom.run/

https://cloud.ia.crom.run/

🔧 Instalação e Uso Rápido

Instalação Completa (tudo de uma vez)

Com um único comando, você instala o App Desktop, o CLI e o Daemon:

curl -sSL https://cloud.ia.crom.run/install.sh | bash -s all

Ou rode sem argumentos para abrir o menu interativo e escolher o que instalar:

curl -sSL https://cloud.ia.crom.run/install.sh | bash

Instalação Modular

Se quiser instalar só o que precisa:

# Apenas o App Desktop (Tauri + React)
curl -sSL https://cloud.ia.crom.run/install.sh | bash -s app

# Apenas o CLI (interface de terminal)
curl -sSL https://cloud.ia.crom.run/install.sh | bash -s cli

# Apenas o Daemon (motor em background)
curl -sSL https://cloud.ia.crom.run/install.sh | bash -s daemon

Usando o CLI

Depois de instalado, é só rodar no terminal do seu projeto:

# Com Ollama local (sem internet, sem custo)
crom-agente-cli --provider ollama --model llama3

# Com OpenRouter
crom-agente-cli --provider openrouter --model google/gemini-2.5-flash

# Sessão persistente (salva contexto entre execuções)
crom-agente-cli --session meu-projeto --provider openrouter --model deepseek/deepseek-chat

Atualizar para a última versão:

crom-agente-cli update

Slash commands dentro do chat:

Comando	O que faz
`/add caminho/arquivo.go`	Anexa o conteúdo do arquivo no próximo prompt
`/session nome`	Troca de sessão preservando histórico
`/clear`	Limpa a tela
`/exit`	Sai do CLI

SDK em TypeScript (via NPM)

Para construir seus próprios aplicativos integrados com o agente:

npm install crom-agente-sdk

Exemplo básico — conectar ao daemon e conversar:

import { CromClient } from 'crom-agente-sdk';

// Conecta na porta local padrão do daemon
const client = new CromClient({ daemonPort: 9090 });

// Envia uma instrução
const res = await client.chat("Liste a pasta atual");
console.log(res.answer);

// Acompanha eventos em tempo real
client.on('tool_execution', (event) => {
  console.log("Executando:", event.action);
});

Operações diretas via SDK:

// Ler e escrever arquivos pelo daemon
const conteudo = await client.readFile('/home/user/projeto/main.go');
await client.writeFile('/home/user/projeto/TODO.md', '# Tarefas\n- [ ] Item 1');

// Buscar modelos disponíveis na CromIA Cloud
const modelos = await client.getCloudModels();

// Agendar tarefa recorrente
await client.addScheduledTask({
  name: 'backup-diario',
  cron: '0 3 * * *',
  workspace: '/home/user/projeto',
  task: 'Faça um commit de backup com a mensagem "backup automático"'
});

Repositório do SDK: github.com/MrJc01/crom-agente-sdk

🤝 Participe

Estamos sempre procurando pessoas interessadas — devs, pesquisadores, ou qualquer um que queira contribuir com código, testes, documentação ou infraestrutura.

GitHub: MrJc01
E-mail: mrj.crom@gmail.com
Hugging Face: CromIA
Discord: Servidor da Crom

🏗️ A Jornada do crom-agente: Como Estou Construindo um Agente de IA Autônomo do Zero | Go | SDK, CLI, APP, IDE | NPM