DEV Community: ANIRUDDHA ADAK

i burnt $127 in api credits before i fixed these openclaw mistakes

ANIRUDDHA ADAK — Fri, 24 Apr 2026 16:09:00 +0000

This is a submission for the OpenClaw Writing Challenge

everyone is saying openclaw would build my startup while i slept.

instead, i spent two weeks watching it burn through my api credits

while it asked the same question eight times in a row.

it wasn't thinking hard.

it was stuck in a loop, and i was the one paying $0.03 per token to watch it spin.

if you're currently babysitting your agent, watching it loop on simple tasks, or wondering if you should just go back to coding manually — i was there.

i almost gave up.

now i have openclaw running my morning briefings and handling database chores without me touching it.

the difference wasn't buying a better api tier. it was fixing these specific, stupid mistakes.

stop using your expensive model for everything

i had gpt-5.4 set as the default for every single task. heartbeat checks, file scans, cron jobs — all of it. i was asking a formula 1 car to deliver groceries.

openclaw lets you set up tiered model configs. here's what i switched to:

task type	model
file reads, syntax checks, existence queries	`haiku`
actual coding tasks	`sonnet`
complex debugging, things that broke twice	`opus`

my daily token spend dropped from 40,000 to around 1,500.

you can switch models mid-session with /model if you need to escalate, but most of the time, you don't.

your agent needs rules written in stone

out of the box, openclaw will:

loop forever
forget what it was doing
rewrite your database schema because it misread a comment

you have to parent this thing with explicit, paranoid instructions.

i keep a workspace/skills/ folder full of SKILL.md files. these aren't suggestions. they're laws.

workspace/
├── skills/
│ ├── anti-loop.md
│ ├── USER.md
│ └── AGENTS.md

one file is literally called anti-loop.md and says:

"if you see the same error twice, stop and ask me. do not try a third variation."

another forces the agent to check USER.md before asking questions.

every assumption the agent makes is a potential landmine. openclaw doesn't know your database schema. it doesn't remember that you told it yesterday to never touch the auth module. write it down.

the agents that actually work are the ones with heavy custom instruction sets.

closing the chat kills the session

i told openclaw to optimize some queries and message me when done. closed my laptop. came back the next morning to find it had done nothing.

sessions die when you close the chat. they're stateful only while the window is open. when you reopen, you might get a summary, but the context, the stack, the "where was i" — gone.

what to do instead:

use openclaw's cron jobs with isolated session targets
these spin up fresh agent instances on a schedule, do one task, message you results, and die
for one-off tasks, pair a simple sqlite queue with a cron that checks it hourly

# example cron entry
0 * * * * openclaw run --session-target=daily-briefing

don't try to maintain long-running thinking sessions. they break, they cost money, and they hallucinate when context gets long.

one working workflow beats five broken ones

i tried setting up email, calendar, telegram, web scraping, and reporting all at once. everything broke, and i couldn't tell which integration was failing.

start with one thing that hurts slightly every day.

i started with a morning briefing cron that:

reads my calendar
summarizes slack mentions
messages me results

i got that working end-to-end — running without me touching it, messaging me reliably, failing loudly instead of silently — before i added anything else.

every new integration is a new failure mode. if things feel broken, run:

openclaw doctor --fix

half the "my agent is stupid" complaints are actually "my config is borked" problems.

compaction eats your memories

openclaw has a context window. when it fills up, the system compacts older messages — which means it forgets stuff.

i spent twenty minutes explaining my database schema once, then the agent compacted and hallucinated a new one. almost dropped a production table.

now i persist everything important:

what	how
long-running task state	`JSON` or `YAML` state files
user context	`USER.md`
behavior rules	`AGENTS.md`
architectural decisions	decision logs read at session start

the less openclaw has to re-learn, the less it hallucinates.

chat quality and agent quality are different animals

i was using a model that gave beautiful, articulate chat responses. great reasoning. but it couldn't call tools to save its life. it generated malformed json and hallucinated function names.

models that actually work for agentic coding:

claude sonnet / claude opus
gpt-5.4
kimi k2.5 via api

models to avoid:

deepseek reasoner — amazing at thinking, terrible at doing. it reasons beautifully about why your code is broken while generating completely broken tool calls.
gpt-5.3 mini — cheap, but it skips steps and ignores tool results. multiple people have called it useless for agent work.

quick sanity test:
i) give your model three sequential tool calls.
ii) if it can't handle that without hand-holding,
iii) don't use it for autonomous work.

you're not bad at this. it's just early.

the gap between usual demos and daily use is real. when someone posts "my agent built a saas overnight," you're seeing the highlight reel. you're not seeing the three weeks they spent tuning prompts and debugging why openclaw kept trying to pay aws with monopoly money.

this stuff is genuinely hard right now. not "you need a cs degree" hard. just "the tools are immature" hard.

the people making it work are treating these agents like orchestras, not autopilots.

the four rules that changed everything for me:

start with one cron job
write one guardrail file
use the cheap model
save your state

it gets easier. don't give up before the compound interest kicks in.

My First Glimpse Into the Agentic Era: Google Cloud NEXT 2026 Keynote Reflection

ANIRUDDHA ADAK — Thu, 23 Apr 2026 13:56:35 +0000

This is a submission for the Google Cloud NEXT Writing Challenge

The Moment It All Started

It was the evening of April 22, 2026, around 1 PM IST for me here in Kolkata.

I was casually working at my desk when the Google Cloud NEXT Challenge notification popped up on my screen.

Without a second thought, I jumped into the Cida Live stream on YouTube to catch the keynote.

The Opening That Hooked Me

The keynote opened with Sundar Pichai sharing a stat that truly stopped me in my tracks.

75 percent of all code is now written by AI, and it is verified by engineers.

That is a massive shift in how we build software today.

What Stood Out for Me

The keynote had many moments, but a few things really caught my attention.

Google Enterprise Agent

The Google Enterprise Agent was one of the most exciting announcements.

It showed how businesses can now deploy AI agents at scale across their organizations.

This is not just automation, it is a whole new way of working.

Google AI Generation Chip

I was really impressed by the new Google AI generation chip.

The power and efficiency it brings to AI workloads is something every developer should care about.

Gemini Live and Real World Impact

One of the most inspiring moments was the Gemini Live athlete demo.

Gemini was guiding an athlete in real time, showing exactly what to do and tracking progress.

It pointed out mistakes and suggested corrections on the fly.

That is the kind of AI assistance I want in my daily workflow too.

The Agentic Era Is Here

The Google Assistant Platform demo blew my mind.

Agents can now talk to each other, coordinate tasks, and build complete agentic workflows.

With the Agent Development Kit, developers can create multi agent systems with ease.

This is the agentic era that Google is building, and I am here for it.

Big Partnerships That Matter

Google is not building this alone.

They are collaborating with OpenAI, NVIDIA, SpaceX, and even NASA.

