EDDIE Agent System
Codebase Audit

What EDDIE Actually Is

At its core, EDDIE is a message relay: Telegram message in → Claude Code CLI subprocess out. Everything else is middleware.

The system wraps this simple relay in:

Plus: a full video production pipeline, multi-channel comms (Gmail, Calendar, Slack, WhatsApp, iMessage), eBPF kernel monitoring in a privileged container, phone calls via Twilio, and a community distribution bridge.

The Context Window Tax

This is the most architecturally damaging finding. Every Claude invocation pays a token "tax" before any user content is processed.

Visual: Context Window Consumption

What Gets Injected

Interactive relay: EDDIE persona (~1,200 chars) + top 10 memory matches (~3,000 chars) + session state (~2,000 chars) = 2,000–5,000 tokens before the user's message.

Background jobs: PDAC protocol (~3,000 chars) + Brain Vault paths + briefing + project states + CLAUDE.md files + routing hints = 8,000–15,000 tokens before the task prompt.

Heartbeat ticks: Checklist + last 3 heartbeats + goals + 30 conversations + ALL project states + usage data + crons + queue stats = 10,000–30,000 tokens before any reasoning.

The Ontology Disconnect

None of this injected context comes from a knowledge graph. The capabilities registry is a 2,966-line keyword matcher — pattern matching, not understanding:

{
  id: "agent:cold-outreach-strategist",
  triggers: [
    { type: "keyword", patterns: ["outreach", "cold email", "prospecting"...], weight: 0.9 },
    { type: "project", patterns: ["leadgen"], weight: 1.0 }
  ]
}

It doesn't know the relationship between a client, a campaign, and a lead. It can't distinguish "outreach" meaning cold email vs. community engagement vs. PR. No semantic graph — just keywords and weights.

Security Findings

Complexity Analysis

What Could Be 50 Lines

The core value proposition — relay Telegram messages to Claude Code — is roughly a 50-line script:

import { Bot } from "gramio";
const bot = new Bot(process.env.TELEGRAM_BOT_TOKEN);
bot.on("message", async (ctx) => {
  if (ctx.from.id !== Number(process.env.OWNER_ID)) return;
  const proc = Bun.spawn(["claude", "-p", ctx.text, "--print"]);
  const result = await new Response(proc.stdout).text();
  await ctx.reply(result);
});
bot.start();

Everything beyond this is middleware. The question is whether each layer earns its complexity.

What's Doing Real Work

• Job system (tmux background tasks): Solves a real problem
• Memory/search (semantic fact retrieval): Useful for context continuity
• Model selection (Opus/Sonnet/Haiku routing): Real cost savings
• Security scanning (input/output): Necessary, though implementation has gaps

Complexity Without Proportional Value

35+ proactive modules: Heartbeat, dream cycle, morning brief, daily brief, weekly review, monthly review, weekly content, 80/20 analysis, nightly orchestrate, self-improve, optimizer, challenge, brainstorm, vision, pillars, goals, observation log, revenue tracker, expense tracker, social snapshot, content brief, waiting-on tracker, rejection learning, outcome analysis, report synthesis, accounting triage, discoverability, context drift, video idea pipeline, dashboard generation, eBPF monitoring, anthropic monitoring, claude health, memory monitor...

Heimdall: A full content scanning/cleaning/packaging/sync system for community distribution. An entire product inside an assistant.

Video pipeline: News → script → ElevenLabs TTS → Remotion render → FFmpeg → Gemini QA → YouTube upload → analytics. A full media production system embedded in a chat bot.

eBPF kernel monitoring: A privileged Docker container running bpftrace programs for network, process, and memory kernel events. Infrastructure monitoring inside an assistant.

The OpenClaw Parallel

The OpenClaw extraction document prepared for Limore identified structural vulnerabilities. Every one maps to EDDIE:

The Ontology Gap

What EDDIE Has: Keyword Matching

A weighted keyword matcher that cannot understand relationships, context, or meaning. It doesn't know that "reach out to the prospect from Tuesday's meeting" refers to a specific person. It can't connect content to strategy.

What EDDIE Has: Flat File Memory

Brain Vault is a folder structure, not a knowledge graph. "Semantic search" is embedding similarity over stored text fragments — useful for recall, but it has no understanding of relationships, types, hierarchies, or provenance.

What ShurAI Provides: Semantic Infrastructure

• Typed entities with defined relationships (Client → Project → Campaign → Asset)
• Scoped context injection — only the semantic neighborhood of the query, not everything
• Provenance chains — every piece of context traces to its source
• Cross-session continuity via the Letta memory architecture — structured memory blocks with guided synthesis
• InfraNodus integration — actual knowledge graph analysis, gap detection, semantic clustering
• Ontology-driven routing — route based on semantic structure, not keyword matching

The Alternative: What We Can Build

Architecture Principles

Recommendations for Nicholas

This report is not an attack on the engineering effort. EDDIE represents significant technical ambition and many individual modules are well-built. The critique is architectural:

1. The complexity is the vulnerability. 235 files and 35+ autonomous modules create an attack surface that no amount of input scanning can defend. Simplify ruthlessly.
2. The context window tax is real. Measure how many tokens are consumed by system scaffolding vs. actual user content. Claude may be spending more time reading about itself than thinking about your problem.
3. The memory system needs sanitization. Any content that enters the system prompt must be validated. The storeFact() → buildMemoryContext() pipeline is a persistent injection vector.
4. Rotate all credentials immediately. Every key in .claude/settings.json should be considered compromised. Move to environment variables or a secret manager.
5. The dashboard needs authentication. Binding to 0.0.0.0 with Access-Control-Allow-Origin: * and optional auth is an open door.
6. Consider what actually needs to be autonomous. Dream cycle, self-heal, self-improve, and nightly orchestrate create feedback loops that drift from intended behavior. Each needs a human approval gate.
7. Connect to real ontology. The keyword-matching router will always be brittle. A knowledge graph that understands relationships between clients, projects, and capabilities would make routing intelligent rather than pattern-matched.