@seelffff: ## <i>Full architecture, real ...
Full architecture, real code, and a demo you can replicate tonight.
10 min read · Beginner-friendly · Claude Pro only - no extra cost
Let me tell you what my mornings looked like six months ago. I'd wake up, grab my phone, and spend the first 20 minutes opening five different apps: one for tasks, one for news, one for habits, one for notes, one for market data. By the time I finished checking everything, I was already stressed and behind.
Now I type two letters - "gm" - and 30 seconds later my phone buzzes. The agent has already browsed real websites, read my task list, pulled today's top AI headlines, and texted me everything I need to start the day. I don't open a single app. I just read one message.
This isn't a $200/month SaaS product. It's not a no-code workflow. It's a personal AI agent I built in one afternoon using Claude Desktop, three open-source tools, and a single markdown file that acts as its brain. Here's everything - including the exact code.
The Problem With How We Manage Our Days
Most people use 5–8 apps to run their day. Task managers, news aggregators, habit trackers, note apps, dashboards. Each one is optimized for its own little slice of your life and has no idea what the others are doing.
AI tools promised to fix this. But most AI assistants have a fundamental limitation: they can't actually do anything. They answer questions. They summarize text. But they can't open your real browser and read a live webpage. They can't update a file on your computer. They can't send you a push notification at 7am.
That's the gap this system fills. Not another chat interface - an agent that takes real actions on your behalf, reads your real files, browses real websites, and reaches you on your phone.
The key insight: an AI assistant tells you things. An AI agent does things. That's the difference we're building toward here.
What Makes This Possible: MCP
If you haven't heard of MCP yet, you will soon. Model Context Protocol is an open standard that lets you connect Claude to external tools — like USB ports for AI. Each connection is called an "MCP server," and each server gives Claude a new capability.
The three MCP servers powering this system:
· Filesystem MCP - reads and writes files on your computer. Your notes, your task lists, your knowledge base. The agent can read them and update them.
· Playwright MCP - controls a real Chrome browser. Not a scraper, not an API - an actual browser that opens pages the same way you do. If you're logged in, the agent is logged in.
· Telegram MCP - sends messages to your Telegram. This is how the agent reaches your phone. You don't pull data from it - it pushes data to you.
The crucial point: you don't need API keys for any of this. You don't need a paid OpenAI plan, AWS credits, or a developer account. Everything runs on a standard Claude Pro subscription (~$20/month) that most people reading this already have.
Total additional cost: $0. The only new piece is a Telegram account, which is free.
The Architecture - How It All Connects
Here's the full map of the system before we start building:
```
YOU → Claude Desktop (the brain)
│
├── Filesystem MCP
│ └── ~/agent-system/
│ ├── CLAUDE.md (agent instructions)
│ ├── tasks.md (daily habits)
│ ├── context.md (about you)
│ └── notes.md (research output)
│
├── Playwright MCP
│ └── Real Chrome browser
│ ├── TechCrunch, X.com
│ └── Polymarket, any site
│
└── Telegram MCP
└── Your phone 📱
```You type a command. Claude reads CLAUDE.md (its instruction file), decides what to do, uses the MCP tools, and sends you the result on Telegram. The whole thing runs locally on your Mac or PC. Nothing goes to a third-party server except the Telegram message itself.
Building It - Step by Step
Step 1: Install Claude Desktop and connect MCP servers
Download Claude Desktop from claude.ai/download. Sign in with your Claude Pro account. Then open the config file that controls which MCP servers are active:
```
~/Library/Application Support/Claude/claude_desktop_config.json
```Replace its contents with this - substituting your own folder path, Telegram bot token, and chat ID (we'll get those in a moment):
```json
{
"mcpServers": {
"playwright": {
"command": "npx",
"args": ["@playwright/mcp@latest"]
},
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/Users/yourname/agent-system"
]
},
"telegram": {
"command": "node",
"args": ["/Users/yourname/.mcp-servers/telegram/server.js"],
"env": {
"BOT_TOKEN": "YOUR_BOT_TOKEN",
"CHAT_ID": "YOUR_CHAT_ID"
}
}
},
"preferences": {
"allowAllBrowserActions": true
}
}
```Save the file. Don't restart Claude Desktop yet - we need to build the Telegram server first.
Step 2: Create your Telegram bot
Open Telegram and search for @BotFather. Send it the message /newbot, give your bot a name, and copy the token it gives you - it looks like 1234567890:ABCdef...
Then send any message to your new bot and visit this URL in your browser (replace YOUR_TOKEN with the actual token):
```
https://api.telegram.org/botYOUR_TOKEN/getUpdates
```Find the "id" field inside the "chat" object. That number is your CHAT_ID. Both values go into the config file above.
Security note: treat your bot token like a password. Don't share it publicly. If it gets exposed, revoke it immediately with /revoke in BotFather and generate a new one.
Step 3: Build the Telegram MCP server
This is the only part that involves writing code - and it's 25 lines. You need Node.js installed (check with node --version in terminal). Then:
```bash
mkdir -p ~/.mcp-servers/telegram
cd ~/.mcp-servers/telegram
npm init -y
npm install @modelcontextprotocol/sdk zod
```Open the folder and create a file called server.js with this content:
```javascript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
const BOT_TOKEN = process.env.BOT_TOKEN;
const CHAT_ID = process.env.CHAT_ID;
const server = new McpServer({ name: "telegram", version: "1.0.0" });
server.tool(
"send_telegram_message",
{ message: z.string().describe("Message to send") },
async ({ message }) => {
const url = `https://api.telegram.org/bot${BOT_TOKEN}/sendMessage`;
await fetch(url, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
chat_id: CHAT_ID,
text: message,
parse_mode: "HTML"
})
});
return { content: [{ type: "text", text: "Message sent." }] };
}
);
const transport = new StdioServerTransport();
await server.connect(transport);
```Then open package.json and add one line inside the top-level object:
```json
"type": "module"
```That's the entire server. It receives a text string from Claude and forwards it to your Telegram.
Step 4: Create the agent-system folder
Create a folder at ~/agent-system with four files. This is where the agent lives - it reads these files every time you give it a command.
```
~/agent-system/
├── CLAUDE.md ← instructions (we'll fill this next)
├── tasks.md ← your daily habit list
├── context.md ← background info about you
└── notes.md ← empty for now, agent writes here
```For tasks.md, create a checklist of your daily habits:
```
# Daily Habits EXAMPLE
- [ ] ML Course (1 lesson)
- [ ] Post on X
- [ ] Gym
- [ ] LeetCode (1 problem)
- [ ] English practice
- [ ] Reading (30 min)
- [ ] Water (2L)
- [ ] Neural Networks study
```For context.md, write a short paragraph about yourself - your goals, interests, what you're learning. The agent references this when generating content personalized to you:
```
# About Me
I'm a developer and AI enthusiast learning ML and neural networks.
I'm building in public on X. I care about AI progress, prediction
markets, and shipping fast. My main focus: consistency and depth.
```CLAUDE.md - The Agent's Brain
This is the most important file in the whole system. CLAUDE.md is the permanent system prompt that Claude Desktop reads at the start of every conversation. It's what transforms Claude from a generic chatbot into your personal agent with specific commands and behaviors.
Think of it like an employee handbook. Every time the agent starts a new session, it reads this file and knows exactly what it's supposed to do, how to behave, and which commands it recognizes.
Here's the full CLAUDE.md that powers my system:
```
# MY PERSONAL AI AGENT — Operating Instructions
You are my personal life agent. You help me stay focused, informed,
and consistent with my habits.
## CORE RULES
1. After every command, send the result to Telegram.
Never skip this step.
2. Use English for all outputs.
3. Be direct. No filler words, no unnecessary disclaimers.
4. When you need data from a website, use Playwright to browse
the actual page — don't guess or make things up.
5. Read context.md before generating any personalized content.
## COMMANDS
### gm
Morning briefing. Do this in order:
1. Open TechCrunch with Playwright. Find the 3 most important
AI or tech stories from the last 24 hours. Get real headlines.
2. Read tasks.md. List all unchecked items as today's habits.
3. Write one motivational line (personalized to my context).
4. Format everything clearly and send to Telegram.
### x post idea
Generate 3 viral post ideas for X (Twitter):
- Read context.md to understand my niche and voice.
- Browse X or tech news for what's trending right now.
- Write 3 different hooks: one contrarian take, one personal
story format, one 'here's what I learned' format.
- Send all 3 to Telegram.
### motivate me
Write one powerful, specific motivational message based on
my context and current goals. Not generic. Send to Telegram.
### fact
Find or generate one fascinating, specific fact about AI,
technology, or science. Surprising and shareable. Send to Telegram.
### polymarket check
Open polymarket.com with Playwright. Find the 3 most interesting
active prediction markets. Report current odds and volume.
Add a one-line take on each. Send to Telegram.
### research [topic]
Browse 3 different sources on [topic] using Playwright.
Synthesize the key insights into a concise summary.
Save to notes.md and send a summary to Telegram.
### done: [task]
Find [task] in tasks.md and mark it complete (change [ ] to [x]).
Confirm what was marked and send to Telegram.
### check progress
Read tasks.md. Count completed vs total habits.
Calculate the % and send a progress report to Telegram.
### evening review
Read tasks.md to see what was completed today.
Write a short, honest summary: wins, what was missed, and
one improvement for tomorrow. Send to Telegram.
```This file is the entire intelligence of the agent. No code, no configuration - just plain English instructions. That's the beauty of the system: you can edit it anytime to add new commands, change behaviors, or update your context.
Pro tip: the more specific your CLAUDE.md, the better the agent performs. "Browse TechCrunch" gets better results than "find news." "Write a contrarian take about AI automation" gets better results than "write a post idea."
Restarting and Testing the Agent
With all four steps complete, restart Claude Desktop. When it opens, create a new Project (this is important - Projects in Claude Desktop have persistent memory and read your folder). Add the agent-system folder to the Project.
Now type your first command: gm
Here's what happens: Claude reads CLAUDE.md, sees the instructions for the gm command, opens a real Chrome browser using Playwright, navigates to TechCrunch, reads the actual headlines, goes back to your tasks.md file, reads your habits, formats everything into a clean message, and sends it to Telegram. The whole process takes about 30–60 seconds.
Here's what actually arrived on my phone the first time I ran it:
```
🌅 Good morning! Here's your briefing:
AI NEWS TODAY:
• Anthropic raises at $900B valuation - new frontier model incoming
• OpenAI files suit against xAI over Grok training data
• Stripe announces native AI agent payment infrastructure
• Google Gemini integration coming to 400M cars via Android Auto
TODAY'S HABITS:
☐ ML Course ☐ X Post ☐ Gym
☐ LeetCode ☐ English ☐ Reading
☐ Water (2L) ☐ Neural Networks
One thing: ship something small today. Consistency beats intensity.
Let's go. 🔥
```Real headlines. Real tasks from my file. A message that sounded like it was written for me, not a template. That was the moment I knew this system was worth sharing.
How I Actually Use This Every Day
The system has been running for several months now. Here's how it fits into an actual day — not an idealized productivity workflow, but what really happens.
Morning (7–8am)
I type "gm" while still in bed. By the time I've brushed my teeth, the briefing has arrived. I know what's happening in AI, I know what I've committed to today, and I have one concrete intention for the morning. No app-switching, no doom-scrolling, no decision fatigue.
During the day
When I finish something, I type "done: gym" or "done: ml course." The agent updates the file and confirms. It takes three seconds and it's strangely satisfying to watch the agent do the bookkeeping for me.
When I need a post idea or I'm stuck on what to write, I type "x post idea." The agent browses what's actually trending — not what was trending three hours ago — and gives me three hooks I can work with. About one in three is good enough to publish with light editing.
Evening
"Evening review" pulls everything together. The agent reads what was completed, what wasn't, and writes an honest summary. It's like having a coach who isn't afraid to tell you when you skipped the gym.
Why This Works (When Other Systems Don't)
I've tried most of the popular productivity systems. Notion databases, Obsidian vaults, Zapier automations, Todoist integrations. They all have the same problem: they require you to go to them. You have to open the app. You have to check in. When life gets busy, you stop.
This system inverts the relationship. The agent comes to you. It reaches you on Telegram - the same app you're already using - and delivers exactly what you need. The friction is almost zero, which is why it actually sticks.
The second reason it works is that it's connected to your real data. The agent doesn't give you generic morning motivation because it doesn't know anything about you. It reads context.md. It knows you're building in public, learning ML, and care about prediction markets. The output reflects that.
The third reason: it browses the actual web. Not summaries, not training data from six months ago. When you ask for today's AI news, the agent opens TechCrunch and reads today's headlines. When you ask for Polymarket data, it opens Polymarket and reads live odds. This is the Playwright MCP doing work that no other AI assistant can do without an expensive API.
The agent doesn't replace your judgment - it removes the friction between your intentions and your actions. You still decide what matters. The agent just makes sure you don't forget.
How It Compares to Existing Tools
```
+--------------------------+--------------+-------------+---------+-----------------+
| Capability | This Agent | Notion AI | Zapier | Generic AI apps |
+--------------------------+--------------+-------------+---------+-----------------+
| Browses real websites | Yes | No | Partial | No |
| Reads your local files | Yes | No | No | No |
| Sends Telegram push | Yes | No | Yes | No |
| Understands your context | Deep | No | No | Shallow |
| Customizable commands | Unlimited | Limited | Limited | Limited |
| Extra monthly cost | $0 | $8-16/mo | $20+/mo | $20+/mo |
| No-code setup | Yes | Yes | Yes | Yes |
+--------------------------+--------------+-------------+---------+-----------------+
```Where to Take It Next
What's described in this guide is a foundation. The real power is that every new MCP server you add gives the agent a new capability. Here's what I'm adding next:
· Scheduled morning briefing - the agent sends "gm" automatically at 7am. No typing required. Claude Desktop supports scheduled tasks natively.
· Weekly review - every Sunday, the agent compares this week's habit completion against last week and identifies patterns.
· X post drafting - the agent writes a full post, saves it to a drafts file, and I review before publishing. One step closer to shipping consistently.
· Learning tracker - as I finish ML lessons, the agent logs progress and gives me a weekly study report.
· Mood log - I describe how I feel each morning, the agent tracks it over time and surfaces patterns I'd never notice manually.
Every one of these is just a new section in CLAUDE.md plus, in some cases, a new MCP server. The architecture scales because it's built on plain text and open protocols.
How to Build This Yourself — Full Checklist
Here is everything you need, in order:
· Claude Pro subscription (claude.ai) ~$20/month
· Node.js installed on your computer - nodejs.org, free
· Telegram account - telegram.org, free
· 20–30 minutes of focused setup time
The steps:
The first time it works - the browser opens on its own, reads a real page, and a notification arrives on your phone - it feels like a scene from a sci-fi film. Except you built it yourself in an afternoon.
Final Thought
The AI tools most people use are impressive but passive. You go to them. You ask questions. You get answers. You still have to do everything else yourself.
An agent is different. It acts on your behalf. It reads your files, browses the web, tracks your habits, and reaches you where you already are. It's not a smarter search engine - it's a system that works while you're busy living your life.
The stack I've described here isn't cutting-edge research. It's available to anyone with a Claude subscription and a few hours. What separates people who have this kind of system from people who don't isn't technical ability - it's the decision to build it.
Now you have the blueprints.
my tg channel - https://t.me/+y1dBeWEIm_plMGNi
