Open Forem: ANIRUDDHA ADAK

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

I Gave an AI My Study Materials, and It Planned My Entire Learning Schedule. HyperKnow Is Not Just Another Chatbot

ANIRUDDHA ADAK — Wed, 04 Mar 2026 13:22:41 +0000

"What if your AI study partner didn't wait for you to ask, but already knew what you needed to learn next?"

That question kept bugging me after the 100th time I opened ChatGPT, typed "explain neural networks", got a wall of text, closed the tab, and learned absolutely nothing. Sound familiar?

I’ve tested a lot of AI tools over the last year, from study assistants to full agent systems, and most of them are reactive by design.

Then I stumbled onto HyperKnow and honestly, my first reaction was skepticism. Another AI study tool? But 10 minutes in, I was watching it write a script, generate narration, compile Python animation code, and render a full instruction video, all from a single prompt. No plugins. No fiddling. Just results.

Here is how it all started. I posted this thread on X while testing it live:

// Detect dark theme var iframe = document.getElementById('tweet-2027078777290084681-22'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2027078777290084681&theme=dark" }

Let me walk you through what makes this thing genuinely different.

🤖 Wait, What Is HyperKnow Exactly?

HyperKnow bills itself as "Your all-round learning companion", a 24x7 proactive study partner built by the Hyperknow Learning Intelligence Lab. But that tagline undersells it.

The key word is proactive. Most AI tools are reactive. They sit there waiting for your question. HyperKnow's agent (nicknamed Orbie) reads your uploaded files, understands your deadlines, builds a study plan, and starts preparing materials before you even ask.

It's trusted by students from MIT, UC Berkeley, Harvard, Yale, University of Illinois, and more, which tells you the caliber of learners already using it.

💡 HyperKnow calls itself the "World's first proactive agent for learning," and from what I’ve tested so far, it genuinely feels different.

HyperKnow Homepage - World's first proactive agent for learning

🔥 The Feature That Stopped Me Cold: Instruction Video Generation

Okay, let me just show you what happened when I typed:

Make a launch demo video for https://careerzen.vercel.app/

I wasn't expecting much. Maybe a script? A bullet list?

Instead, HyperKnow launched a 4-stage automated pipeline:

Stage	What Happens
✅ Stage 1	Script Writing - structures the narrative
✅ Stage 2	Narration Generation - voice synthesis
✅ Stage 3	Code Generation - writes Python (Manim) animation code
🔄 Stage 4	Video Rendering - renders the final `.mp4`

I tweeted about it live as it was happening. The whole thing kicked off with a single prompt:

// Detect dark theme var iframe = document.getElementById('tweet-2027084765946687588-616'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2027084765946687588&theme=dark" }

Notice how it asked for input via MCQs first, then just started building. That's the proactive intelligence at work. It clarified how to help before diving in.

The Python code it generated was actual Manim animation code, not pseudocode. Neural network visualizations with VGroup, Circle, and layered architectures:

def construct(self):
    # Define network structure
    layers = [4, 5, 3]
    neurons = []

    for i, size in enumerate(layers):
        layer = VGroup(*[
            Circle(radius=0.25, color=BLUE)
            for _ in range(size)
        ]).arrange(DOWN, buff=0.5)

And then came the final videos. Here is the first one I posted, a launch demo video generated in under 2 minutes:

// Detect dark theme var iframe = document.getElementById('tweet-2027081627114111013-471'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2027081627114111013&theme=dark" }

And then the second video, the "AI in 2027" explainer created from a PDF. Worth every second of the wait:

// Detect dark theme var iframe = document.getElementById('tweet-2027087761245942225-813'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2027087761245942225&theme=dark" }

These are fully AI-generated educational videos with animated code, narration, and structured visuals, produced by typing a single sentence. I was genuinely floored.

🧠 Deep Learn Sessions: The Feature I Keep Coming Back To

If the instruction video feature is the showstopper, Deep Learn Sessions is the workhorse. It is the one I actually use every single day now.

Instead of a one-shot Q&A, Deep Learn is a unit-based, AI-led guided learning experience. Think of a professor who never gets tired, never judges you, and actually adapts their explanation to your level in real time.

