DEV Community: Mohammed Ayaan Adil Ahmed

Building Meridian: An Autonomous Multi-Agent AI Scheduler with Gemini 3.1

Mohammed Ayaan Adil Ahmed — Tue, 14 Apr 2026 15:10:43 +0000

🚀 The Vision: Beyond Static Scheduling

Scheduling meetings is a universal friction point. We've all experienced the "email tag" fatigue and the loss of context once a meeting ends. For the Google Cloud Gen AI Academy APAC Edition, my teammate Bibi Sufiya Shariff and I built Meridian. An autonomous multi-agent system designed to handle the entire meeting lifecycle.

🧠 The Architecture: Orchestrator & Sub-Agents

Meridian isn't a single script; it’s a fleet of specialized agents coordinated by a central "brain."

The Orchestrator (Gemini 3.1): Using Vertex AI, the orchestrator parses natural language intent and dynamically delegates tasks to sub-agents based on the context.
Calendar Agent: Interfaces with the Google Calendar API to surface real-time availability.
Email Agent: Handles automated dispatch of invites and notifications.
Transcription & Summary Agents: Processes audio/text post-meeting to extract action items and summaries.

💎 The USP: "Glass Box" Transparency

A major challenge with AI agents is trust. Users often feel like they are interacting with a "black box."

We solved this by implementing a Real-time Agent Trace. Using Server-Sent Events (SSE), Meridian streams the agent’s internal reasoning, tool calls, and state changes directly to the UI. You can watch the AI "think" and "act" in real-time.

🛠️ The Tech Stack

Frontend: Next.js (App Router) for a premium, high-aesthetic dashboard.
Backend: FastAPI (Python) serving as the Agent Hub.
AI Layer: Google Vertex AI (Gemini 3.1).
Persistence: Google Cloud SQL (PostgreSQL).
Hosting: Google Cloud Run for scalable, containerized deployment.

📈 Roadmap & Future Scope

This is just the beginning. We're looking forward to expanding Meridian with:

Collaborative Workspaces: Multi-user calendar comparison for team-wide scheduling.
Deep Memory: Using persistent agent state to remember context across months of meetings.
Bio-rhythm Optimization: Suggesting slots based on user productivity patterns.

Building Meridian has been an incredible journey in exploring the limits of agentic workflows. A huge thank you to the Google Cloud team for the support!

🔗 Stay Connected

LinkedIn: https://www.linkedin.com/in/mohammed-ayaan-adil-ahmed-540868311/

Check out the project and let us know what you think in the comments! 👇

machinelearning #productivity #webdev #googlecloud

Moving LLMs to the Edge: Building a Private AI Study Companion with Llama 3

Mohammed Ayaan Adil Ahmed — Wed, 18 Mar 2026 16:02:49 +0000

Moving LLMs to the Edge: Building a Private AI Study Companion with Llama 3

Most AI tutors are just wrappers around an API. When my teammate Ahmed Mohammed Ayaan Adil and I sat down to build Brain Dump, we wanted to solve two specific problems: the stateless nature of current AI tools and the high cost/privacy concerns of cloud-based learning.

🧠 The Core Concept: The "Living Knowledge File"

Instead of just chatting, Brain Dump acts as a distillation engine. It converts messy, long-form learning conversations into a structured, personal Knowledge File.

Think of it as your brain’s notes, but automatically organized and refined by AI as you learn. It doesn't just "forget" the context after a session; it builds a persistent map of what you actually know.

🛠️ The Tech Stack

We focused on local execution to keep the data where it belongs—with the user.

The Orchestrator: FastAPI and LangChain.
The Hardware Edge: Optimized for NPU (Neural Processing Unit) integration to offload LLM tasks from the CPU.
Local LLM: We utilized the ROCm stack to run Llama 3 8B locally, ensuring low latency without a subscription fee.

Why the Edge?

Running locally reduces the marginal cost per user to near-zero. More importantly, it ensures that a student's learning process—including their specific "hiccups" and knowledge gaps—stays private on their own machine rather than being fed back into a corporate training set.

⚡ Key Feature: Hiccup Detection & Pathway Engine

We didn't want a passive chatbot that just nods along. We built a custom Hiccup Detection Chain.

When the system detects a gap in prerequisite knowledge (a "hiccup"), it doesn't just re-explain the current topic. Instead, it:

Pauses the current lesson flow.
Generates a targeted 10-minute micro-learning pathway to fix the specific misunderstanding.
Resumes the main topic only once the foundational gap is bridged.

💡 Reflections

Optimizing a local LLM to handle real-time distillation was a massive technical win. It proved that we are moving toward a world where powerful, personalized AI doesn't require a constant "umbilical cord" to a cloud provider.

Check out the code here:

git791 / Brain-Dump

