Uma nova forma de codar, no formato que você escolher.
Amot é um workspace que se adapta a você. Ferramentas como editor de código, terminais com agentes, notes de contexto, tarefas, e preview ao vivo. Todas organizadas do jeito que fizer sentido pro seu momento: espalhadas livremente num canvas infinito, ou concentradas numa view de código tradicional. Tudo dentro do mesmo app, sem trocar de ferramenta no meio do trabalho.
Windows · macOS · Linux
Cada ferramenta é um bloco que você posiciona: o editor onde você escreve, o terminal do agente, as notes que o alimentam e o portal que mostra o resultado.
Nada de fluxograma de nodes. São as suas ferramentas, no lugar onde você as deixou.
PTY
Terminal de verdade, não emulado
MCP nativo
Protocolo no core, não wrapper
Rust + Tauri
NÃO ELECTRON
3 ambientes
Windows, macOS e Linux
Várias ferramentas, um workspace só.
01
Visões do workspace
Espalhe tudo livremente num canvas infinito com zoom e pan, ou concentre o trabalho numa view de código tradicional. Você troca quando o momento pedir, sem perder onde cada coisa estava.
02
Terminais com PTY
Cada bloco de agente é um pseudo-terminal de verdade, aberto pelo processo em Rust. Prompt interativo, cores ANSI, Ctrl-C, TUI que redesenha: o agente roda igual ao seu terminal porque é um terminal.
03
Notes como contexto
Decisões de arquitetura, convenções, o que já foi tentado. A note fica ao lado do agente e entra no contexto dele. Você escreve uma vez e para de repetir a mesma instrução em todo prompt.
04
Portal com preview ao vivo
Um navegador embutido apontado para o seu dev server. O agente edita, o Vite recarrega, o portal mostra, no mesmo canvas, ao lado do terminal que fez a mudança. Vibe coding com o resultado à vista.
05
Tarefas no canvas
O que precisa ser feito fica onde vai ser feito, ao lado do agente responsável. Sem quadro Kanban em outra ferramenta.
06
MCP nativo
O Amot fala MCP no próprio core: um agente externo pode ler o canvas, criar blocos e acompanhar o trabalho sem plugin intermediário.
07
Code integrado
O Amot não é só um canvas. Quem gosta de ver, editar e acompanhar o código trabalha direto no editor embutido: você abre o arquivo que o agente acabou de mexer, revisa a mudança e escreve por cima, sem sair do workspace.
Um agente não é um chat. É um cargo.
Cada bloco recebe um papel com escopo, contexto e limite de alçada. O Tech Lead quebra a demanda e distribui; os devs executam no que é deles; você revisa no fim, como faria com gente.
Os papéis são configuráveis: a hierarquia abaixo é o padrão que vem pronto.
Tech Lead
Recebe a demanda, decide a abordagem, abre as tarefas e distribui para os papéis abaixo.
Dev Frontend
Componentes, estado, o que aparece no portal.
Dev Backend
Rotas, dados, integrações e migrações.
QA
Roda, quebra e reporta antes de você ver.
Você pede uma vez. A equipe se organiza no workspace.
O caminho de um comando
Do prompt até o pixel na tela, sem camada escondida.
- 01
Você escreve no bloco do agente. A UI é React, renderizada na webview nativa do sistema pelo Tauri, sem Chromium empacotado junto.
- 02
O core em Rust abre um PTY. Um pseudo-terminal por bloco, com o mesmo shell, as mesmas variáveis de ambiente e as mesmas credenciais que você já usa na sua máquina.
- 03
O agente roda como CLI. Claude Code, OpenCode ou qualquer outro binário de linha de comando: o Amot não reimplementa o agente, ele hospeda o processo.
- 04
Notes e tarefas entram como contexto. O que está ligado ao bloco é montado no prompt antes de chegar ao agente: explícito e visível no canvas.
- 05
O portal reflete o resultado. Um navegador embutido no app aponta para o seu dev server e recarrega junto com ele.
- 06
O canvas fica em disco, no seu projeto. Nada de servidor obrigatório no meio: o estado do workspace é um arquivo local que você versiona se quiser.
Conecte um agente ao Amot em um comando.
O servidor MCP faz parte do core. Um agente conectado enxerga o canvas como estrutura (blocos, papéis, notes, tarefas) e pode criar e atualizar o que precisa enquanto você acompanha na tela.
# [comando de conexão MCP a definir]
$ [preencher com o comando real]
Você vê o que a IA está fazendo, e onde ela para.
Saída completa, não resumida
Tudo que o agente imprimiu fica no bloco, do primeiro comando ao último erro. Sem log escondido em outra janela.
Escopo por papel
Cada agente trabalha no diretório e no escopo do cargo dele. O que não é dele, ele não tem por que tocar.
Local por padrão
O código, as notes e o canvas ficam na sua máquina. O que sai é o que o agente que você escolheu manda para o provedor dele.
Interrupção a qualquer momento
É um PTY: Ctrl-C funciona. Você para o agente no meio da frase, corrige a note e manda de novo.
[depoimentos: adicionar quando houver usuários reais]
Espaço reservado para citações de usuários e, se fizer sentido depois, métricas de uso. Nada aqui foi inventado.
Perguntas diretas
O Amot substitui o Claude Code ou o OpenCode?
Não. Ele hospeda os agentes que você já usa, cada um no seu terminal, e cuida do workspace em volta: editor, contexto, papéis, tarefas, preview e a organização das views.
Preciso de chave de API própria?
Você usa a autenticação do agente que escolheu, exatamente como no terminal. O Amot não fica no meio dessa relação.
Funciona com qualquer projeto ou só com Vite e Next.js?
O terminal roda qualquer coisa. O portal aponta para qualquer URL local, então o foco inicial é em projetos web com dev server (Vite, Next.js, React), mas nada impede outros stacks.
É Electron?
Não. Tauri com core em Rust e a webview nativa do sistema operacional.
Meu código sai da minha máquina?
O Amot é um app local: canvas, notes e arquivos ficam com você. O que trafega é o que o agente escolhido envia ao provedor dele, sob as regras desse provedor.
Quanto custa?
[preço a definir]