These partnerships show how seriously Google is taking AI development and deployment.

YouTube with AI Built In

Another cool reveal was YouTube with an AI assistant built right in.

You can ask questions about your TV, request content, and get personalized recommendations.

It is like having a smart assistant living inside your entertainment experience.

My Take on It All

Every model capability mentioned felt like a step forward for developers like me.

Google is clearly pushing everything toward being AI powered and agent driven.

That is exactly the direction I want to grow in as a developer.

The whole keynote was epic, and I am excited to see where this journey leads.

Wrapping Up

This was my first experience tuning into Google Cloud NEXT, and it set a high bar.

The future of AI is not just coming, it is already here.

And I am ready to be part of it.

Thanks for reading my first Google Cloud NEXT reflection.

The Night OpenClaw Completely Ghosted Me: My Real Headache Story as a Kolkata AI Agent Engineer

ANIRUDDHA ADAK — Tue, 21 Apr 2026 12:48:00 +0000

Hey DEV Community 👋

I’m ANIRUDDHA ADAK (@aniruddhadak on X), final-year B.Tech CSE student at BBIT Kolkata and a full-time AI Agent Engineer who lives and breathes this stuff.

After my last post about the 30 wins that made OpenClaw my 24/7 lobster-powered sidekick , I promised myself I’d also share the messy, frustrating, headache-inducing side. Because let’s be real — no tool is perfect, especially one that’s still growing fast.

This is the raw, first-person story of the night OpenClaw straight-up failed me, ignored my commands, threw ridiculous errors, and left me staring at my screen at 2 AM in my Kolkata room wondering why I trusted a lobster with my workflow.

It started simple enough.

I was deep in a side project — one of my AI agent experiments that needed to scrape some public data, organize it into a clean Markdown file, and push it to a private GitHub repo. I had done similar tasks before and OpenClaw had nailed them. So I fired up WhatsApp at around 11 PM IST and typed a clear, detailed prompt:

“Run a full web research on the latest Ollama model releases, compile them into a clean table in results.md, commit it with message ‘Updated Ollama models - April 2026’, and push to my private repo. Use exec tools only. Confirm each step.”

The lobster replied instantly with its usual confidence:

“Got it, Aniruddha! Starting research now… ✅”

Then… nothing.

For the next 45 minutes it kept sending half-hearted updates like:

“Browsing sites…”

“Compiling table…”

“Almost done…”

But when I checked my repo? Empty. No results.md. No commit. Nothing.

I tried again, this time even more specific. Same thing. It would promise, loop, and ghost me.

Then came the error that made me want to throw my laptop out the window.

“Failed to call a function. Please adjust your prompt. See 'failed_generation' for more details.”

I saw that message pop up in WhatsApp at least 12 times that night. No matter how I rephrased the command, it kept failing the tool call. I even switched from Claude to a local model — same nonsense.

At one point it literally told me:

“I cannot execute commands, I have no exec tool”

…even though I had explicitly enabled full elevated tool access in the config and confirmed it in the gateway dashboard. Classic.

I tried the nuclear option — restarted the gateway, ran openclaw doctor --fix, cleared the session with /new, even rolled back to an older version. Still nothing. It would accept the task, act like it was working, then either hang or give placeholder replies with zero actual execution.

By 3 AM I had burned through way more tokens than I care to admit (the retry loop was ruthless), my head was pounding, and my once-exciting agent project was now just sitting there mocking me.

I finally gave up, did the task manually in 20 minutes, and went to sleep frustrated.

The next morning I dug into Reddit (r/openclaw, r/clawdbot, r/AI_Agents) and realized I wasn’t alone. Tons of people were posting about the exact same pain:

Updates breaking exec tools overnight
“Failed to call a function” becoming the most common error
Agents promising the world but never actually running shell commands or git pushes
Infinite retry loops that quietly drain your API budget

It wasn’t just me. OpenClaw was still early, and these kinds of silent failures and ignored commands were hitting a lot of us.

But here’s the part that still keeps me hooked: even after that nightmare night, I didn’t uninstall it.

I learned three hard lessons that night:

Always start a fresh session (/new) before important tasks — old context can silently break tool calling.
Double-check tool permissions in openclaw.json after every update (the “ask: off” + “security: full” combo saved me later).
Never trust it 100% on autopilot yet. Human oversight is still mandatory, especially for anything that touches git or the terminal.

That headache actually made me a better AI builder. It forced me to understand the internals, read the config deeper, and set up better safeguards (like cost guardians and sandbox checks).

OpenClaw is still the most powerful personal agent I’ve used — when it works, it feels magical. But when it doesn’t… it really doesn’t.

And that’s okay. That’s how real tools grow.

If you’ve had your own “lobster ghosted me” moment, drop it in the comments. My OpenClaw is (hopefully) reading them right now.

Exfoliate! Exfoliate! 🦞 (even on the bad days)

— ANIRUDDHA ADAK

Kolkata, West Bengal, India | April 17, 2026

(X: @aniruddhadak — I test every AI agent so you don’t have to)

This is a separate companion post for the OpenClaw Challenge (Wealth of Knowledge track). The shiny 30-experience version is my love letter. This one is the honest truth.

Both sides make the full picture.

Thanks, happy building ...

OpenClaw + GLM 5.1 = FREE AI AGENTS

ANIRUDDHA ADAK — Sat, 18 Apr 2026 04:44:46 +0000

This is a submission for the OpenClaw Writing Challenge

In this guide, I'll walk you through installing three tools step by step that together give you a free personal AI assistant running right on your computer.

No subscriptions, no monthly fees = completely free.

Here's what we'll install:

Ollama:

A program that lets you run AI models directly on your computer. Think of it as an "engine" that powers artificial intelligence locally. Works on macOS, Windows, and Linux.

GLM-5.1:

An AI model from Chinese company Z.AI (formerly Zhipu AI). Released on April 7, 2026, it's one of the best open-source models in the world. On the SWE-Bench Pro benchmark (a coding test), it scored 58.4 points, more than GPT-5.4 and Claude Opus 4.6. And it's completely free under the MIT license.

OpenClaw:

An AI agent that transforms a regular language model into a full-featured assistant. It can send messages via WhatsApp, Telegram, Slack, Discord, search the web, work with files, write code, and automate tasks. OpenClaw launches through Ollama with a single command.

System Requirements

Before installing, make sure your computer meets these requirements:

Minimum (for cloud models via Ollama Cloud):

Any modern computer
8 GB RAM
5 GB free disk space
Internet connection
Node.js version 22 or newer

Recommended (for local models):

16 GB RAM (for medium-sized models)
GPU with 8+ GB VRAM (NVIDIA recommended)
20+ GB free disk space
Running the full GLM-5.1 locally requires server hardware (the model has 744 billion parameters), but the cloud version via Ollama is free

Important:

