Se o seu agente de IA dá uma resposta útil ou inventa algo com total convicção, isso depende, mais do que qualquer outra coisa, de como o contexto é gerenciado — como o histórico de conversas, saídas de ferramentas e conhecimento externo são empacotados dentro da janela de contexto finita do modelo. Antes do OpenClaw 2026.3.7, essa lógica era hardcoded. Agora é um plugin.
O Problema
O OpenClaw usava compactação por janela deslizante: a conversa ficava longa demais, mensagens antigas eram resumidas, mensagens novas ganhavam espaço. Funcionava. Mas tinha seus trade-offs, e nem todo mundo ficava satisfeito:
- •Resumir significa perder detalhe. Um agente de código precisa referenciar uma função de 50 turnos atrás? Já era.
- •Sem memória entre sessões. Fechou a sessão, perdeu o contexto. Toda conversa começa do zero.
- •Uma estratégia única, pegar ou largar. Quer montagem baseada em RAG? Ramificação de conversas? Budgets de tokens customizados? Sem caminho limpo pra isso.
O pessoal dava seus jeitinhos — monkey-patching nos internos, fork do core, orquestração externa por cima. Nada disso era sustentável.
ContextEngine: Um Slot de Plugin para Gerenciamento de Contexto
O 2026.3.7 pega todo o ciclo de vida do contexto, extrai numa interface bem definida e abre como um plugin slot. Escreva um plugin, implemente a interface, e o gerenciamento de contexto é seu.
Como se conecta
Registre sua engine pela API de plugins:
// In your plugin's bootstrap
export default function myContextPlugin(api: PluginAPI) {
api.registerContextEngine('my-engine', (config) => {
return new MyCustomContextEngine(config);
});
}
Selecione no config:
plugins:
slots:
contextEngine: my-engine
Nenhum plugin configurado? O OpenClaw encapsula o comportamento antigo num LegacyContextEngine. Nada muda pra quem já usava.
Sete Hooks de Ciclo de Vida
A interface oferece sete hooks — um pra cada estágio que importa num turno de conversa:
1. `bootstrap()`
A engine inicializa. Conecte ao seu vector DB, monte seu grafo, carregue estado salvo.
async bootstrap(): Promise<void> {
this.vectorStore = await connectToVectorDB(this.config.dbUrl);
this.sessionGraph = new DAG();
}
2. `ingest(message: Message)`
Uma nova mensagem chega — input do usuário, resposta do assistente, saída de ferramenta. Você decide como armazenar e indexar.
async ingest(message: Message): Promise<void> {
// Add to the DAG
const node = this.sessionGraph.addNode(message);
// Index for retrieval
const embedding = await embed(message.content);
await this.vectorStore.upsert(node.id, embedding, message);
}
3. `assemble(budget: TokenBudget): AssembledContext`
O hook principal. Antes de cada chamada ao modelo, o OpenClaw te entrega um budget de tokens e pede: monta um contexto pra mim. O que você retornar é exatamente o que o modelo vai ver.
Engines diferentes, estratégias radicalmente diferentes:
async assemble(budget: TokenBudget): AssembledContext {
const recentMessages = this.sessionGraph.getRecent(budget.soft * 0.6);
const relevantHistory = await this.vectorStore.query(
this.currentQuery,
budget.soft * 0.3
);
const systemContext = this.buildSystemPrompt(budget.soft * 0.1);
return {
system: systemContext,
messages: [...relevantHistory, ...recentMessages],
tokenEstimate: this.estimateTokens([systemContext, ...relevantHistory, ...recentMessages]),
};
}
4. `compact()`
O contexto estourou o limite hard de tokens. Hora de enxugar. A engine padrão resume mensagens antigas. Seu plugin pode podar nós do grafo, descarregar num vector store, ou simplesmente ignorar se o assemble() já se mantém dentro do budget.
5. `afterTurn(turn: Turn)`
Um turno completo terminou — o usuário falou, o agente respondeu. Bom momento pra persistir estado, atualizar índices ou disparar trabalho em background.
6. `prepareSubagentSpawn(parentContext: Context): SubagentContext`
O agente está criando um subagente. Quanto contexto o filho recebe? Tudo estouraria o budget de tokens. Nada o deixaria às cegas. Esse hook permite ser preciso.
prepareSubagentSpawn(parentContext: Context): SubagentContext {
// Give the subagent a focused slice of context
const relevantNodes = this.sessionGraph.getSubtree(parentContext.taskId);
return {
messages: relevantNodes.map(n => n.message),
metadata: { parentSessionId: this.sessionId },
};
}
7. `onSubagentEnded(result: SubagentResult)`
O subagente terminou. Os resultados precisam voltar pro contexto pai de alguma forma — merge de tudo, resumo, seleção manual. Você que manda.
Arquitetura: Slots vs. Hooks
ContextEngine é um slot, não um hook. Hooks são aditivos — dez plugins podem ouvir o onMessage ao mesmo tempo. Slots são exclusivos. Uma ContextEngine por vez.
┌─────────────────────────────────────┐
│ Plugin Registry │
│ │
│ Hooks (aditivos): │
│ onMessage → [plugin1, plugin2] │
│ onTool → [plugin3] │
│ │
│ Slots (exclusivos): │
│ contextEngine → my-engine │
│ (padrão: LegacyContextEngine) │
└─────────────────────────────────────┘
Na inicialização, o OpenClaw lê plugins.slots.contextEngine, encontra a factory registrada e instancia. Se a engine não existir, a inicialização falha de forma ruidosa. Sem fallback silencioso — decisão deliberada. Você precisa saber qual context engine está rodando.
O isolamento de subagentes usa AsyncLocalStorage: cada filho recebe seu próprio runtime com escopo isolado. Estado de plugin não vaza entre fronteiras de agentes.
O Que Já Estão Construindo
Lossless-Claw
GitHub · Martian Engineering
O primeiro plugin sério de ContextEngine. Substitui a compactação por janela deslizante por um sistema de sumarização baseado em DAG que mantém todas as mensagens originais sem estourar o limite de tokens.
- •Cada mensagem vira um nó num grafo acíclico dirigido
- •Nós se agrupam em "episódios" por tópico
- •Estourou o budget? Episódios antigos são resumidos, mas os originais ficam no grafo
- •Se um turno posterior referencia conteúdo antigo, a engine puxa o original — não o resumo
Se você já teve um agente de código que esqueceu uma função que ele mesmo escreveu uma hora atrás, esse é o fix.
MemOS Cloud Plugin
GitHub · MemTensor
Faz uma coisa só: dá ao seu agente memória que sobrevive entre sessões.
- •No
bootstrap(): puxa memórias relevantes do MemOS Cloud com base na mensagem inicial - •No
afterTurn(): salva novos turnos na nuvem - •No
assemble(): injeta memórias recuperadas no contexto do sistema
Seu agente lembra a conversa da semana passada, suas preferências, seus projetos. Você para de se repetir.
O Que Vem Por Aí
Pelo que se vê nas issues do GitHub e no Discord, a galera está trabalhando em:
- •Montagem nativa com RAG: Pula o histórico de mensagens, monta contexto a partir de chunks de documentos recuperados. OpenClaw como motor de busca conversacional.
- •Memória compartilhada multi-agente: Múltiplos agentes compartilhando um knowledge graph. Workflows colaborativos sem contexto redundante.
- •Otimização de budget de tokens: Ajuste dinâmico da composição do contexto com base no modelo que você está usando — preço, pontos fortes, tamanho da janela de contexto.
- •Ramificação de conversas: Contexto com estrutura de árvore. Explore caminhos diferentes, volte atrás, mantenha tudo.
Por Que Isso Muda o Jogo
O OpenClaw sempre soube adicionar canais, modelos e ferramentas. Mas o contexto — como o agente efetivamente pensa — estava trancado dentro do core. Não dava pra mexer sem fazer fork.
O ContextEngine abre essa caixa. E uma vez aberta, as coisas começam a se acumular:
- 1.Desenvolvedores de plugins finalmente podem competir no problema mais difícil da UX de agentes: qualidade de contexto.
- 2.Usuários enterprise ganham controles de compliance — redação antes do modelo ver, políticas de retenção, auditoria de cada prompt.
- 3.Pesquisadores podem testar novas estratégias de contexto sem manter um fork.
- 4.Provedores de modelos podem distribuir plugins otimizados pras suas arquiteturas. Modelos de contexto longo e curto não devem usar a mesma estratégia.
É isso que realmente significa um framework se tornar uma plataforma. Não é um rebrand. Não é um post de blog anunciando uma "visão." É uma mudança arquitetural concreta que torna o ecossistema auto-reforçante. Mais plugins → mais usuários → mais desenvolvedores → mais plugins. Quando esse ciclo começa, é difícil parar.
A lagosta acabou de ganhar uma garra nova.