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:

🔴 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.

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:

[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:

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:

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.