
Sessenta contêineres em um servidor
Uma caixa bare-metal executa dezenas a centenas de contêineres Hoody. KSM e BTRFS dedup fazem o custo marginal próximo a zero.
Um agente de pesquisa recebe um prompt complexo. Em vez de fazer tudo sozinho, ele faz POST na API de containers e recebe três URLs de sub-agentes. Cada sub-agente pode criar seus próprios sub-agentes. Nenhum deles conhece um orquestrador. Eles só chamam uns aos outros por HTTP.
Todo nó da árvore é um contêiner Hoody com um serviço hoody-agent. Pais e filhos só se conhecem por URL. Não tem planejador central observando do alto.
Recebe o prompt. Decide quais sub-tarefas distribuir. Faz POST na API de containers para iniciar um novo contêiner por sub-agente, depois chama o endpoint /api/v1/agent/tasks de cada um com a fatia de trabalho que possui.
Cada um roda no próprio contêiner com filesystem, terminal e SQLite próprios. Nenhum pode corromper os outros. Qualquer um deles pode decidir que precisa de ajuda e criar seus próprios filhos do mesmo jeito que o pai fez. O protocolo é simétrico.
O fact-checker vê cinco afirmações, cria cinco contêineres em paralelo, dispara cinco requisições HTTP, aguarda cinco respostas. Mesmo padrão, um nível mais fundo. Contêineres ociosos custam zero, então árvores profundas são economicamente livres.
Não tem runtime de agente para instalar, sem barramento de mensagens para configurar, sem estado compartilhado para sincronizar. O agente pai usa a mesma API de Containers que um humano usaria: POST para criar, depois chamar a URL do filho.
// Parent agent (running in its own Hoody container).
// Spawn three sub-agents, hand each one a slice of work,
// await their results in parallel.
const HOODY = 'https://api.hoody.com';
async function spawnChild(name) [
// 1. Create a fresh container with the agent service running.
const res = await fetch(HOODY + '/api/v1/projects/' + PROJECT + '/containers', [
method: 'POST',
headers: [ authorization: 'Bearer ' + TOKEN ],
body: JSON.stringify([
name,
server_id: SERVER,
container_image: 'debian-12',
hoody_kit: true,
ai: true,
]),
]);
const child = (await res.json()).data;
// 2. Hit the child's agent URL like any other HTTP service.
const agentUrl = 'https://' + PROJECT + '-' + child.id + '-agent-1.' + SERVER + '.containers.hoody.com';
return [ id: child.id, agentUrl ];
]
const [scrape, summarize, factCheck] = await Promise.all([
spawnChild('scrape'),
spawnChild('summarize'),
spawnChild('fact-check'),
]);
// 3. Dispatch tasks. Each child runs autonomously,
// can spawn its own children the same way.
const results = await Promise.all([
fetch(scrape.agentUrl + '/api/v1/agent/tasks', [ method: 'POST', body: JSON.stringify([ description: scrapeBrief ]) ]),
fetch(summarize.agentUrl + '/api/v1/agent/tasks', [ method: 'POST', body: JSON.stringify([ description: summarizeBrief ]) ]),
fetch(factCheck.agentUrl + '/api/v1/agent/tasks', [ method: 'POST', body: JSON.stringify([ description: factCheckBrief ]) ]),
]);Os dois endpoints são APIs Hoody documentadas: POST /api/v1/projects/$PID/containers cria um novo contêiner com o serviço de agente pré-instalado; POST $CHILD_URL/api/v1/agent/tasks despacha uma tarefa para ele. O fact-checker pode rodar exatamente o mesmo código para criar seus próprios verificadores por afirmação — a recursão é só HTTP.
Todo framework de agente é uma camada fina sobre chamadas de função em processo. Todos assumem que agentes compartilham memória, compartilham Python, compartilham um único runtime. O Hoody assume o oposto: agentes são computadores separados, e HTTP já é o protocolo que eles falam.
POST /api/v1/projects/$PID/containers
fetch(child.url + '/api/v1/agent/tasks')
Duas chamadas HTTP por filho. O pai não importa um framework, não registra uma ferramenta, não compartilha estado. Cada sub-agente é um peer com URL — mesma forma que o pai, mesma forma que você chamaria qualquer outro serviço HTTP.
Cada agente é um peer com URL. Eles chamam uns aos outros do jeito que qualquer serviço HTTP chama qualquer outro serviço HTTP.
Não tem orquestrador. Não tem barramento de mensagens. Não tem estado compartilhado para sincronizar. A única coisa que limita quantos agentes você roda em paralelo é quanto você quer gastar — e contêineres ociosos não custam nada.
Os frameworks de orquestração e serviços de runtime efêmero aos quais as pessoas recorrem quando um agente não basta. Cada um resolve uma fatia do problema. A primitiva HTTP-nativa substitui a fatia e o framework em volta dela.
Pare de cabear grafos de agente. Inicie um. Deixe ele iniciar o resto.