Lançado aiterm-mcp no npm: Um Servidor MCP para Reduzir o Uso de Tokens ao Fornecer um Terminal Persistente para IA

Eu publiquei um servidor MCP chamado aiterm-mcp no npm. Ele foi projetado para permitir que uma IA mantenha um terminal como uma "sessão persistente única".

Tarefas de terminal de IA consomem tokens invisivelmente

Ao fazer uma IA executar tarefas no servidor, você geralmente envia um comando por vez. Para SSH, isso significa ssh host "comando" toda vez. Isso repete o ciclo completo "conectar → autenticar → executar → desconectar" para cada tentativa.

O problema é que, como começa do zero toda vez, nenhum estado permanece. O diretório em que você cd'd, o ambiente que você source'd e a conexão SSH que você estabeleceu desaparecem no próximo comando. Portanto, a IA tem que fazer isso toda vez:

• Conectar via SSH novamente,
• Mudar de diretório novamente,
• Carregar o ambiente novamente,

...e só então finalmente executar o comando real. Este "conjunto de operações de repetição" é escrito pela IA e lido por você toda vez que ela envia um comando. O texto relacionado à reconexão, re-autenticação e re-configuração—nada disso se relaciona à tarefa real—se acumula no contexto a cada vez. Tokens estão se dissolvendo em repetições redundantes que não produzem nada.

aiterm oculta isso. Ele mantém apenas um terminal persistente, e o SSH é estabelecido apenas uma vez. Se você executar 10 comandos, ssh é chamado apenas para o primeiro. Conexões e autenticações são reduzidas de N vezes para apenas uma. O cd e o ambiente permanecem da primeira vez também. Todos os comandos subsequentes são enviados diretamente através da mesma sessão única. Todo o conjunto de operações de repetição simplesmente desaparece.

Eu medi quanto isso economiza no meu próprio servidor. Ao fazer login via SSH, o texto padrão (informações do sistema e anúncios, ou seja, MOTD) sozinho passa cerca de 385 tokens para a IA. No modo fragmentado, onde você reconecta para cada comando, isso é incluído toda vez. Para uma tarefa de 10 comandos, isso representa cerca de 3.800 tokens apenas em texto padrão antes mesmo de chegar ao trabalho real. Ao manter um terminal, você paga por isso uma vez. O resto é zero.

Podando a saída antes de ler

Há mais um nível de economia de tokens. aiterm poda a saída antes que a IA a leia.

Divulgação completa: essa lógica de redução não é minha invenção. Eu portei a lógica de rtk (Rust Token Killer) inteiramente. rtk é uma ferramenta criada por Patrick Szymkowiak que comprime a saída de comandos antes de passá-la para um LLM (Apache-2.0). Eu a reimplementei em aiterm para que ela seja concluída dentro do processo de leitura do terminal sem chamar um binário separado (os arquivos não foram duplicados, mas o comportamento foi igualado; resumos do pytest foram corrigidos com testes de regressão para corresponder ao rtk 0.42.0).

O que ele faz:

• Remove caracteres de controle (cores e movimentos do cursor)
• Agrupa linhas repetidas em contagens
• Trunca saídas que são longas demais, deixando a cabeça e a cauda (com dicas para restauração)
• Resume comandos comuns como git status / git log / grep / pytest em pontos-chave usando resumidores específicos de comando

No meu próprio servidor, eu medi a saída recebida pela IA como "crua" versus "via aiterm".

Quanto mais isso corta depende do conteúdo. Logs com muitas repetições caem significativamente (-61% para 120 linhas). Por outro lado, tabelas largas com apenas valores únicos (como a lista de containers) apenas diminuem em -6%. Não é mágica que reduz tudo por uma porcentagem fixa, mas sim "aparar apenas o desperdício". Mesmo assim, combinado com o fato de não ter que ler o texto padrão de reconexão toda vez, os tokens definitivamente param de se acumular.

Não era apenas um problema de tokens

Até este ponto, tem sido sobre economizar tokens. Mas a abordagem fragmentada "1 comando = 1 conexão" teve um efeito colateral ainda menos engraçado.

Quando você repete conexões em um ritmo rápido, as defesas do seu servidor decidem que você é um atacante.

• Ferramentas de monitoramento que rastreiam tentativas de login veem conexões consecutivas como um ataque de força bruta e banem você.
• Você atinge limites no número de conexões ou sessões simultâneas, fazendo com que novas conexões sejam rejeitadas.
• Em última análise, sua conta é bloqueada.

Os mecanismos destinados a impedir atacantes acabam bloqueando a pessoa que os criou. Isso realmente aconteceu no meu servidor doméstico.

Eu realmente escrevi sobre algo semelhante antes. Em Um Registro de Confiar Meu Servidor à IA, mencionei como um script de monitoramento atingiu seu próprio limite de conexão simultânea, fazendo com que minhas próprias tentativas de SSH falhassem. Naquela época, era um "script". Desta vez, o "agente de IA" estava caindo na mesma armadilha com cada comando que executava. A causa é a mesma—muitas conexões.

Ao agrupar tudo em um único terminal, isso também desaparece. A autenticação acontece uma vez, e há apenas uma sessão que não se multiplica. Portanto, você não atingirá limites de taxa de conexão ou será banido.

Design: Mantendo apenas "um terminal"

A filosofia de aiterm é simples: o primitivo é apenas "manter um terminal local".

No início, tentei aumentar as ferramentas por tipo—ferramentas para SSH, ferramentas para containers... mas não há fim para isso. Então eu parei tudo. Eu parei de fazer SSH, docker exec, e shells interativos (REPL) em ferramentas dedicadas, e as rebaixei para "uma única linha digitada naquele terminal."

pty_open()                      # Abrir um terminal
pty_send(id, "ssh 192.168.1.2") # SSH uma vez dentro dele
pty_send(id, "uname -a")        # Comandos subsequentes são executados na mesma sessão
pty_read(id)                    # Ler saída podada

É por isso que existem apenas 6 ferramentas (op