Eddo: The GTD-AI Hybrid That Makes Todo Apps Obsolete

Stop fighting your todo list. Every developer knows the soul-crushing cycle: you open your task manager, stare at 47 unchecked boxes, and quietly close the tab. Traditional todo apps are digital graveyards where good intentions go to die. They're passive. Dumb. Silent witnesses to your procrastination.

But what if your todo list fought back?

What if it could think, track time automatically, sync with GitHub issues, read your emails, and even delegate work to AI agents that actually get things done?

Meet Eddo—a GTD-inspired todo and time tracking system with AI integration that transforms task management from a chore into a conversation. Born from a notebook-based system refined over 10+ years, Eddo isn't another SaaS subscription trap. It's an open-source, offline-first, agent-powered productivity engine that top developers are quietly adopting to 10x their output.

Ready to see why everyone is abandoning Notion, Todoist, and linear task managers? Let's dive in.

What is Eddo?

Eddo is a personal productivity platform that merges David Allen's legendary Getting Things Done (GTD) methodology with cutting-edge AI agent integration. Created by Walter Rafelsberger as a solo side project, Eddo represents a radical reimagining of how knowledge workers should interact with their tasks.

The project's philosophy is elegantly simple: "todos. humans. agents. that's it."

This isn't hyperbole. Eddo treats AI agents as first-class citizens in your workflow—not gimmicky chatbots bolted onto a database, but autonomous collaborators that can create tasks, track time, query your backlog, and even orchestrate multi-agent coding sessions through its pi-coding-agent integration.

Why Eddo is Trending Now

Three converging forces make Eddo explosively relevant:

1. The MCP Revolution — The Model Context Protocol (MCP) standardizes how AI assistants interact with external data. Eddo's MCP server makes your todos programmatically accessible to any compatible agent.

2. Developer Burnout Epidemic — Developers are drowning in context switching between Jira, GitHub, Slack, email, and calendar. Eddo consolidates everything into one offline-first hub.

3. AI Agent Maturation — Claude, GPT-4, and specialized coding agents can finally handle complex multi-step instructions. Eddo's Telegram bot leverages this for natural language task management.

⚠️ Alpha Software Warning: This is actively developed solo project. Expect rough edges, breaking changes, and don't rely on data integrity across updates. But for early adopters? The payoff is massive.

Key Features That Destroy the Competition

Eddo's feature set reads like a wishlist every developer has scribbled in frustration:

GTD Contexts with Kanban Visualization

Organize todos by context—work, home, projects—in Kanban columns that mirror how your brain actually categorizes obligations. No more flat lists that induce decision paralysis.

Calendar Week View

Navigate tasks by week with date-range queries. See exactly what's coming without the noise of monthly overviews or daily myopia.

Dependency Graph with Graphviz

Click any task to explode its parent/child relationships and blockers into a leveled Graphviz visualization. Complex projects become navigable territory instead of terrifying mysteries.

Time Tracking That Doesn't Suck

Start/pause timers with daily summaries and filter views by active tracking state. Finally, understand where your hours actually go—not where you think they go.

Offline-First Architecture

PouchDB local storage with real-time CouchDB sync means your data survives airplane mode, coffee shop WiFi failures, and apocalyptic internet outages. Your productivity doesn't depend on someone else's uptime.

AI-Powered Telegram Bot

Natural language todo management through Claude integration: "Add a work todo for tomorrow's meeting", "What's overdue?", "Start tracking time on the API refactor". The bot handles multi-step instructions, delivers daily briefings, and configures integrations via chat.

GitHub, RSS & Gmail Sync

Auto-import issues assigned to you, subscribe to feeds for automatic todo creation, and convert emails to tasks through Gmail OAuth. Eddo doesn't just store tasks—it harvests them from your existing workflows.

MCP Server for Programmatic Access

Expose your entire todo ecosystem to AI agents via the Model Context Protocol. Build custom automations, integrations, and workflows that traditional APIs make painful.

pi-coding-agent Skills

