# I Wanted a Simple Morning Email Digest — Here's Why I Ignored LangChain, CrewAI, and Every AI Agent Framework

> **TL;DR:** I needed a system that pulls my Gmail and Google Calendar every morning, uses AI to figure out what actually matters, and sends me a prioritized summary on Telegram/Discord/Whatsapp. After researching 15+ tools — from Zapier to Temporal.io to LangGraph — the answer was a single OpenAI API call triggered by a cron job. Total cost: $1/month. Build time: an afternoon.



## The Problem I Wanted to Solve

Every morning I open my inbox to 40-60 emails and a calendar packed with meetings. Half the emails are newsletters I subscribed to in 2021. A quarter are CC'd threads I don't need to read. Maybe 5-8 actually need my attention today.

I wanted something dead simple: a bot that wakes up at 7 AM, reads my email and calendar, figures out what's important, and sends me a Telegram message that looks like this:

```plaintext
🔴 Top Priority
• Reply to Sarah's contract review (deadline today)
• Prepare slides for 3 PM standup

📅 Today's Schedule
• 10:00 — 1:1 with Manager (30 min)
• 14:00 — Design review (1 hr, 4 attendees)
• 15:00 — Team standup (15 min)

📧 Needs Response (3)
• [John] Q3 budget approval — action needed by EOD
• [HR] Benefits enrollment reminder — deadline Fri
• [Client] Project timeline question

💤 Can Wait (7 filtered)
• 4 promotional, 2 newsletters, 1 notification
```

That's it. No dashboard. No UI. Just a message I glance at with my coffee.

Before writing a single line of code, I went deep on research. How do people build automations like this in 2025? What's the right tool? And with everyone talking about AI agents, should I be using LangChain or CrewAI for this?

Here's everything I found.

* * *

## The Automation Landscape: 15+ Tools Compared

I grouped every tool I evaluated into four tiers.

### Tier 1: No-Code Platforms

**Zapier** — the obvious first thought. Gmail trigger → Filter → OpenAI step → Telegram step. It works, but the free tier only gives you 100 tasks/month (my digest would use ~50 per run), and multi-step flows require a $20/month paid plan. For a daily cron job that calls one API, $20/month felt absurd.

**Make (formerly Integromat)** — more powerful than Zapier, cheaper too. Free tier gives 1000 operations/month, paid starts at $9. This was actually viable, but I wanted more control over the AI prompt than a visual builder allows.

**Pipedream** — the interesting middle ground. You write real TypeScript/Node.js in their cloud IDE, and they handle OAuth, scheduling, and infrastructure. Free tier: 10K invocations/month. The catch: your code lives on their platform. If Pipedream shuts down or changes pricing, you're migrating.

### Tier 2: Self-Hosted Workflow Engines

**n8n** — open-source, self-hostable, visual workflow builder with 400+ integrations. I already run n8n on a Raspberry Pi at home, so this was immediately attractive. Built-in Gmail, OpenAI, Telegram, and Discord nodes. Add a second Google account? Just duplicate the Gmail node and add new credentials. Setup time: 1-2 hours.

**Windmill** — developer-first alternative to n8n. Scripts in TypeScript/Python/Go with a web UI. Smaller community, fewer pre-built integrations, but good if you prefer code-first over visual-first.

**Temporal.io** — used by Stripe, Netflix, and Datadog for durable workflow orchestration. Incredible technology. Absolutely massive overkill for a morning email digest. Self-hosted cloud starts at $200/month. Skipped.

**Inngest** and **Trigger.dev** — modern TypeScript-native job frameworks. Inngest is event-driven with a nice developer experience. Trigger.dev is open-source with a built-in dashboard. Both would work, but they're solving orchestration problems I don't have.

### Tier 3: Data Pipeline Tools

**Apache Airflow** — the industry standard for DAG-based workflows. Python only, painful to self-host, designed for data engineering at scale. Using Airflow for a daily email digest is like renting a warehouse to store a shoebox.

**Prefect** — modern Airflow alternative. Better developer experience, same level of overkill.

### Tier 4: Custom Code

A single TypeScript file. `npm install openai googleapis`. Fetch emails, fetch calendar events, send to GPT-4o, post the result to Telegram. No framework. No platform. Just a script and a cron job.