Here is a real example. I asked HyperKnow to compare Manus AI, Genspark AI, and HyperKnow itself, using the Deep Learn Session mode:

// Detect dark theme var iframe = document.getElementById('tweet-2027277527295611014-46'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2027277527295611014&theme=dark" }

It didn't just answer. It searched across 27+ sources, synthesized a structured conclusion with definitions and key concepts, flagged the Agentic Architecture as the central insight, and kept gathering context while I was reading. That is not a chatbot. That is a research partner.

Notice that "Deep Learn Session" button visible in the interface? Clicking it locks you into a focused, structured session where the AI guides the pace, not you. It is surprisingly effective for staying on track.

What I love about Deep Learn:

📚 Step-by-Step mode - breaks down even IMO-level math problems clearly
🔗 10+ citations per response - not vibes, actual verifiable sources
🎯 Adaptive pacing - naturally slows down where you are struggling
🧩 Concept chaining - connects new ideas to things you already understand

🚀 The Proactive Agent: Orbie Does the Work Before You Ask

This is HyperKnow's philosophical differentiator, and it is where the platform genuinely earns the word proactive.

Upload your course syllabus. Orbie will:

Extract all deadlines and to-dos automatically
Build a calendar of study sessions around your exam dates
Pre-generate study materials (flashcards, cheatsheets, quizzes) before each session
Surface reminders when a session is due, even if you forgot about it entirely

From the HyperKnow website:

"A proactive agent doesn't wait for questions. It understands your learning context and acts ahead of time."

The agent app (agent.hyperknow.io) makes this very tangible. The sidebar has a "Proactive Learning Feed", a live dashboard where Orbie surfaces what you need to work on today, ordered by urgency and your personal learning gaps:

That kind of contextual intelligence, knowing how to help before you have fully formulated what you need, is the difference between a tool and a true partner.

📋 All the Features, Organized

Here is the full feature set as I have experienced it:

Core Agent Capabilities

Feature	What It Does
Concept Explanation (Upgraded)	Step-by-step teaching that adapts to your level
Personal Study Materials Generation	Quizzes, flashcards, cheatsheets from your own files
Long-files Digestion	Reads up to 1,000 pages, cites exact page numbers
Problem Solving	Tackles complex problems with guided, clear steps
Visualization (New)	Generates graphs, diagrams, and animation videos
Instruction Video	Full pipeline: script to narration to code to rendered video

Proactive System

Feature	What It Does
Proactive Learning Feed	Auto-extracts deadlines and tasks from your syllabus
Deep Learn Sessions	AI-led unit learning, structured and fully guided
Knowledge Base Integration	Connects to your files and Canvas LMS seamlessly
Learner's Persona	Builds your unique learning profile that improves over time

💰 Pricing (Surprisingly Reasonable)

Plan	Price	What You Get
Free	$0	Basic agent usage, file uploads, quiz and flashcard generation, proactive features
Pro	$12/month	10x usage limits, Knowledge Base, Memory enabled, early access to advanced features

For what it does, $12/month is genuinely fair, especially compared to AI tutoring platforms that charge per session.

🎯 Pro tip: HyperKnow is currently invite-code gated. Check their website. If a code is displayed, it means spots are open. They also post codes on their TikTok, X/Twitter, and Instagram. Pro users also get a 1:1 onboarding session with the founders and an invite to their official Discord community.

🤔 My Honest Take After Testing

What genuinely impressed me:

✅ The instruction video pipeline is unlike anything I have seen. Typing a URL and getting a rendered educational video in 2 minutes is genuinely remarkable
✅ Deep Learn Sessions feel like a real tutoring experience, not a chatbot conversation
✅ The proactive features actually reduce the cognitive load of planning your own study schedule
✅ The citation quality is legit. It reads and cites your 800-page textbook with page accuracy
✅ The neural network visualizations it generated were production-quality Manim animations

Where It’s Still Growing

⚠️ The proactive system works best when you upload structured materials like syllabi or course slides.