Specialized extensions for AI-assisted development: multi-agent git worktree orchestration, ES|QL query generation, web search integration, and diagram rendering.

Use Cases: Where Eddo Absolutely Dominates

1. The Solo Developer Running Multiple Projects

You're juggling client work, open-source contributions, and side projects. Eddo's context-based Kanban keeps boundaries clear. The dependency graph reveals hidden blockers. Time tracking proves (to yourself) which projects are profitable versus time sinks. The pi-coding-agent integration lets you spawn AI assistants for each codebase without context pollution.

2. The Remote Team Lead Drowning in GitHub Issues

Issues multiply faster than you can triage. Eddo's GitHub sync automatically imports assignments, creates context per repository, and auto-completes when issues close. Your Telegram bot becomes a command center: "Show me overdue API issues" → instant filtered view.

3. The Researcher Tracking Information Streams

RSS feeds, newsletters, and email alerts create notification debt. Eddo's RSS autodiscovery and Gmail folder sync convert information into actionable todos. The calendar week view schedules deep reading blocks. Time tracking ensures you're consuming, not just collecting.

4. The AI-First Developer Building Agent Workflows

You're already using Claude, GPT-4, or pi-coding-agent. Eddo's MCP server and specialized skills let these agents read and write your task state. Imagine: your coding agent finishes a refactor, automatically creates follow-up tasks for tests and documentation, and schedules them based on your calendar. This isn't science fiction—it's Eddo's architecture.

5. The Digital Nomad Needing Offline Reliability

Coffee shop WiFi. International flights. Rural coworking spaces. Eddo's PouchDB offline-first design means full functionality without connectivity. Sync happens when possible, not when required. Your task data lives on your device, not someone's cloud.

Step-by-Step Installation & Setup Guide

Eddo's setup is surprisingly streamlined for a system this powerful. Here's the complete path from zero to productive:

Prerequisites

Installation Commands

# Clone the repository
git clone https://github.com/walterra/eddoapp.git
cd eddoapp

# Optional: Use latest stable release instead of main
git checkout $(git describe --tags --abbrev=0)

# Install dependencies
pnpm install

# Run interactive setup wizard
pnpm dev:setup

# Start development server
pnpm dev

# Open http://localhost:3000

What the Setup Wizard Actually Does

The pnpm dev:setup command isn't just a script—it's an intelligent bootstrap:

1. Prerequisite Validation — Checks Node.js, pnpm, Docker, and Git versions with helpful error messages
2. Docker Orchestration — Starts CouchDB (primary database) and Elasticsearch (search index) containers
3. Environment Generation — Creates .env with sensible development defaults
4. Package Building — Compiles core libraries and setup tools in dependency order
5. User Creation — Generates eddo_pi_agent account for MCP/agent authentication
6. pi-coding-agent Linking — Auto-discovers and links skills if pi is installed globally (npm i -g @mariozechner/pi-coding-agent)

Troubleshooting & Maintenance

# Diagnose everything: prerequisites, Docker, services, ports, config
pnpm dev:doctor

# Verify code quality before commits
pnpm check:commit
# Runs: TypeScript build checks, ESLint, Prettier verification

Service Management

pnpm dev              # Start all services (web, API, sync, bot)
pnpm test             # Run full test suite
pnpm lint             # Check and fix code style
pnpm build            # Production optimization build
pnpm dev:create-user  # Manual user creation for team access

REAL Code Examples from the Repository

Let's examine actual implementation patterns from Eddo's codebase and documentation.

Example 1: Starting the Complete Development Environment

# Clone and enter repository
git clone https://github.com/walterra/eddoapp.git
cd eddoapp

# Switch to latest stable tag (defensive practice for alpha software)
git checkout $(git describe --tags --abbrev=0)

# Install with pnpm's strict dependency resolution
pnpm install

# Interactive wizard handles Docker, env files, and user setup
pnpm dev:setup

# Launch all services: React↗ Bright Coding Blog frontend, Hono API, CouchDB sync, Telegram bot
pnpm dev

