Terminal multipainel
Agentes concorrentes, cada um no próprio PTY e no próprio grupo de processos do sistema, cada um com um terminal vivo onde você pode digitar.
Tudo o que o Maegor faz hoje, agrupado por onde você encontra cada coisa. Nada nesta página é plano: se está listado aqui, está construído e coberto por testes.
Onde você acompanha o trabalho acontecendo.
Agentes concorrentes, cada um no próprio PTY e no próprio grupo de processos do sistema, cada um com um terminal vivo onde você pode digitar.
Divida, redimensione e reorganize. O arranjo é uma árvore salva por projeto, então ele sobrevive à missão que o criou.
Uma segunda casa que sobrevive a toda missão: um painel por agente, uma conversa que você retoma em vez de um processo que você reinicia.
Um painel é um contêiner, não um slot de terminal. Terminal, editor, explorador de arquivos e preview do navegador dividem a mesma grade.
Monaco sobre a árvore do projeto, em sandbox e resolvendo symlinks. Um arquivo sob lease de escrita ativo abre somente leitura e diz qual agente o segura.
Acha a URL do dev server na saída do agente e encaixa ao lado do terminal, em largura de desktop, tablet ou celular. Ele nunca divide sua grade por palpite.
Toda ação do aplicativo alcançável sem tirar as mãos do teclado.
Um briefing vira um grafo, e o grafo vira trabalho.
Dependências e grupos paralelos, com ciclos e dependências órfãs recusados em tempo de planejamento, antes de qualquer agente ser despachado.
Livre conduz um agente na sua mão, Squad roda um time declarativo, Agêntico deixa o Maegor decompor e delegar. Mesmo core, quantidades diferentes de autonomia.
O orquestrador pergunta o que precisa antes de planejar, e suas respostas viram parte do briefing. Onde uma resposta contradiz uma suposição, a resposta vence.
Agentes enviam revisões e achados por MCP. Uma revisão rejeitada devolve a tarefa em vez de integrar em silêncio.
O git diff real do worktree do agente, ao lado do gate que o julgou.
Os relatórios, specs e contratos que um agente produziu, endereçados por missão e tarefa e legíveis muito depois da sessão ter acabado.
Quem faz o trabalho, e no que cada um tem permissão de ser bom.
Times declarativos em YAML: papéis, modelos, globs de arquivo, gates e orçamentos. Quatorze vêm com o app, do Solo de um agente ao web de doze.
Escreva um squad dentro do app e tenha a validação no salvamento, com o campo problemático nomeado.
Uma CLI, um modelo, um conjunto de skills e um nível de esforço compostos em um especialista que você pode despachar de novo.
O elenco de especialistas que um projeto acumulou, reutilizável entre as missões dele.
Uma capacidade instalável que se acopla a um agente e passa a valer na próxima execução dele.
Os agentes que você já paga, conduzidos de um lugar só.
Claude Code, Codex e OpenCode conduzem os binários que você já tem. A detecção executa cada um, ela nunca confia em arquivo de configuração, e toda flag foi lida de um help local.
Um agente headless que continua vivo entre os turnos: o próximo prompt é uma linha escrita em um stdin que nunca fechou, então não há partida a frio nem contexto perdido.
O loop de ferramentas do próprio Maegor, para o trabalho onde não existe CLI de terceiro que valha conduzir.
Um painel sem agente nenhum dentro, na mesma grade e sob o mesmo kill switch.
A saída headless vira eventos tipados, e o painel avisa quando o mapeamento degrada em vez de fingir que entendeu.
Verificações no runtime, não linhas em um prompt.
Um worktree git e um branch próprios para cada agente em execução. As escritas de um agente nunca chegam à sua árvore de trabalho.
Dois agentes que poderiam escrever no mesmo arquivo são recusados no despacho, por interseção de globs, não quando o merge desanda.
Os gates rodam dentro do worktree do agente contra o git diff real. Um gate obrigatório que falha bloqueia a integração.
Encerra grupos de processos inteiros, netos incluídos. Um teste cria um neto e afirma que ele morre.
SIGSTOP e SIGCONT, por agente ou pela missão inteira, sem perder o terminal.
Comandos destrutivos, escritas fora de escopo e estouro de orçamento param o agente até você decidir. Um pedido expirado é uma recusa, nunca uma aprovação.
Um teto de tempo real e um timeout de heartbeat pegam um agente travado, encerram e registram o motivo.
Sessões que o banco ainda acredita estarem rodando são marcadas como órfãs quando o projeto abre. Nada é retomado automaticamente depois de um crash.
Detecção tokenizada de comandos destrutivos, sandbox de caminhos que resolve symlinks e redação de segredos no caminho de persistência. Os modos mudam com que frequência você é consultado, nunca se a verificação roda.
Um teto por missão. Estourar para o agente e consulta você, não sai gastando calado.
O que um projeto lembra entre uma missão e a próxima.
Missão, projeto e agente. O nível de projeto é o motivo de a segunda missão em um repositório sair mais barata que a primeira.
As entradas se ligam entre si, então o caminho mais curto entre duas delas é uma consulta, não uma rolagem.
O construtor escolhe o que é relevante dentro de um teto explícito de tokens, em vez de colar tudo o que tem e torcer.
Tipado e append-only sobre SQLite, pesquisável e filtrável por agente, tarefa, tipo, severidade e texto livre.
Custo ao vivo por agente, com a origem etiquetada. Quando o provedor não reporta nada, a resposta é desconhecido, nunca $0.00.
As outras portas de entrada.
Vinte e oito ferramentas sobre missões, tarefas, memória, artefatos, leases e gates, atrás de um token por missão. Toda ferramenta confere se o id pertence à sessão que chamou.
O binário maegor e o aplicativo desktop compartilham um core de domínio em Rust: mesma máquina de estados, mesmo banco, mesmo log de eventos.
Um serviço de fala local e opcional para descrever uma missão em voz alta. Nada sai da máquina.
Confere a instalação, os adapters detectados e os worktrees que uma missão cancelada deixou para trás.
Um agente falso determinístico com seis comportamentos roda o produto inteiro sem rede e sem gasto de LLM.
Um squad é um arquivo YAML: papéis, modelos, globs de arquivo, gates, orçamentos. Quebre um campo e ele diz qual, antes de qualquer coisa rodar. Quatorze já vêm com o app.
Implementa uma feature inteira entre backend e frontend, em paralelo, contra um contrato que os dois lados tratam como congelado.
Constrói uma feature web inteira, da descoberta à revisão. Sequencial de propósito, para cada handoff ser contra o que foi entregue de verdade.
Varre o código por área em paralelo, depois triagem, correção e um teste que trava o resultado.
Reproduz o defeito, corrige a causa raiz e trava com um teste.
Encontra vulnerabilidades, segredos e dependências arriscadas, depois corrige o que importa.
Planeja, aplica e verifica a mudança de schema, com backfill e segurança de rollback.
Implementa uma feature entre um core em Rust e um shell em React, regerando os tipos compartilhados no meio do caminho.
Aumenta a cobertura sem tocar em código de produção, com gate no delta real.
Remove código morto e duplicação com o comportamento comprovadamente inalterado.
Desenha um contrato de API e o trava com testes dos dois lados.
Sobe dependências em grupos revisáveis, verificando a árvore depois de cada um.
Acha gargalos com evidência, otimiza e prova o ganho com benchmarks.
Divide uma árvore de trabalho suja em um commit por mudança lógica, cada um com uma mensagem que a nomeia, e faz o push.
Um agente faz tudo, para um briefing pequeno demais para os handoffs valerem o que custam.
Abra um repositório, descreva uma missão e veja quatro agentes trabalhando em paralelo, dentro das regras que você definiu.
Nenhum crédito é queimado na demo, um agente falso determinístico roda a suíte inteira.