⚠️ Video narration could benefit from more customization options, especially a more humanized and adjustable tone.

🌟 The Bigger Picture

HyperKnow's manifesto says it best:

"We believe education is due for a fundamental change, not through shortcuts or cheating, but a new approach that enables faster learning, deeper understanding, and eliminates barriers to knowledge, for generations to come."

That is not just marketing copy. Every feature, from the proactive planning to the Deep Learn sessions to the instruction video generation to the personalized Learner's Persona, is building toward a vision of AI that partners with your learning process, rather than just answering your questions.

After years of AI tools that are brilliant at generating text but terrible at actually teaching, HyperKnow feels like a meaningful step in the right direction.

🔗 Try It Yourself

🌐 Website: hyperknow.io
🤖 Agent App: agent.hyperknow.io
💬 Discord: discord.com/invite/WXhsUSxtGH
🐦 X/Twitter: @hyperknow_ai

If you're building in the AI education space, this proactive-agent direction is something to pay attention to.

Have you tried HyperKnow or any other proactive AI learning tool?

I would love to hear your experience in the comments, especially if you have used the Deep Learn Sessions for something gnarly like topology or quantum mechanics 👇

From Code Dreams to AI Reality: Building MarketPulse with Google Gemini

ANIRUDDHA ADAK — Fri, 27 Feb 2026 14:21:17 +0000

This is a submission for the Built with Google Gemini: Writing Challenge

What I Built with Google Gemini

I built MarketPulse AI – an intelligent financial analytics platform that leverages Google Gemini to provide real-time market insights, sentiment analysis, and predictive trends. It's essentially your personal AI-powered financial advisor! 📊

The core problem? Traders and investors drown in information overload. There's stock data, news, social media sentiment, and economic indicators everywhere. We needed something to synthesize ALL of that intelligently.

Google Gemini played the MVP role here:

Natural Language Processing: Gemini ingests raw financial news and tweets, then generates coherent market analysis summaries
Sentiment Analysis: It reads investor commentary and extracts bullish/bearish sentiment with incredible accuracy
Predictive Suggestions: Using historical patterns + current data, Gemini generates actionable trading signals ("Consider looking at Tech stocks, they're showing 73% bullish sentiment")
Multi-Modal Understanding: The platform can analyze charts, reports, AND text simultaneously

Demo

https://marketpulse-ai.vercel.app

(Live dashboard showing real-time stock trends and AI-powered insights)

What I Learned

Technical Wins: 🏆

Integrating Gemini API was surprisingly smooth. The documentation is fantastic, and the response latency is impressive – averaging around 1.2 seconds even for complex analyses. I learned how to properly handle streaming responses for real-time data updates.

I discovered that combining Gemini with TensorFlow for time-series forecasting creates a powerful duo. The AI handles the narrative, TensorFlow handles the math. Chef's kiss! 👨‍🍳

Soft Skills & Surprises: 💡

What surprised me most? Gemini's ability to understand context across completely different data types. You can feed it stock charts (images) and quarterly reports (text) in the same prompt, and it genuinely understands the relationship between them.

I also learned the importance of prompt engineering. Small tweaks to how I framed requests to Gemini made massive differences in output quality. Treat prompts like code – iterate and refine!

The Unexpected Lesson: One thing that humbled me – building an AI-powered product isn't about the coolest model, it's about solving REAL problems for REAL users. I initially over-complicated things, but Gemini's simplicity forced me to think about what traders actually need.

Google Gemini Feedback

What Worked Beautifully: ✨

✅ Ease of Integration - The API is intuitive. Getting from "hello world" to production-ready took maybe 4 hours

✅ Consistency - Results are surprisingly consistent across different queries and sessions

✅ Speed - For an AI model of this capability, the response times are genuinely fast

✅ Multi-Modal Capabilities - Being able to analyze images and text together is a game-changer

Where I Hit Friction: 🤔

⚠️ Rate Limiting - During testing, I occasionally hit rate limits. More generous free-tier limits would help devs experiment more freely

⚠️ Fine-tuning - While the base model is incredible, not having fine-tuning capabilities for domain-specific language (stock market jargon) would've been nice