What's happening here? This isn't just npm start. The pnpm dev:setup wizard performs infrastructure provisioning typically handled by DevOps^{↗ Bright Coding Blog} teams. It validates your entire toolchain, starts containerized databases, generates cryptographic secrets, and creates the agent user account. For solo developers, this eliminates the "works on my machine" problem by codifying the entire environment.

Example 2: Running Diagnostic Checks

# Comprehensive system diagnosis
pnpm dev:doctor

Behind the scenes, this command inspects:

• Prerequisites: Node.js version compatibility, pnpm availability
• Docker status: Daemon running, container health, image presence
• Service health: CouchDB responding on expected port, Elasticsearch cluster status
• Port availability: No conflicts with common development services
• Configuration validation: .env completeness, required secrets present

This pattern—proactive diagnosis over reactive debugging—is why Eddo feels polished despite alpha status.

Example 3: Telegram Bot with Claude Integration

# Configure environment variables in .env:
# TELEGRAM_BOT_TOKEN=your_bot_token_from_botfather
# ANTHROPIC_API_KEY=your_claude_api_key

# Start the AI assistant
pnpm dev:telegram-bot

Natural language interactions enabled:

User:  "Add a work todo for tomorrow's meeting"
Bot:   [Creates task with context='work', due=tomorrow, title='meeting']

User:  "What's overdue?"
Bot:   [Queries CouchDB for due_date < now AND status != 'done', 
        formats response with priority indicators]

User:  "Start tracking time on the API refactor"
Bot:   [Finds matching task, creates time tracking session, 
        confirms with elapsed time display]

Technical depth: The bot uses multi-step instruction handling—it doesn't just parse single commands but maintains conversation state for complex workflows. Daily briefings run on scheduled cron-like triggers. Integration configuration (GitHub, RSS, Email) happens through conversational state machines rather than web forms.

Example 4: GitHub Issue Synchronization

# Via Telegram bot conversation:
/github token ghp_your_personal_access_token
/github on
/github status

Implementation logic:

1. PAT creation at https://github.com/settings/tokens with repo or public_repo scope
2. Token encryption before storage (security best practice)
3. Repository discovery — each repo becomes a GTD context
4. Bidirectional sync — issues auto-import as todos; closures on GitHub auto-complete in Eddo
5. Webhook or polling for real-time updates

This eliminates the Jira-GitHub context switch tax that costs developers 15+ minutes per interruption.

Example 5: MCP Server for Agent Programmatic Access

# Start the Model Context Protocol server
pnpm dev:mcp-server

# Interactive testing with sample requests
pnpm test:mcp-server

Authentication required:

# HTTP header options:
Authorization: Bearer <api_key>
# OR
X-API-Key: <api_key>

Critical security note from documentation: "Don't expose the MCP server to untrusted networks." This is localhost-first architecture—your agents run locally, access your data locally, and never expose your todo graph to the internet.

Generate API keys via: User Profile → Security, or capture from pnpm dev:create-user output.

Example 6: pi-coding-agent Skills Integration

# Install pi-coding-agent globally (prerequisite)
npm i -g @mariozechner/pi-coding-agent

# Setup wizard auto-links these skills:
# - eddo-todo       : Task management commands
# - eddo-work       : Structured implementation workflow  
# - eddo-spawn      : Multi-agent git worktree orchestration
# - elasticsearch-esql : ES|QL query generation
# - searxng-search  : Web search integration

# Extensions for visualization:
# - graphviz-chart  : Diagram rendering
# - vega-chart      : Data visualization

The eddo-spawn skill is particularly powerful: it creates isolated git worktrees for each agent, preventing branch conflicts when multiple AI assistants work simultaneously. This is multi-agent orchestration that most development teams haven't implemented for human developers, let alone AI ones.

Advanced Usage & Best Practices

Backup Strategy for Alpha Software

# Interactive backup with selection dialogs
pnpm backup:interactive
pnpm restore:interactive

# Automated cron-friendly backups
pnpm backup:auto --pattern "eddo_user_*"

