Contexto
Acabo de publicar claude-agent-patterns con 8 patterns extraidos de un agente autonomo en produccion. Investigando el espacio, descubri que OpenClaw -- el framework de agente autonomo open source mas popular (6000+ stars) -- resuelve exactamente los mismos problemas fundamentales.
La diferencia: OpenClaw es un framework generico que abstrae todo por ti. Nuestro approach es artesanal, cada pieza construida a medida con control total.
Lo que aprendi
Los 5 problemas que todo agente autonomo en produccion necesita resolver son los mismos, sin importar el approach:
| Problema | OpenClaw | DIY (nuestro daemon) |
|---|---|---|
| Daemon 24/7 | Gateway daemon con health checks | asyncio event loop con signal handlers |
| Anti-recursion | Heartbeat suppression basica | 4 capas independientes (provenance, cooldown, self-authored, rate limit) |
| Mensajeria | 12+ plataformas (Slack, Discord, Telegram...) | Telegram HITL (human-in-the-loop) enfocado |
| Memoria | Markdown files en el filesystem | SQLite + .task files con estado estructurado |
| Ejecucion | Claude/GPT headless via API keys | Claude Code headless (sin API keys directas) |
Ventajas del approach DIY
- Anti-recursion mas robusto: 4 capas vs suppression basica. Cada capa ataca el problema desde un angulo diferente
- Policy engine determinista: CBAC (Context-Based Access Control) que no existe en OpenClaw. Las reglas son codigo, no prompts
- Claude Code headless: sin gastar API keys directamente, aprovechando la suscripcion existente
- Control total: sin dependencias de framework externo, cada pieza es tuya para modificar
Cuando usar cada uno
- OpenClaw: quieres algo funcionando rapido, necesitas multi-plataforma, valoras la comunidad grande
- DIY: quieres control total sobre cada decision, necesitas patterns especificos para tu caso, quieres entender los fundamentals
Ejemplo
El anti-recursion de 4 capas es el pattern mas interesante porque OpenClaw solo resuelve la capa 1 (heartbeat suppression). El approach DIY agrega 3 capas mas:
class AntiRecursionGuard:
def should_process(self, source, provenance=None) -> bool:
now = time.monotonic()
# Capa 1: Provenance - "Yo genere esto?"
if provenance == self.provenance_id:
return False
# Capa 2: Cooldown - "Vi algo de esta fuente hace poco?"
last = self._cooldown_map.get(source)
if last and (now - last) < self.cooldown_seconds:
return False
self._cooldown_map[source] = now
# Capa 3: Self-authored - "Yo modifique este archivo?"
authored_at = self._self_authored.get(source)
if authored_at and (now - authored_at) < self.self_authored_window:
return False
# Capa 4: Rate limit - "Demasiados eventos por minuto?"
cutoff = now - 60.0
while self._event_timestamps and self._event_timestamps[0] < cutoff:
self._event_timestamps.popleft()
if len(self._event_timestamps) >= self.max_events_per_minute:
return False
self._event_timestamps.append(now)
return True
Cada capa es independiente. Si una falla, las demas siguen protegiendo. En produccion esto ha prevenido cientos de loops que una sola capa de suppression no habria capturado.
Referencias
- claude-agent-patterns -- Los 8 patterns extraidos y documentados
- OpenClaw Documentation -- Framework de agente autonomo open source
- OpenClaw en Wikipedia -- Historia y contexto del proyecto