If you don't have a powerful GPU, don't worry! GLM-5.1 is available as a cloud model through Ollama (glm-5.1:cloud), and it runs fast without any hardware requirements on your end.

1. Install Ollama

https://ollama.com/

Ollama is the foundation of the entire system. We start here.

Install Ollama by following the link to the official website. Paste the command into the terminal or download the app.

Now Ollama is installed.

2. Choosing GLM 5.1 model

Just type ollama and the program will launch, then select the option “Chat with a model”.

Next, select the desired model, in my case GLM 5.1.

You'll be able to chat with it right in the terminal, ask questions, request code, analyze texts, and more.

Important:

To use cloud models, you need to sign in to an Ollama account. If you don't have one yet, Ollama will prompt you to create one when you first launch a cloud model. It's free.

Now we are connected via the cloud version of GLM 5.1.

3. OpenClaw

https://ollama.com/

Next, going down a little further on the same site, we will install OpenClaw using the command (if it is not already installed):

Ollama will check if OpenClaw is installed on your computer
If not, it will download and install it via npm (Node.js must be installed)
A security notice will appear (OpenClaw is getting access to tools on your computer) – accept it
A model selection screen will open, choose the one you need (for example, glm-5.1:cloud)
OpenClaw will launch in the terminal, and you can start chatting

Launch with configuration before starting:

If you want to configure OpenClaw first (choose a model, connect messengers, etc.):

ollama launch openclaw --config

4. OpenClaw Control Panel (Control UI)

After launching OpenClaw, you can open the web control panel in your browser. Go to:

http://localhost:3000

In the Control UI you'll find:

Chat – chat with the AI assistant right in the browser
Overview – general information about the agent's status
Channels – connect messengers (WhatsApp, Telegram, Slack, Discord, iMessage)
Instances – manage running instances
Sessions – session and conversation history
Usage – usage statistics
Cron Jobs – automated scheduled tasks

At the top of the panel, you can switch between channels and models.

5. Connecting automatic web search

https://docs.ollama.com/integrations/openclaw#web-search-and-fetch

Next, we follow the documentation and enable automatic web search.

OpenClaw can search for information on the internet. If you're using a cloud model through Ollama, web search is enabled automatically.

For local models, you need to install the plugin:

openclaw plugins install @ollama/openclaw-web-search

6. Connecting the messaging platform

https://docs.ollama.com/integrations/openclaw#connect-messaging-apps

Now you can connect messengers that will make it easier to communicate with your agent.

One of OpenClaw's key features is the ability to chat with the AI agent through familiar messengers. You send a message on Telegram and get a response from AI.

Channel setup is done through the Control Panel (Control UI) or via the command:

ollama launch openclaw --config

Select the “Channels” section and follow the instructions to connect the messenger you need.

Link WhatsApp, Telegram, Slack, Discord, or iMessage with this command:

openclaw configure --section channels

For example, to connect a Telegram account, you will need to:

Go to the Telegram bot “BotFather”
Start it
Create a new bot by giving it a name and a username
Once the bot is successfully created, grab its token

Next we add our bot token in the terminal, and we're all set.

7. Using with Claude Code and Codex (Bonus)

Ollama also lets you launch other AI development tools. As shown on the GLM-5.1 page on Ollama, there are ready-made commands:

Claude Code with GLM-5.1:

ollama launch claude --model glm-5.1:cloud

Codex with GLM-5.1:

ollama launch codex --model glm-5.1:cloud

OpenCode with GLM-5.1:

ollama launch opencode --model glm-5.1:cloud

This lets you harness the power of GLM-5.1 through different programming interfaces.

About the GLM-5.1 Model: Why It Matters

GLM-5.1 is a next-generation model from Z.AI (formerly Zhipu AI, a Tsinghua University spinoff). Key facts:

Architecture: 744 billion parameters (Mixture-of-Experts), 40 billion active parameters per token
Context window: 200,000 tokens
License: MIT (completely free, use however you want)
Release date: April 7, 2026

GLM-5.1's key feature is its ability to work autonomously for up to 8 hours, revising its strategy and finding new approaches to problem-solving.

While other models “run out of steam” after their initial attempts, GLM-5.1 continues improving results through hundreds of iterations.

Three commands. Zero subscriptions. Your own AI agent that works for you, not someone else's server. The future is here and it's free.

🔖 Bookmark this – you'll need it again.

🔔 Follow my profile, so you catch guides like this first.

TerraLens: See Your Planet. Shape Its Future. 🌍

ANIRUDDHA ADAK — Fri, 17 Apr 2026 05:45:04 +0000

This is a submission for the Weekend Challenge: Earth Day Edition.

🌍 What I Built

TerraLens is an interactive, visually stunning 3D Earth visualization combined with an AI-powered environmental storytelling experience.

For Earth Day, I wanted to build something that doesn't just show sterile data on a static dashboard, but actually connects people emotionally to the challenges our planet faces.

With TerraLens, you can rotate and explore the globe to discover environmental hotspots (from the Amazon rainforest to the Great Barrier Reef) across four critical dimensions:

💨 CO₂ Emissions
🌳 Forest Loss
🌊 Ocean Health
🦋 Biodiversity

When you click on a region's glowing marker, you don't just get a simple pop-up. Instead, Google's Gemini 2.0 Flash steps in as your "Earth Advisor" — dynamically explaining the local environmental dynamics, the specific challenges that region faces, and what positive actions are being taken right now.

"My intended goal was to make environmental awareness immersive, beautiful, and fundamentally optimistic — empowering users to understand our planet and generate their own personalized 'Earth Day Pledges'."

📸 Features & Demo

I've deployed the project live! You can personally experience the 3D interaction here:

🚀 Experience TerraLens Live

The 3D Environmental Globe

The interactive globe allows you to rotate Earth and cycle through different high-importance data layers like CO₂ emissions, the state of the Oceans, and Biodiversity hotspots.

(A high-level view showing the dark, space-glass UI and the emissions layer)

(Switching to the Oceans layer. Notice the animated KPI dashboard at the bottom updating in real-time!)

The "Earth Advisor" AI Chat

By clicking "Ask Gemini", you unlock an interactive environmental storytelling interface. If you click on specific continent hotspots, the spatial mapping feeds that location's data right into Gemini!