### The Cost Comparison That Settled It

| Approach | Monthly Infra | Monthly AI | Total | Setup Time |
| --- | --- | --- | --- | --- |
| Zapier | $20 | ~$1 | **$21** | 30 min |
| Make | $0-9 | ~$1 | **$1-10** | 1-2 hours |
| Pipedream | $0 | ~$1 | **$1** | 1-2 hours |
| n8n (self-hosted) | $0 (already running) | ~$1 | **$1** | 1-2 hours |
| GitHub Actions + script | $0 | ~$1 | **$1** | 6 hours |
| Custom TypeScript + cron | $0 | ~$1 | **$1** | 6 hours |
| Express server on VPS | $5-10 | ~$1 | **$6-11** | 2 days |

The OpenAI cost is the same everywhere: ~20-50 emails at ~2,000-5,000 input tokens per run costs $0.01-0.03/day with GPT-4o. About $1/month.

The infrastructure cost is where the options diverge — and for a personal daily job, most options are either free or overkill.

* * *

## The Agent Framework Question

This is where things got interesting. With everyone talking about AI agents in 2025, I had to ask: should I use LangChain, LangGraph, CrewAI, or any of these agent frameworks?

I researched all of them. Here's what each one actually does and whether it applies.

### What These Frameworks Solve

**LangChain** composes multiple LLM calls into chains. Instead of one API call, you build pipelines like `prompt → LLM → parser → next prompt → LLM → output`. It's genuinely useful when you have 3+ LLM calls that depend on each other.

**LangGraph** extends LangChain for stateful, graph-based agent workflows. Think of it as a state machine where nodes are LLM calls and edges are conditional transitions: "if the email is urgent, do X; if it's spam, do Y; loop if confidence is low."

**LangSmith** is observability for LLM apps — tracing every call, measuring latency, evaluating prompt quality. Useful, but a monitoring tool, not a building tool.

**CrewAI** and **AutoGen** are multi-agent frameworks where you define specialized AI agents (Researcher, Writer, Critic) that collaborate to solve a task.

**LlamaIndex** connects LLMs to your data for search and retrieval (RAG). Great when you're querying over documents — not relevant when you're processing a known set of emails.

### The Complexity Ladder

Here's when you actually need each one:

**Level 0 — Single LLM Call:** You fetch data, send everything to GPT in one prompt, and get a structured response back. No framework needed.

```typescript
import OpenAI from 'openai';
const client = new OpenAI();
const response = await client.chat.completions.create({
  model: 'gpt-4o',
  response_format: { type: 'json_object' },
  messages: [{ role: 'user', content: prompt }]
});
```

Five lines. That's it.

**Level 1 — Sequential Chain:** You want a cheap model (GPT-4o-mini) to pre-filter 200 emails down to 20, then a smarter model (GPT-4o) to deep-analyze the important ones. Two chained LLM calls. LangChain starts adding value here.

**Level 2 — Branching Logic:** The AI doesn't just summarize — it acts. Drafting replies for urgent emails, creating calendar events, auto-archiving newsletters. Each action needs its own LLM call with different tools. LangGraph territory.

**Level 3 — Multi-Agent Collaboration:** Five specialized AI agents (Email Agent, Calendar Agent, Priority Agent, Writer Agent, Critic Agent) working together. You're building a full AI executive assistant, not a morning digest. CrewAI / AutoGen land.

### Where My Daily Digest Falls

Level 0. One API call. I collect all my emails and calendar events, send them to GPT-4o in a single prompt, and get back a prioritized summary. One call, one response, done.

LangChain would wrap those same five lines in abstraction layers without adding anything. LangGraph would give me a graph runtime for what is a straight line. CrewAI would spin up five agents to do what one prompt handles in 2 seconds.

**The practical rule I landed on: use the lightest tool that solves your current problem, not the coolest framework that solves hypothetical future problems.**

You can always add LangChain later — it wraps the same OpenAI SDK underneath. You lose nothing by starting simple. You lose a lot by starting complex: more dependencies, more abstraction to debug, more things that break when libraries update.

* * *

## What I Actually Built