AI study companion that learns alongside you — automatically extracts concepts from your chat into a personal knowledge file, detects when you're stuck and serves a targeted learning pathway, and exports notes to Anki/Notion. Built with Python, Streamlit & Gemini API, with an AMD ROCm branch for fully offline on-device inference.

📚 Study Companion — Beginner's Guide

A smart study chatbot that helps you learn topics, tracks what you know, and gives you a step-by-step plan when you're stuck.

🧠 What Does This App Do?

You type questions or topics you're studying. The app:

Answers your questions like a tutor
Automatically saves concepts and definitions you've learned
Gives you a 10-minute action plan when you say "I'm stuck"
Lets you export your notes to Markdown, Anki flashcards, or Notion

📁 What Each File Does

File	What it is
`app.py`	The entire app — all the code lives here
`.env`	Your secret API key — never share this
`.gitignore`	Tells git which files to NOT upload to GitHub
`requirements.txt`	List of libraries the app needs to run
`knowledge_notes.json`	Auto-created when you run the app — stores your saved notes

⚙️ How to Set It Up (First Time)

Step 1 — Install Python

…

View on GitHub

How are you integrating local LLMs into your workflow? Let's discuss in the comments!

Designing a "Living" UI: Prototyping Emotional Residue in Figma

Mohammed Ayaan Adil Ahmed — Tue, 17 Mar 2026 15:58:28 +0000

The Systems Thinking Behind the Aura

We have instruments for the physical body, but nothing for the invisible labor of emotional presence. For our project Tide, we wanted to create a bio-responsive interface that visualizes "social proprioception"—the implicit awareness of emotional proximity and relational pressure.

🛠 The Build: Logic Over Pixels

Rather than just drawing screens, we built Tide as a functional simulation within Figma. We leveraged:

Figma Variables & Expressions: To track the "Emotional Reserve" and dynamically update UI states based on user interaction.
Advanced Prototyping: Utilizing "Smart Animate" and "After Delay" triggers to create the organic, bioluminescent pulse of the aura system.
Component Properties: To handle the complex transitions between data-heavy states and ambient visualizations.

🧮 The Math of Empathy

To make Tide more than just a visualizer, we modeled a caregiver's emotional reserve R(t) over a session using this integral:

R(t) = R₀ - ∫₀ᵗ α I(τ) dτ

Where:

R₀ is the starting reserve.
I(τ) is the emotional intensity.
α is the individual’s absorption coefficient.

Tide makes this "empathy calculus" visible in real-time, helping users identify depletion before it leads to burnout.

🎨 Visualizing "Bioluminescence"

The hardest challenge was making data feel felt, not just seen. We moved away from rigid charts and used layered gradients and noise textures in Figma to create a glowing, organic UI.

Compassion Mode: The Interaction Logic

Highly empathetic users are often already overwhelmed by the signals they absorb. A tool that surfaces more raw data could make things worse.

We implemented "Compassion Mode"—a single toggle that shifts the UI from high-fidelity data points to ambient "weather" patterns. It resolves the tension between personal insight and cognitive fatigue by turning "raindrops" of data into a soft, atmospheric glow.

🔗 Explore the Project

To see the "Living Aura" system and our full design logic, you can explore our Figma files below:

Interactive Prototype — Experience the "Flow Ribbon" and Compassion Mode in action.
The Tide Strategy Deck — A deep dive into the research, sensory systems, and future roadmap.

What's next? The immediate next step is a wearable patch prototype: a non-invasive biosensor that correlates skin conductance and HRV to feed the environmental emotional model Tide currently simulates.

Designed by Bibi Sufiya Shariff and Mohammed Ayaan Adil Ahmed.

I Built a Live AI First Aid Agent with Gemini 2.5 Flash in 3 Days

Mohammed Ayaan Adil Ahmed — Sun, 15 Mar 2026 14:12:07 +0000

How I Built CalmAid — A Live AI First Aid Agent with Gemini 2.5 Flash and Google Cloud Run

I created this piece of content for the purposes of entering the Gemini Live Agent Challenge hackathon. #GeminiLiveAgentChallenge

The Idea

In an emergency, people panic. They fumble with Google, get walls of text, and waste critical seconds. I wanted to build something that could just talk to you — calmly, instantly, while also seeing what you're dealing with.

That became CalmAid: speak the emergency, show the injury, hear step-by-step instructions streaming back in real time.

The Stack

Gemini 2.5 Flash — multimodal vision + text generation with streaming
Google GenAI SDK (google-genai) — the new SDK, not the deprecated one
FastAPI — async Python backend
Server-Sent Events (SSE) — real-time streaming to the browser
Google Cloud Run — serverless hosting
Google Secret Manager — secure API key storage
Web Speech API + Speech Synthesis — browser-native voice in and out
GSAP 3 — animations

How Streaming Works

The key insight that makes CalmAid feel live is that text renders and TTS speaks simultaneously while Gemini is still generating.

The backend streams via SSE:

async def stream_gemini(parts):
    response = client.models.generate_content_stream(
        model="gemini-2.5-flash",
        contents=parts,
        config=types.GenerateContentConfig(
            system_instruction=SYSTEM_PROMPT,
            max_output_tokens=300,
        )
    )
    for chunk in response:
        if chunk.text:
            yield f"data: {json.dumps({'chunk': chunk.text})}\n\n"
            await asyncio.sleep(0)
    yield f"data: {json.dumps({'done': True})}\n\n"

The frontend reads the stream and feeds sentences to a TTS queue the moment a sentence boundary (., !, ?) is detected:

function enqueueSentences(newText) {
  ttsBuffer += newText;
  const sentences = ttsBuffer.split(/(?<=[.!?])\s+/);
  ttsBuffer = sentences.pop() || "";
  sentences.forEach(s => { if (s.trim()) ttsQueue.push(s.trim()); });
  if (!ttsActive) drainTTSQueue();
}

The result: the agent starts speaking before the full response arrives. That's what makes it feel genuinely live.

Vision Integration

When a user snaps a photo, it's sent as base64 and converted to a Pillow image on the backend:

if req.image_b64:
    img_bytes = base64.b64decode(req.image_b64)
    img = Image.open(io.BytesIO(img_bytes)).convert("RGB")
    buf = io.BytesIO()
    img.save(buf, format="JPEG")
    img_part = types.Part.from_bytes(data=buf.getvalue(), mime_type="image/jpeg")
    parts.append(img_part)

Gemini then describes what it sees and tailors the first aid advice accordingly.

Deploying to Cloud Run

The whole deploy is one command thanks to --source . which triggers Cloud Build automatically:

gcloud run deploy calmaid-agent \
  --source . \
  --region us-central1 \
  --allow-unauthenticated \
  --set-secrets="GEMINI_API_KEY=gemini-api-key:latest" \
  --memory 512Mi

The API key lives in Secret Manager and gets injected at runtime — never hardcoded, never in the repo.

Challenges

SSE buffer management was trickier than expected. Chunks from the stream reader arrive mid-line, so you have to hold incomplete lines across read cycles:

buffer += decoder.decode(value, { stream: true });
const lines = buffer.split("\n");
buffer = lines.pop(); // hold incomplete line

Python 3.13 compatibility broke several pinned packages. Pillow 10.x and pydantic 2.7.x don't have prebuilt wheels for 3.13 — bumping to Pillow 11.1.0 and pydantic 2.10.0 fixed it.

SDK migration — the google-generativeai package is fully deprecated and streaming was unreliable. Switching to google-genai resolved it completely.

What I Learned

Streaming + TTS together is what makes AI feel live vs turn-based
Browser-native Web Speech API and Speech Synthesis are underrated — zero dependencies, instant
python:3.11-alpine cuts Docker image vulnerabilities dramatically vs slim
Cloud Run + Secret Manager is the cleanest production pattern for API keys

Try It

Live app: submitted via the Gemini Live Agent Challenge portal
GitHub: https://github.com/git791/Calm-Aid

Built for the Gemini Live Agent Challenge. #GeminiLiveAgentChallenge

GreenAI-Agent: Optimizing the Environmental Impact of AI with Gemini

Mohammed Ayaan Adil Ahmed — Wed, 04 Mar 2026 10:50:41 +0000

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

What I Built with Google Gemini

GreenAI-Agent is an intelligent assistant designed to help developers and organizations monitor and optimize the carbon footprint of their AI workloads. As AI models become more complex, their energy consumption grows; this project solves the "visibility gap" by providing real-time insights into the environmental impact of code execution.

Google Gemini served as the "brain" of the agent. I used it to:

Analyze complex energy usage logs and translate raw data into actionable "green" recommendations.
Power the natural language interface, allowing users to ask questions like "Which of my functions is consuming the most power?"
Generate optimized code snippets that prioritize efficiency without sacrificing performance.

Demo

You can find the full source code and documentation here:
GitHub: https://github.com/git791/GreenAI-Agent
StreamLit: https://greenai-agent-pgttexvww7m2bpeschkc6n.streamlit.app/

What I Learned

Building this project taught me a lot about sustainable computing and the nuance of LLM token efficiency.

Technical: I sharpened my skills in prompt engineering—specifically how to ground Gemini's responses in specific hardware telemetry data.
Unexpected Lesson: I realized that even the "Green Agent" has a footprint! It led me to implement a "low-power" mode for the agent itself, where it uses more concise prompts to save tokens and energy.

Google Gemini Feedback

The Good: The context window is a lifesaver. Being able to feed in large logs of execution data without the model "forgetting" the beginning of the run made the analysis incredibly accurate.
The Friction: I ran into some challenges with rate limiting when trying to do high-frequency real-time monitoring. I had to implement a batching system to send data to Gemini every 30 seconds rather than instantly to stay within the free tier limits during development.