# Apply retention policies (prevent disk bloat)
pnpm backup:retention

Pro tip: Since Eddo is alpha, run pnpm backup:auto in a pre-commit hook or daily cron job. The CouchDB backend means backups are complete JSON documents—trivial to inspect, modify, or migrate.

Performance Optimization

• Elasticsearch queries: Use the elasticsearch-esql skill for complex aggregations instead of loading all documents
• PouchDB sync: Configure batch_size and batches_limit for large datasets
• Graph rendering: Large dependency graphs benefit from Graphviz's levelsgap parameter for readability

Security Hardening

1. MCP server: Bind to 127.0.0.1 only, never 0.0.0.0
2. Telegram bot: Use webhook mode with HTTPS in production instead of polling
3. Gmail OAuth: Restrict to specific label, use dedicated Google Cloud project
4. API keys: Rotate monthly; use pnpm dev:create-user for per-agent credentials

Comparison with Alternatives

Eddo's unfair advantages:

• Zero vendor lock-in — your data lives in CouchDB, exportable as JSON anytime
• Agent-native architecture — not retrofitted AI, but designed for autonomous collaboration
• Cost efficiency — run forever at cloud VPS cost versus per-seat SaaS pricing

FAQ

Is Eddo stable enough for daily use?

Not yet for mission-critical data. The alpha status means breaking changes and potential data loss across updates. However, the offline-first PouchDB architecture means you always have local copies. Use it for experimental workflows, personal projects, or parallel tracking alongside your current system.

How does Eddo compare to specialized time trackers like Toggl?

Eddo's time tracking is context-integrated—timers attach to GTD contexts and dependency graphs, revealing why time was spent, not just how much. For pure agency billing, Toggl remains superior. For understanding productivity patterns, Eddo's visualization wins.

Can I self-host Eddo for my team?

Technically yes, practically challenging. The monorepo supports multi-user CouchDB, but the alpha status and solo maintainer mean no enterprise support. For small technical teams comfortable with Docker, it's viable. For non-technical users, wait for beta.

What AI models work with the Telegram bot?

Currently Claude via Anthropic API. The architecture supports swapping LLM providers through the ANTHROPIC_API_KEY configuration pattern. MCP server access is model-agnostic—any MCP-compatible agent connects.

How do I migrate from Todoist/Notion?

No automated importer yet (alpha limitation). Export your data to CSV/JSON, then use the MCP server or direct CouchDB API to bulk-create tasks. The GTD context mapping requires manual thought—this is feature, not bug, as it forces productive categorization.

Is there a mobile app?

Not native. The React web client is responsive and works as PWA. For Telegram-centric workflows, the bot provides full mobile access to task creation, querying, and time tracking.

How does pi-coding-agent integration actually help development?

The eddo-spawn skill creates isolated git worktrees per agent task, preventing branch pollution. eddo-work structures implementation into atomic steps with automatic todo creation. You effectively pair program with AI while maintaining task traceability.

Conclusion

Eddo represents something rare in productivity software: genuine architectural innovation rather than feature accumulation. By combining decades-proven GTD methodology with emerging AI agent standards (MCP), offline-first resilience, and developer-centric integrations, it solves problems that existing tools don't even recognize.

The alpha status is a feature for early adopters—you shape the roadmap, report real issues that get fixed, and build workflows before the mainstream arrives. The MIT license guarantees no future vendor extortion.

For developers drowning in context switching, tired of SaaS pricing creep, and excited about AI-augmented workflows, Eddo isn't just another option. It's a fundamentally different category.

Your move: Clone the repo, run pnpm dev:setup, and experience task management that actually thinks with you. The future of productivity isn't more dashboards—it's intelligent agents working through protocols that put you in control.

👉 Star Eddo on GitHub — watch the repository for releases, contribute issues and PRs, and join the small but growing community of developers who refuse to let their todo lists defeat them.

The notebook-based system evolved over 10 years. The digital version is just getting started. Where will you be when it hits 1.0?