⚠️ Cost at Scale - For production apps with heavy usage, pricing can add up quick. But honestly? It's worth it.

The Honest Truth: Google Gemini is legit. It's not just hype. This is the closest I've come to building something that feels like true AI collaboration. It understands nuance, context, and intent in ways that consistently impress me.

Final Thoughts

Building MarketPulse with Gemini taught me that the future of development isn't about choosing between "AI" and "traditional code" – it's about blending them intelligently. Gemini handles the hard thinking, we handle the smart orchestration.

If you're on the fence about using AI in your projects, take it from me – dive in. The learning curve is gentler than you'd expect, and the possibilities are genuinely exciting! 🚀

Thanks for checking out MarketPulse AI! If you build something cool with Gemini (or any AI), drop a comment – I'd love to see what the community creates! 💻✨

CodeShare Hub: Building a Community-First Code Snippet Platform

ANIRUDDHA ADAK — Fri, 27 Feb 2026 14:19:56 +0000

This is a submission for the DEV Weekend Challenge: Community

The Community

I built this for the amazing Open Source Developer Community on GitHub and DEV. From beginners learning to code to seasoned veterans pushing the boundaries of tech, this community thrives on sharing knowledge and supporting one another. 🚀

As someone deeply involved in the web dev and AI space, I see how scattered code snippets can be across different platforms. Developers waste time searching through countless repositories and forums instead of having one unified, community-driven space.

What I Built

I created CodeShare Hub – a sleek, open-source code snippet platform where developers can instantly save, organize, and share their most useful code snippets. Think of it as a community "brain" for reusable code patterns!

The app features:

✨ Search & Filter Magic - Find snippets by language, framework, or topic in milliseconds

🎨 Beautiful Syntax Highlighting - Code looks gorgeous with support for 50+ programming languages

⭐ Community Ratings - Upvote the most useful snippets (because good code deserves recognition!)

🔗 Share & Collaborate - Generate shareable links and embed snippets directly in blogs

💾 Smart Collections - Organize snippets into folders (because chaos is nobody's friend)

Demo

codeshare-hub.vercel.app

Code

aniruddhaadak80 / codeshare-hub

CodeShare Hub – a sleek, open-source code snippet platform where developers can instantly save, organize, and share their most useful code snippets.
CodeShare Hub

CodeShare Hub is a friendly place to save, organize, and share useful code snippets.
It helps developers keep good code close, so they can reuse it, improve it, and help others faster

✨ Quick look

Why this feels useful

Save snippets before they get lost in old chats, notes, or random files.

Search and explore shared code with level, source, language, and quick-tag filters.

Group snippets into collections when a project grows.

🧭 Interactive product flow
flowchart TD
    A([Open CodeShare Hub]) --> B{What do you want to do?}
    B --> C[Explore public snippets]
    B --> D[Sign in with GitHub or Google]
    B --> N[Save a snippet locally without auth]
    D --> E[Create a new snippet]
    D --> F[Build a collection]
    C --> G[Open a snippet page]
    C --> O[Use level, source, tag, and search filters]
    E --> H[Add title, code, tags, and language]
    H --> I[Publish
…
View on GitHub

How I Built It

I focused on keeping the tech stack modern and lightweight:

Frontend: Next.js 14, React 18, TypeScript for type safety
Styling: Tailwind CSS + Framer Motion for smooth animations
Backend: Node.js with Express, MongoDB for flexible data storage
Syntax Highlighting: Prism.js with custom themes
Authentication: NextAuth.js for community logins
Deployment: Vercel (frontend) + Railway (backend)

The entire project was built over this weekend using best practices like code splitting, lazy loading, and proper error handling. Performance optimization was key – the average page load time is under 1.2 seconds! ⚡

A little fun fact: This project taught me that even in a short timeframe, you can build something meaningful if you focus on what actually matters to the community. No bloatware, just solid engineering! 😄

Thanks for checking out CodeShare Hub! If you build something cool and want to contribute, the repo is open for pull requests. Happy coding! 💻✨