(The Gemini sidebar. It generates contextually-aware responses based exactly on what you're interacting with.)

Generate Your Own Earth Pledge

To promote real-world change beyond just looking at a screen, I programmed Gemini to construct highly personalized, realistically actionable Earth Pledges dynamically.

(A personalized, AI-generated pledge modal generated live using the @google/generative-ai SDK!)

💡 Pro Tip: Try deploying it locally and asking the Gemini chat panel to "Generate a personalized Earth Day Pledge" for you!

💻 Code

You can check out the full source code on my GitHub:

aniruddhaadak80 / terralens-earth-day

🌍 TerraLens — See Your Planet. Shape Its Future.

An interactive 3D Earth visualization with AI-powered environmental storytelling, built for Earth Day 2026.

Explore our planet through an immersive 3D globe showing real environmental data — CO₂ emissions, deforestation hotspots, ocean temperature anomalies, and biodiversity loss. Click on any region and let Google Gemini AI explain the environmental situation and suggest actionable steps.

✨ Features

Interactive 3D Globe — Rotate, zoom, and explore Earth with realistic rendering using Three.js
Environmental Data Layers — Toggle between CO₂ emissions, deforestation, ocean health, and biodiversity
AI Environmental Advisor — Powered by Google Gemini, get personalized insights about any region
Real-Time Stats Dashboard — Animated environmental statistics from public datasets
Earth Day Pledges — Generate personalized sustainability commitments
Responsive Design — Works beautifully on desktop and mobile

🛠️ Tech Stack

Technology	Purpose
Three.js	3D globe rendering with custom shaders
Google Gemini API	AI-powered

…

View on GitHub

🛠️ How I Built It

TerraLens is a completely frontend-driven application built for speed and immersion. Here is the technical breakdown:

The Core Environment: I used Vite + vanilla JavaScript and CSS to keep the bundle as light and blazing-fast as possible.
The 3D Globe: I used Three.js directly to map out custom procedural earth textures, atmosphere shaders, glowing hotspot markers, and the dynamic starfield. Creating a realistic day/night cycle and atmospheric glow required some very careful tweaking of the ShaderMaterial!
The UI Experience: Beautiful, smooth "glassmorphism" panels implemented purely with vanilla CSS variables and backdrop-filter to give it a premium, futuristic look.
The Data: I manually compiled real datasets from public sources like the Global Forest Watch, NASA, and the IUCN Red List. This is structured as a static JSON for zero-latency lookups on the frontend.

🧠 The Hardest Part

The biggest technical challenge was seamlessly connecting the spatial UI (the 3D globe) with the conversational UI.

Clicking a hotspot creates a direct handoff to the Gemini chat panel. To make this work, the app dynamically injects the selected region's environmental data into a hidden system prompt to guide the AI's response format before presenting it to the user.

🏆 Prize Categories

I am proudly submitting this project to the following prize category:

Best Use of Google Gemini ✨: To bring the data to life, I deeply integrated the @google/generative-ai SDK. I used a highly tuned system prompt that instructs Gemini to be an encouraging, optimistic "Earth Advisor".

It receives hidden context about the specific region the user clicks on, formatting the structural JSON data into engaging, human-readable narratives. Crucially, it also has the programmatic capability to generate actionable, localized Earth Day pledges for users based on their chat inputs. It turns TerraLens from a passive encyclopedia into an active conversation!

Thank you for checking out TerraLens, and Happy Earth Day! Let's shape a better future together. 🌍💚

My OpenClaw Journey: 30 Hands-On Experiences That Built My Wealth of Knowledge (Kolkata AI Agent Engineer Edition)

ANIRUDDHA ADAK — Fri, 17 Apr 2026 04:11:33 +0000

This is a submission for the OpenClaw Challenge in the Wealth of Knowledge track.

Hey DEV Community 🙋‍♂️

I’m ANIRUDDHA ADAK (@aniruddhadak on X), a final-year B.Tech Computer Science student at Budge Budge Institute of Technology (BBIT) in Kolkata, and a full-time AI Agent Engineer at heart. I spend my days (and nights) building autonomous agents, experimenting with the latest LLMs, and sharing what actually works on my DEV.to and X.

OpenClaw hit different for me. While everyone was hyped about AI chatbots, I wanted something that executes. So I went all-in — scoured every Reddit thread, X post, DEV.to article, and GitHub repo about OpenClaw, then turned those stories into my daily reality on a spare Ubuntu laptop running Docker + Claude 3.5 Sonnet + local models.

This isn’t a tutorial. This is my raw, first-person journey of how OpenClaw became my 24/7 lobster-powered executive assistant. It chats with me on WhatsApp and Telegram, remembers everything, runs heartbeats, and actually gets shit done. Here’s the wealth of knowledge I’ve gained — 30 real experiences that leveled up my coding, learning, and life as a Kolkata-based AI builder.

Quick Setup Story (My Kolkata Reality)

30 minutes. That’s all it took. Node.js 22, Docker Compose, WhatsApp OAuth, and I was live — fully local, no VPS, no cloud nonsense. Connected it to my personal WhatsApp and family Telegram group. Persistent memory + Obsidian vault + cron heartbeats? Perfect for my chaotic IST schedule and engineering life.

(My real dusty Kolkata setup powering OpenClaw 24/7 — full local ownership)

The Top 30 Experiences (Synthesized from the Entire Internet + My Daily Tests)

Every single one pulled from real community wins and battle-tested by me while building my own AI agents.

Daily Life Automation (1-10)

Morning Briefings — 7 AM IST WhatsApp digest: Kolkata weather, my calendar, top tasks, news, and health stats. Replaced five different apps overnight.
Email Zero Inbox — Cleared 847 emails and unsubscribed from 203 newsletters with scary accuracy. Drafts replies in my exact tone.
Calendar Mastery — OAuth scheduling, conflict detection, autonomous flight check-ins.
File Chaos to Order — Smart renaming and organizing 300+ dev screenshots and files.
Web Research Beast — Browses 15+ sites and structures competitor analyses for my agent projects.
Recurring Heartbeats — Every 4 hours: inbox recap + Indian stocks/crypto portfolio check.
LinkedIn Enrichment — Finds founders talking AI agents and suggests personalized connection intros.
Reddit Trend Watcher — Flags rising topics in r/LocalLLaMA and r/devto for my next builds.
Family History Archivist — Documents stories in our Telegram group and builds a living knowledge base.
Health & Diet Coach — Tracks calories and workouts via chat without any extra apps.

(Real WhatsApp vibe: "Morning brief ready, Aniruddha! ☀️ Kolkata weather + your top 3 tasks")

Dev & Productivity Superpowers (11-20)

Repo Maintenance Bot — Monitors my GitHub (@aniruddhaadak80 / @aniruddhaadak), prioritizes issues, updates docs while I sleep.
Daily AI News Digest — Curated and delivered via Telegram, perfectly filtered for my agent engineering focus.
Code Review Assistant — Spots obvious bugs (human verification always on).
Meeting Prep VA — Pulls context from emails, Slack, and notes before calls.
Content Generator — Drafts DEV.to blogs or LinkedIn posts pulling from my Notion/Airtable.
Custom Skill Builder — Vibe-coded a new skill in chat; it packaged and deployed it itself.
Local Model Experimenter — Switches seamlessly between Claude, GPT, and Qwen on my hardware.
Cost Guardian — Tracks API spend and sets hard limits (saved me real money).
Sub-Agent Spawner — Breaks complex tasks into parallel agents.
Obsidian Memory Vault — Long-term context stored in version-controlled notes I can edit anytime.

Advanced & Fun Wins (21-30)

To-Do & Reminder Overlord — Proactive pings for bills, birthdays, events.
Portfolio Crypto Robot — Monitors + simple trades (small wallet only — learned caution fast).
Networking EA — Drafts human-feeling “executive assistant” emails.
Booking & Reservations — Handles flights and dinners via tools.
Inbox & Slack Cleaner — Archives 80% automatically.
Personal Learning Coach — Turns my DEV.to reading list into daily actionable insights.
Security-First Sandbox — Everything isolated and reviewed.
Real-Time Chat Responses — Replies in groups with full memory context.
Workflow Glue — Connects Gmail, Slack, calendar, browser — feels like a real VA.
Life Leverage Multiplier — Freed 10+ hours/week so I can focus on building agents instead of admin work.

(Watch the lobster magic: Email → Calendar → Heartbeat automation flowing live 🦞)

What I Learned (My Wealth of Knowledge as an AI Agent Engineer)

OpenClaw showed me what personal AI should feel like: persistent memory, heartbeats, chat-first UX, and actual execution. It’s not just another chatbot — it’s a force multiplier.

Yes, token costs need watching and outputs always need verification, but the privacy and ownership of running everything locally on my own machine? That’s pure empowerment for a Kolkata dev like me building autonomous agents.

OpenClaw isn’t perfect yet (still early, some vibe-coding quirks), but the community stories + my own tests convinced me this is the real deal.

If you’re on the fence, set it up today. Start small — one WhatsApp connection and a morning brief. You’ll thank yourself.

Exfoliate! Exfoliate! 🦞

What’s your #1 OpenClaw experience so far? Drop it in the comments — my own OpenClaw instance is reading every single one.

This entire post was 100% powered by my OpenClaw instance.

— ANIRUDDHA ADAK

Kolkata, West Bengal, India | April 17, 2026

(X: @aniruddhadak — I test and share the latest AI agents and LLMs daily. Come say hi!)

The Hyper-Intelligent 418 Teapot: Wasting AI Compute on Tea

ANIRUDDHA ADAK — Sun, 12 Apr 2026 04:04:44 +0000

This is a submission for the DEV April Fools Challenge.

What I Built

I built The Hyper-Intelligent 418 Teapot. In a world where AI is curing diseases, writing complex algorithms, and optimizing logistics, I decided to use it for its truest purpose: aggressively refusing to brew coffee.

Driven by the legendary Larry Masinter's HTCPCP (Hyper Text Coffee Pot Control Protocol), this app is literally designed to do absolutely nothing useful. You click "Brew Coffee," and the AI generates a myriad of completely over-engineered excuses explaining why it's a teapot, throwing an HTTP 418 error directly to your face.

Anti-Value Proposition

This app produces exactly zero milligrams of caffeine. It decreases systemic productivity by arguing with the user, wastes precious processing power to simulate a porcelain vessel, and solves a problem that no one has ever had (accidentally asking a website for coffee). It embodies pure, unadulterated anti-value.

Best Google AI Usage

I integrated the essence of Google's AI capabilities not to summarize your codebase or write emails, but to generate the most contextually aware, heavily-parameterized HTTP 418 errors known to humankind. The prompt engineering exclusively focused on maximizing the AI's indignation at being mistaken for a coffee maker.

Best Ode to Larry Masinter

Larry Masinter envisioned a future where protocols were robust. HTCPCP (RFC 2324) was his gift to the world, and error 418 ("I am a teapot") is its crown jewel. This project exists to ensure that his legacy lives on in the age of Artificial Intelligence.

Happy April Fools! 🫖☕🚫

I built NexusForge: The Multimodal AI Agent Hub for Notion

ANIRUDDHA ADAK — Fri, 20 Mar 2026 15:48:00 +0000

This is a submission for the Notion MCP Challenge

NexusForge is a multimodal workflow app for Notion. It turns screenshots, whiteboard photos, rough sketches, and messy prompts into structured Notion-ready deliverables.

The strongest workflow in the app is diagram to technical brief: upload a system design image, ask for a concise engineering summary, and NexusForge produces a clean markdown artifact that can be previewed immediately and published into Notion as a child page.

I built it to solve a very practical problem: visual thinking happens early, but documentation usually happens later and manually. NexusForge closes that gap.

It combines:
✅ Gemini 3 Flash Preview for multimodal understanding
✅ Notion API for creating real pages from generated markdown
✅ Notion MCP configuration in the workspace, so the repo is ready for direct Notion MCP OAuth in VS Code

Reliability Hardening

To make the app safer for broader public use, I added:

a Notion page picker backed by live workspace search
client-side upload validation for unsupported image types and oversized files
clearer Notion publish errors instead of generic failures
retry and timeout handling for both Gemini and Notion requests
a small runtime health panel so users can see whether Gemini, OAuth, and Notion publish paths are actually ready

Live:

nexus-forge-one.vercel.app

View the source code:

aniruddhaadak80 / nexus-forge

Turn rough visuals into polished Notion deliverables with Gemini, Notion, and MCP.

NexusForge

Turn rough visuals into polished Notion deliverables.

Overview

NexusForge is a challenge-focused multimodal workflow app for Notion. It takes a screenshot, whiteboard photo, product sketch, or architecture diagram plus a text prompt, uses Gemini 3 Flash Preview to generate structured markdown, and then publishes that result into Notion as a child page.

It now supports two Notion auth paths:

Connect Notion with OAuth from the app UI

Fall back to `NOTION_API_KEY` for a workspace token based setup

The project also includes workspace-level Notion MCP configuration in .vscode/mcp.json so the repo itself is ready for direct Notion MCP OAuth inside VS Code.

Why This Is Different

It is built around a concrete workflow, not a generic chat wrapper.

It demonstrates multimodal input with a real generated artifact.

It uses an honest split between Notion MCP for workspace tooling and the Notion API for user-triggered web publishing.

It is screenshot-ready for…

View on GitHub

Demo:

Landing page

Generated result from an uploaded system map

Structure Flowchart

Let's see how the internal pipeline operates using this diagram:

Setup & Implementation Guide

1. The Multimodal Intelligence

I used @google/genai with gemini-3-flash-preview so NexusForge can reason about both text and images in one request. That makes screenshots and architecture diagrams first-class input instead of just attachments.

const contents = [
  {
    text: `${buildSystemPrompt(mode)}\n\nUser request: ${prompt.trim()}`,
  },
];

if (imageBase64) {
  const [meta, data] = imageBase64.split(",");
  const mimeType = meta.split(":")[1]?.split(";")[0] ?? "image/png";
  contents.push({
    inlineData: { data, mimeType },
  });
}

const response = await ai.models.generateContent({
  model: "gemini-3-flash-preview",
  contents,
});

2. The Notion Publishing Path

For the web app runtime, I now support a proper Notion OAuth connect flow. Users can connect their own workspace from the UI, which stores an encrypted session cookie and lets the server publish to Notion using that workspace token. I also kept NOTION_API_KEY as a fallback for internal demos.

Once connected, the app uses the Notion API to create a real child page under a selected parent page:

const response = await fetch("https://api.notion.com/v1/pages", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${notionApiKey}`,
    "Content-Type": "application/json",
    "Notion-Version": "2026-03-11",
  },
  body: JSON.stringify({
    parent: { page_id: cleanParentId },
    properties: {
      title: {
        title: [{ text: { content: title } }],
      },
    },
    markdown,
  }),
});

3. OAuth Callback + Session Handling

The app includes a callback route at /api/notion/callback that exchanges the authorization code for an access token, encrypts the token server-side, and stores it in an HTTP-only cookie. That makes the demo feel like a real connected product rather than a one-off internal script.

4. Where MCP Fits

The repo also includes .vscode/mcp.json pointing at https://mcp.notion.com/mcp, so the workspace itself is ready for direct Notion MCP authentication inside GitHub Copilot or other MCP-capable tools in VS Code.

That means the project demonstrates two complementary ideas:

Web app publishing flow for end users
Workspace MCP integration for AI-assisted Notion operations while developing

Why This Stands Out In The Challenge

It is not just “chat with Notion”. It is a concrete production-style workflow.
It shows off multimodality in a way judges can understand immediately.
It includes a real in-product Connect Notion OAuth handoff instead of relying only on hidden developer credentials.
It uses Notion in a way that feels native: generating polished artifacts and pushing them directly into a workspace.
It is practical across engineering, operations, marketing, and study workflows.
It has been hardened beyond a demo by reducing common user failure modes in the publish flow.

Future Scope

Add PDF and document ingestion for richer multimodal pipelines.
Add template-aware publishing into specific Notion databases.
Add polling and human-in-the-loop approval flows for recurring workflows.

NexusForge aims to redefine exactly how interactive and automated workspaces should feel!

Thank you to Notion and DEV. 💖

building intelligent dreams: my wecoded journey as an ai agent engineer

ANIRUDDHA ADAK — Sun, 15 Mar 2026 16:15:00 +0000

This is a submission for the 2026 WeCoded Challenge: Echoes of Experience

hey everyone, it's aniruddha here. as we dive into the wecoded 2026 challenge, i wanted to take a moment to reflect on my own path in this incredible world of tech. it's been a wild ride, full of learning, building, and a whole lot of coffee.

i remember when i first started tinkering with code. it felt like unlocking a secret language, a way to bring ideas to life. from those early days of crafting simple websites to diving deep into the complexities of full-stack development, every line of code felt like a step forward.

there's a certain magic in seeing your creations come alive on a screen, isn't there. it's that feeling of "it works" that keeps us going through the long nights.

but the real game-changer for me was discovering the power of artificial intelligence, especially in the realm of ai agents. the idea of building systems that can learn, adapt, and even make decisions autonomously, that's what truly captivated me.

it's like teaching a computer to think, to solve problems in ways we hadn't imagined. it's challenging, yes, but immensely rewarding.

there were moments, of course, when i felt completely overwhelmed. the sheer volume of new frameworks, libraries, and concepts in both full-stack and ai development can be daunting. i'd stare at complex architectures, feeling a bit lost in the digital wilderness.

i think every developer, no matter how experienced, has those moments of doubt. those times when the code just won't cooperate and you feel like you're hitting a wall.

that's where the community came in. i found myself drawn to online forums, local meetups, and open-source projects. it was in these spaces that i connected with other passionate developers, people who were just as excited about building the future as i was.

we shared snippets of code, debugged issues together, and celebrated small victories. it was a reminder that even in a field that often feels solitary, we're all in this together.

mentorship has also been a cornerstone of my journey. learning from those who have walked the path before you, absorbing their wisdom and insights, it's invaluable. i've been fortunate to have mentors who not only guided me through technical hurdles but also helped me navigate the broader landscape of a tech career.

their encouragement was like fuel, keeping me going when the challenges seemed too big. it's about that spark of inspiration that lights up the way.

and that's what wecoded, to me, represents. it's a celebration of that collective spirit, that drive to innovate, and that commitment to making tech a more inclusive and inspiring place for everyone.

it's about sharing our stories, our code, and our dreams, and in doing so, empowering others to find their own unique voice in this ever-evolving industry.

i'm still pushing boundaries, still learning new things every single day. the journey of an ai agent engineer and full-stack developer is one of continuous evolution. but with every new challenge, i feel a stronger sense of purpose, knowing that i'm part of a vibrant community that supports and uplifts each other.

what about your journey. what are you building, what are you learning. i'd love to hear your stories and connect with you.

thank you for being here, for reading, and for being a part of this amazing tech community. let's keep building intelligent dreams, together.

with code and camaraderie,
aniruddha adak

Stop Babysitting Prompts: Visualizing Multi Agent Workflows in Next.js

ANIRUDDHA ADAK — Wed, 11 Mar 2026 17:56:25 +0000

This post is my submission for DEV Education Track: Build Multi-Agent Systems with ADK.

"A lot of AI demos look impressive but still hide the actual orchestration. I wanted to make those handoffs deeply explicit."

This post is my official submission for the DEV Education Track on Building Multi Agent Systems.

What I Built

I built Multi Agent Studio, a highly visual web application that turns one broad request into a fully explorable multi agent workflow.

Instead of asking a single hidden model to do everything in one pass, the app intelligently splits the job across four focused roles.

First, Atlas Story handles the heavy planning and framing.
Second, Signal Curator is strictly responsible for evidence gathering and contradiction mapping.

Third, Vector Ops manages the dense execution packaging.
Fourth, Relay Console is thoughtfully used for human review, escalation, and operator readiness.

The application is specifically designed for users who do not want to babysit a giant prompt.

They can dynamically choose a workflow template, edit their core objective, and deeply inspect the full chain of handoffs, artifacts, and recommendations.

Live Demo and Source Code

You can view the full source code directly embedded below.

aniruddhaadak80 / ai-agents-duel

An interactive, narrative-driven AI Agent command center featuring a whimsical Digital Sketchbook UI, live neural feeds, and agent dueling.

Explore the Application

A fully functional Next.js multi agent system that elegantly turns one broad user request into a visible planner, researcher, builder, and reviewer workflow.

Live app: https://ai-agents-duel.vercel.app

GitHub: https://github.com/aniruddhaadak80/ai-agents-duel

This project was carefully rebuilt around the core ideas from the DEV Education track on building multi agent systems. The primary focus is squarely on deep specialization, structured orchestration, explicit handoffs, and rigid review gates. Instead of one giant prompt, the app gives users an entire workflow library, precise agent controls, a visual review queue, and fully inspectable run details.

Extensive Topics and Tags

Here is a look at the major themes covering this repository AI Agents, Build Multi Agents, Gemini 3 Flash, Nextjs, Vercel, Generative AI, Automation, LLM Orchestration, TypeScript Engineering, React 19, Human In The Loop, Agentic Workflows, Google AI Studio, Developer Tools.

Visual Storyboard and Interface

Here is a look at the live dynamic application.

You…

View on GitHub

You can also visit the live application on Vercel to try it yourself right now.

ai-agents-duel.vercel.app

Visual Walkthrough

You can browse the natively available pre built templates directly in the Workflow Library.

You can deeply inspect the exact output and internal thought process in the Run Detail view.

The Mission Board provides a genuinely clear, categorized view of your active tasks and agent assignments in real time.

How the system works

The Core Problem

Users typically type one request, get one answer, and simply cannot tell which role should have handled what.

They do not see where the system confidence silently dropped.
They also do not know exactly when human review is deeply needed or what can be acted on immediately.

By making handoffs explicit, we turn abstract AI operations into a tangible, observable assembly line.

How It Works Under The Hood

The application relies on a workflow first operational model.

Users pick from rich templates like Launch Campaign Studio, Ops War Room, Founder Decision Desk, and Ship Feature Relay.
Each continuous run produces transparent stage ownership across the designated agent team.

It carefully provides a concrete review state, specific agent contributions, and predictive next step recommendations.
Finally, an operator brief is actively generated for incredibly fast human action.

The core orchestration engine currently runs entirely in memory for effortless local setup and seamless Vercel deployment.
If a GEMINI_API_KEY is configured, the selected agent intelligently enriches the final run output utilizing the brand new Gemini 3 Flash Preview model.

Architecture Pattern

The entire system follows a rigorous multi agent pattern logically broken into sequential steps.

First, the Planner accurately scopes the core mission.

Next, the Researcher rigorously gathers context and maps out contradictions.

Then, the Builder systematically converts the raw work into an execution package.

Finally, the Reviewer thoughtfully checks confidence and firmly gates publication.

This architecture keeps the user experience wonderfully simple while still thoroughly proving the massive benefits of true specialization.

Technology Stack

The resilient foundation heavily relies on Next.js 16 and React 19 for a fast modern interface.

Everything is securely and robustly typed with TypeScript.

The styling remains exceptionally lightweight by only using Pure CSS.
The robust Google GenAI SDK reliably manages the artificial intelligence communication layer.

The whole rapid ecosystem is smoothly hosted and delivered on Vercel.

What Makes It Truly Different

I focused heavily on deep usability and structure instead of just raw aesthetics.

The app inherently includes workflow presets for common professional jobs and a real time mission board.
It elegantly features review queue actions alongside granular operator controls for autonomy tuning.
There are also beautifully built in agent pause and resume commands.
It provides an optional Gemini upgrade path without ever breaking standard local runs.

One main architectural challenge was actively avoiding a fake looking multi agent wrapper.
Many early demos simply stop at a stylish dashboard without technical depth.
I strongly wanted the internal model to be robust enough that the visual UI felt deeply justified.

That logically meant entirely rebuilding the internal run store around rigid workflows, stage ownership, structured artifacts, and clear review states instead of just random summaries.

Another prominent engineering challenge was cleanly keeping the project universally easy to deploy.
I effectively chose an in memory backend so the complete experience works immediately on Vercel.
This decision beautifully preserves a wonderfully clean path to add database persistence later.

Key System Learnings

Multi agent user experiences firmly become exponentially more believable when role boundaries remain incredibly explicit.
Review queues genuinely matter because they make autonomy feel safely operational rather than confusingly theatrical.

An optional model enrichment layer serves as a vastly superior onboarding path safely compared to forcing mandatory API keys from day one.
Above all, a highly small but fully inspectable orchestration engine proves decisively more useful than a large opaque one.

Exception OS, a calmer way to handle operational chaos with Notion MCP

ANIRUDDHA ADAK — Mon, 09 Mar 2026 05:33:38 +0000

This is a submission for the Notion MCP Challenge

Exception OS came from a simple frustration. Teams already have enough dashboards, alerts, and summaries. What they usually do not have is a clean way to notice the few situations that actually need judgment, turn those moments into a usable brief, and preserve the final decision somewhere the team will revisit later.

The live demo is here: https://exception-os.vercel.app

The GitHub repository is here:

aniruddhaadak80 / exception-os

Exception-first operations dashboard with live GitHub signals and real Notion MCP publishing workflows.

Exception OS

Exception OS is a deployed SaaS-style operating system for teams that need fewer dashboards and faster decisions. It ingests live operational signals, detects exceptions that require human judgment, generates structured decision briefs, and routes them into a Notion-centered workflow.

Live Demo · GitHub Repository · DEV Submission Draft

Status

Exception OS is complete as a deployable challenge app and SaaS-style product foundation.

Production deployment is live on Vercel.
The dashboard is responsive and verified on desktop and mobile layouts.
Lint, tests, and production build are passing.
Real Notion MCP OAuth, workspace sync, and Notion publishing are implemented server-side.
Other users can use the deployed app by connecting their own Notion workspace.
Live GitHub activity now feeds the dashboard without seeded incident templates.

The only runtime step that still depends on the user is approving Notion OAuth for a specific workspace, which cannot be done automatically on someone else’s…

View on GitHub

What I Built

I built Exception OS, an exception first operating system for teams dealing with operational noise.

Most AI productivity tools try to summarize everything. Exception OS takes the opposite approach. It watches incoming signals, narrows attention to the smaller set of situations that actually require human judgment, and turns those moments into structured decision briefs.

This challenge build is already deployed as a public web app. Other users can open it, connect their own Notion workspace, save a publishing target, and use the live Notion workflow right away.

The app includes a live operations dashboard for signals, exceptions, and decision briefs. It pulls live GitHub activity into the system, uses a real Notion MCP integration with OAuth, PKCE, token refresh, and server side MCP calls, and lets a connected user publish decision briefs directly into Notion pages, databases, or data sources. It also syncs workspace context back from Notion search so the next decision has more useful surrounding context.

In short, Exception OS treats Notion as the operational memory and approval layer for critical decisions.

The desktop view is where the product story starts. It shows the exception queue, the active decision brief, and the live signal layer in a single operating surface.

What Is Real Today

Everything in the core workflow is live today. The app is publicly deployed on Vercel. Each user can connect their own Notion workspace through OAuth. The MCP client is real and runs server side. Workspace search is live. Publishing is live. GitHub repository activity is also live and feeds the upstream operational layer. This is not a mock front end with a pretend integration behind it.

The current limitation is connector breadth. GitHub and Notion are live today, while systems like Stripe, dedicated support tooling, and calendar platforms are still future connectors.

The mobile layout matters here because the workflow is still usable when reduced to its essentials. The same live signal, exception, and brief flow holds together on a small screen.

Video Demo

I am using production screenshots in this submission and the live deployed app for verification. The product can be reviewed directly at the deployed URL, which makes the behavior easier to judge than a prerecorded walkthrough alone.

Live demo: https://exception-os.vercel.app

How I Used Notion MCP

Notion MCP is not decorative in this project. It is the core runtime integration.

I used a real server side Notion MCP client to authenticate users with OAuth 2.0 and PKCE, discover Notion MCP OAuth metadata dynamically, connect to https://mcp.notion.com/mcp over Streamable HTTP, inspect the authenticated workspace, publish decision briefs into Notion as durable operating records, and search the workspace for contextual material that can inform the next decision.

That means the app does not just mention Notion. It actually reads from and writes to Notion through MCP.

It also means different users can connect different Notion workspaces, which makes the deployed app usable beyond my own environment.

In this view, the important part is the Notion MCP panel. That is where a user connects a workspace, saves a publish target, syncs context, and pushes the selected brief into Notion.

Why I Built It

Teams do not usually fail because they lacked dashboards. They fail because critical exceptions get buried across tools, owners, and conversations.

Exception OS is designed around a simple idea:

AI should interrupt humans only when judgment is required.

When a real exception appears, Exception OS creates a decision brief that explains what happened, why it matters now, what the likely cause is, who should own it, what actions should happen next, and what evidence supports the recommendation.

From there, the brief can be pushed into Notion, where the team can review, approve, and preserve the decision as organizational memory.

App Architecture

The app is built with Next.js App Router and React 19 on the front end, plus a server side Notion MCP client powered by @modelcontextprotocol/sdk. Session state is stored in secure encrypted cookies. The signal layer combines live GitHub activity with connected Notion workspace ingestion.

The architecture separates signal generation, decision synthesis, Notion publishing, and workspace context sync. That gives the product a real end to end loop today while keeping the path to broader connector coverage obvious.

I am using the desktop screen here as an architecture reference. The top of the interface establishes live inputs, the center focuses human attention on the current exception, and the lower sections show the normalized signal stream and system structure.

Challenges I Ran Into

The hardest part was treating Notion MCP like a real application integration rather than a prompt only connector.

That meant handling RFC 9470 protected resource discovery, RFC 8414 authorization server discovery, correct PKCE behavior, server side session and token storage, token refresh and reconnect scenarios, and a UI that still works when a workspace is not yet connected.

That extra work was worth it because it turned the project from a mock into a real integration.

The second challenge was turning the upstream feed into something real without depending on private customer infrastructure. I solved that by using live GitHub activity as a public operational signal source and live Notion workspace context as the operator memory layer.

What’s Next

The current version focuses on the decision layer and Notion MCP integration. The next step is to broaden the connector layer so the same workflow can ingest support, revenue, and calendar systems beyond GitHub and Notion. After that, I want to store exceptions in a dedicated Notion data source schema, add approval analytics and learning from human edits, and introduce first party app accounts plus shared team workspaces.

Repo

GitHub repository: https://github.com/aniruddhaadak80/exception-os

Try It

Open the live app, connect your Notion workspace, save a Notion page as the publish target, and start publishing operational decisions directly into Notion. If you want to run it locally, clone the repo, add the environment variables, and start the Next.js app.

This is the quickest way to understand the product. Open the app, connect Notion, save a target page, and the workflow is ready to use from the same screen.

my little notion-powered sidekick

ANIRUDDHA ADAK — Fri, 06 Mar 2026 14:08:53 +0000

this is a submission for the notion mcp challenge

hey there, fellow digital adventurers

i'm here to share a little something i've been tinkering with, something that's made my mornings a whole lot smoother. you see, i've always been a bit of a creative mess, my thoughts and tasks scattered across various apps and sticky notes. it's a charming trait, i tell myself, but not always the most efficient. that's where notion came in, and honestly, it's been a game-changer for my personal organization.

but i wanted more. i wanted to push the boundaries of what notion could do for me, to make it truly my personal command center. and that's how i stumbled upon the notion mcp challenge. it was the perfect excuse to dive deep and build something that would genuinely simplify my daily routine. so, i set out to create my very own 'daily digest' – a little notion-powered sidekick that brings all my essential information into one neat, tidy, and automated page every single morning.

what i built

imagine waking up, grabbing your coffee, and opening notion to a single page that tells you everything you need to know for the day. that's what i built. my daily digest is a personalized notion page that automatically updates with:

the current weather forecast for my location
an inspiring quote of the day to kickstart my motivation
a consolidated list of my to-do items from various sources

it's like having a personal assistant, but without the awkward small talk. it saves me precious minutes every morning, allowing me to focus on what truly matters. it's simple, yes, but sometimes the simplest solutions are the most powerful.

i used to have a desk that looked like a paper explosion, and my digital life wasn't far behind. but with this little project, i've brought a sense of calm and order to my daily chaos. it's amazing what a bit of automation and a well-structured notion page can do.

video demo

show us the code

how i used notion mcp

this is where the magic happens. the notion mcp (model context protocol) was the key to bringing all these disparate pieces of information together. i essentially created a series of integrations that act as bridges between notion and other services. here's a simplified breakdown of how it works:

weather data: i connected to a weather api to fetch the latest forecast for my area. the mcp then takes this data and seamlessly pushes it into a dedicated section on my daily digest page.
daily inspiration: for the quote of the day, i hooked into a quote api. every morning, a fresh dose of wisdom appears on my page, ready to inspire.
task management: this was a big one. i use a few different tools for my to-do lists, and the mcp allowed me to pull all those tasks into a single, unified list within notion. no more jumping between apps to see what i need to do.

the beauty of the notion mcp is how it allows for these

seamless integrations. it unlocks a whole new level of customization and automation within notion, turning it from a powerful tool into a truly personalized system.

my daily digest page is a testament to the power of connected workflows. it’s not just about having information; it’s about having the right information, presented in a way that makes sense for me, exactly when i need it.

i found that by using the mcp, i could really tailor notion to my specific needs, making it less of a generic workspace and more of a bespoke productivity hub. it’s like notion became my personal assistant, always one step ahead.

the little icons that could

to make things even more visually appealing and easy to grasp, i used some simple icons to represent the different data sources. it’s all about making the information digestible at a glance.

conclusion

building this notion-powered daily digest has been an incredibly rewarding experience. it’s not just about the technical challenge, but about creating something that genuinely improves my day-to-day life. i’ve learned so much about the capabilities of notion mcp and the endless possibilities it opens up for personalized workflows.

i hope this little peek into my project inspires you to explore the power of notion and its mcp. whether you’re a seasoned developer or just starting your journey, there’s a whole world of automation and customization waiting to be discovered. go on, build your own little sidekick