Since I already run n8n on a Raspberry Pi, I built the first version there in about an hour:

```plaintext
[Schedule Trigger: 7 AM daily]
    │
    ▼
[Gmail Node] → fetch last 24h emails
    │
    ▼
[Google Calendar Node] → fetch today's events
    │
    ▼
[Merge Node] → combine into one payload
    │
    ▼
[OpenAI Node] → analyze + prioritize
    │
    ▼
[Telegram Node] → send the digest
```

The OpenAI prompt does the heavy lifting:

```plaintext
You are a personal email and calendar assistant. Analyze the
following emails and calendar events for today. For each item:
1. Score importance (1-5)
2. Categorize (action_required | fyi | meeting | promotional)
3. Write a one-line summary

Then produce a prioritized daily brief with:
- Top 3 things to focus on today
- Meetings/events timeline
- Emails needing response (sorted by urgency)
- Things that can wait
```

Adding a second Google account? Duplicate the Gmail node, add new OAuth credentials. n8n handles token storage. Adding Discord alongside Telegram? Drag in a Discord webhook node after the IF router. Five minutes.

### What the Upgrade Path Looks Like

If I outgrow n8n — if I want complex text preprocessing, custom filtering rules, or a portfolio-worthy project — the same logic rewrites cleanly into a TypeScript pipeline with pluggable steps:

```typescript
interface PipelineStep {
  name: string;
  enabled: boolean;
  execute(ctx: PipelineContext): Promise<PipelineContext>;
}

const pipeline: PipelineStep[] = [
  new GmailFetchStep(),
  new CalendarFetchStep(),
  new SpamFilterStep(),
  new AIAnalyzerStep(),
  new TelegramNotifyStep(),
];
```

Each step takes context in, does its work, and returns updated context. Adding Slack, Jira, GitHub notifications, or weather data is just writing a new step class. The pipeline runner doesn't care what's in the array.

This is the same pattern CI/CD systems (GitHub Actions), data pipelines (Airflow), and workflow engines (n8n itself) use internally. It scales from 5 steps to 50 without architectural changes.

* * *

## What I Learned

**1\. The "right tool" depends on the problem's actual complexity, not its potential complexity.** My problem is: fetch data, call an LLM once, send a message. That's three API calls. I don't need a framework for three API calls.

**2\. Agent frameworks solve real problems — just not this one.** If I were building an AI that drafts replies, resolves calendar conflicts, and learns from my behavior over time, LangGraph would genuinely help. But I'm building a morning summary. The gap between "what the framework solves" and "what I need" is enormous.

**3\. Start with what you have.** I already had n8n running. Using it saved me 5 days of setup versus building a custom TypeScript pipeline from scratch. The custom version is cleaner, more testable, and more impressive on a resume — but the n8n version shipped in an hour and told me if the idea was even worth pursuing.

**4\. OpenAI's structured output is surprisingly good at prioritization.** I expected to need elaborate prompt engineering with few-shot examples and chain-of-thought reasoning. In practice, a clear system prompt with explicit categories and a JSON response format gives consistent, useful results from GPT-4o on the first try. The AI analysis was the part I worried about most and the part that required the least iteration.

**5\. The real cost is $1/month.** Not $20 for Zapier. Not $200 for Temporal Cloud. Not $50 for a fancy serverless platform. One dollar for OpenAI API calls, and everything else is free infrastructure I already had.

* * *

## The Decision Framework

If you're building something similar, here's how to decide:

| Your Situation | Use This |
| --- | --- |
| Already have n8n or similar | Build the flow there in 1-2 hours |
| Want zero infrastructure | GitHub Actions cron + TypeScript script |
| Want maximum learning | Custom TypeScript with extensible pipeline |
| Budget is truly zero | Use GPT-4o-mini ($0.15/1M tokens) — drops cost to ~$0.10/month |
| Need multi-step AI reasoning | *Now* consider LangChain |
| Need the AI to take actions (not just summarize) | *Now* consider LangGraph |
| Building this as a product for others | *Now* consider a real workflow engine |

The answer to "should I use an AI agent framework?" is almost always "not yet." Build the simplest version. Use it for a week. Then ask yourself what's actually missing. Chances are, it's a better prompt — not a better framework.