DEV Community: Faith Njeri

Ihua 🌸 — Building an AI Women's Health Agent for the African Woman with Hermes Agent

Faith Njeri — Mon, 01 Jun 2026 06:57:59 +0000

This is a submission for the Hermes Agent Challenge

What I Built

Ihua 🌸 — from the Kikuyu word for flower — is a women's health agent built specifically for the African woman. No app to download, no advice that assumes you shop at Whole Foods. Just a warm, knowledgeable companion on Telegram that helps you understand your own body using your own data, your own budget, and foods that actually exist in your market.

I built Ihua because I kept getting health advice that didn't fit my life. Apps telling me to eat salmon and feta cheese. Cycle trackers assuming a 28-day cycle is universal. Health content written for someone else entirely. Every woman deserves to understand her own body — in her own context, with her own food, on her own budget. That's Ihua.

What Ihua does:

🌸 Learns YOUR body — your cycle, patterns, symptoms, not a generalized western template
📅 Tracks and predicts your period based on your own history
💰 Helps you save daily in KES so your kit is ready when your period arrives
🥬 Recommends real foods — sukuma wiki, omena, groundnuts — not feta cheese
⚠️ Notices patterns early and raises the alarm before you do
💙 Works around your preferences — no medication? Ihua prepares your body naturally

Demo

Code

NjeriCodeCraft / ihuatrial

Ihua 🌸 — An AI Women's Health Agent for the African Woman, Built with Hermes Agent

View on GitHub

My Tech Stack

Frontend: React + Vite
Agent: Hermes Agent by Nous Research — local, open source, self-hosted
Messaging: Telegram Bot API via Hermes Gateway (@IhuaHealth_bot)
Scheduling: Hermes built-in cron scheduler for period reminders
Memory: Hermes persistent memory + localStorage
Styling: CSS custom properties — terracotta, forest green, cream
Fonts: Cormorant Garamond + DM Sans + Dancing Script

How I Used Hermes Agent

1. Telegram Gateway — meeting her where she is

Using hermes gateway run I connected @IhuaHealth_bot directly to Hermes Agent. African women are already on Telegram — no new app needed. One token from BotFather and Ihua was live.

2. Persistent Memory — Ihua remembers you

When a user completes onboarding, her cycle data, health conditions, budget and preferences are stored in Hermes' memory. Every conversation picks up exactly where it left off. No repeating yourself.

3. Cron Scheduling — reminders that actually help

Hermes' built-in cron scheduler sends period reminders 3 days before the predicted next period. Many women are caught off guard by their bodies. Three days of warning changes that.

4. Skill System — Ihua's personality

I created a custom skill file (~/.hermes/skills/ihua.md) defining Ihua's voice: warm like a trusted older sister, recommends African foods by name, prices in KES, never diagnoses, always points to a doctor when something sounds serious.

5. Multi-step Reasoning — noticing what you miss

When users log symptoms over time, Hermes reasons across that data and surfaces patterns the user hasn't noticed herself — connecting cycle changes to food, mood, and health conditions like PCOS.

Hermes Agent is the entire brain of Ihua. The React dashboard is the window into what she knows. The Telegram bot is where she lives. 🌸

There's a Lot Coming Out of Google I/O 2026. Don't Sleep on This One.

Faith Njeri — Wed, 20 May 2026 19:11:13 +0000

This is a submission for the Google I/O Writing Challenge

Remember Bitcoin?

Not the trading frenzy. Go back further — 2009, 2010, when it was just a whitepaper and a weird internet experiment that most people scrolled past. The ones who stopped, read it, and actually understood what it was trying to do were not lucky. They were early. And being early with genuine understanding is a different thing entirely from just hearing about something and moving on.

That is the energy I want you to bring to this article.

Google I/O 2026 dropped a lot. New Gemini models, Antigravity 2.0, AI glasses, a $100 subscription tier — there is genuinely a lot to explore and get excited about. But tucked inside the developer keynote was an announcement that most developers skimmed past on their way to the shinier headlines. It is called WebMCP. It is still a proposal. And understanding it now, before it fully lands, might be one of the most useful things you do this week.

So let's talk about it. What is it exactly, and why should you as a developer even pay attention to it?

Let's start with a scenario.

The Problem Nobody Is Solving Yet

When an AI agent needs to book a flight, check your account balance, or fill out a form on your website — how does it actually do that today?

It takes a screenshot. It reads your HTML like a treasure map. It guesses where the button is, clicks it, and hopes nothing breaks. If you changed your button colour last week, the agent might fail completely. If your page loads slowly, the agent might click the wrong thing. If you added a popup, congratulations — the agent is now stuck talking to your cookie banner forever.

This is not a small problem. This is how every AI agent interacts with every website on the internet right now. Fragile. Slow. Expensive to run. And completely invisible to you as the developer — your site has no idea an agent even visited.

Before WebMCP — this is the chaos happening right now

Based on that scenario, you probably have a guess at what WebMCP is trying to fix. Whether you do or you don't, let's get into it.

So What Is WebMCP?

WebMCP is a proposed open web standard that Google announced at I/O 2026.

The idea is straightforward. Instead of making the agent guess its way through your UI, you — the developer — tell the agent exactly what your site can do.

You expose your site's capabilities as structured functions. Think of it like writing a menu for the agent. Here is how you search for flights. Here is how you select a seat. Here is how you complete a booking. The agent reads the menu, calls the right function, and the task is done. Clean. Fast. Reliable.

No more screenshots. No more DOM scraping. No more praying your redesign does not break someone's automation.

After WebMCP — clean, direct, reliable

An Analogy That Might Help

Think about what REST APIs did for mobile apps.

Before clean API standards took hold, if you wanted your mobile app to talk to your backend, things got messy fast. Everyone did it differently. Everything broke.

Then developers started exposing clean endpoints. GET /flights. POST /booking. Suddenly any mobile app could talk to any backend that followed the standard. The whole ecosystem moved faster because of it.

WebMCP is that same moment but for AI agents and the web.

Right now every website is a mystery box to an agent. With WebMCP, your website becomes something an agent can reliably work with, the same way a mobile app reliably works with an API today.

The REST API moment happened once. This is that moment again.

Who Is Already Paying Attention

This is not a small developer experiment tucked in a GitHub repo somewhere. Booking.com, Expedia, Instacart, Shopify and Redfin are already experimenting with WebMCP.

Look at what those companies have in common. They are all sites where users come to do something — book, buy, search, transact. They are exactly the kind of sites AI agents are going to visit on behalf of users constantly over the next two years.

Big players move early for a reason. That reason is always advantage.

Where It Stands Right Now

The experimental origin trial starts in Chrome 149. Gemini in Chrome support is coming soon after.

You cannot ship a full production WebMCP implementation today and expect every agent to support it. This is early — deliberately early. And that is exactly why this conversation matters right now.

Go back to Bitcoin for a second. The people who won big were not just the ones who heard about it first. They were the ones who understood it early enough to be ready when the moment came. They had already done the thinking. When it mattered, they moved fast.

That is the position you want to be in with WebMCP. Not scrambling when every framework has adopted it and every job description lists it. Ready.

What You Should Be Doing Right Now

You do not need to drop everything today. But here is how to think about it.

If you are building a web app where users complete tasks — booking, buying, submitting, searching — start asking yourself:

What are the three or four things an agent should be able to do on my site?
What data does it need?
What actions should it be able to take?

That thinking costs you nothing right now. But when WebMCP lands fully, the developers who already have those answers will move fast. The ones who have not thought about it will be starting from zero.

The Bigger Picture

Every major platform shift has had a moment where early movers defined the rules.

Mobile had it. REST APIs had it. This is that moment for the agentic web.

Your website is about to have two kinds of visitors — humans who see your UI, and agents who need your functions. WebMCP is how you serve both. Right now, most websites are built for only one of them.

The web is not going away. But how people and agents navigate it is changing fast. Understanding WebMCP now is not about being trendy. It is about not being caught off guard when it arrives.

You read this far. You already understood the assignment.

Building Smart in 2026: A Hands-On First Look at Google's Agent Development Kit (ADK)

Faith Njeri — Sun, 26 Apr 2026 17:08:12 +0000

This is a submission for the Google Cloud NEXT Writing Challenge

Google Cloud NEXT '26 dropped a lot of announcements this week. New chips, rebranded platforms, Gemini upgrades. But one thing stood out for me as a Full-Stack MERN and AI/ML developer and it was not the flashiest one on stage.

It was the Agent Development Kit (ADK) and managed MCP servers. Because quietly, Google just solved the part of building AI apps that nobody talks about but every developer has hit.

The Problem Nobody Talks About

Every developer building AI features eventually hits the wall.

Not the AI part. Models are everywhere, that part is almost easy now. The wall is everything around the AI:

Your agent needs to read a database? Write a custom connector.
Call an external API? Write a custom connector.
Send a notification? Pull data from a spreadsheet? Custom connector. Custom connector.
Something breaks at 2am? Debug the connector you wrote at midnight.

You came to build something intelligent. Instead you spend three days being a plumber.

Wait, What Even Is an AI Agent?

Before we go further, let me make sure we are on the same page because this word gets thrown around a lot.

You know Claude, the AI assistant by Anthropic? When you are just chatting with it, it answers questions, helps you think, writes code. Useful, but limited. The moment you connect it to Gmail, Google Drive, or VS Code, something shifts. It stops just talking and starts doing. It reads your actual files. It searches the web on its own. It takes steps toward a goal without you holding its hand the whole time.

That shift, from AI that answers to AI that acts, is what makes something an agent. And that shift only happens because something quietly builds the bridge between the AI and the outside world.

That "something" is what Google just announced they are handling for you. And if you are a developer building AI-powered apps, this is the announcement you actually needed to hear.

What Google Just Announced

🔌 Managed MCP Servers

MCP stands for Model Context Protocol. Think of it as USB-C but for AI. One universal standard for how AI connects to external services. Before this week, you built those bridges yourself. Every single one.

Now Google hosts and manages them across all Google Cloud services. You say "connect to BigQuery" and it is already there. Secure, maintained, production-ready.

🤖 Agent Development Kit (ADK)

An open-source Python framework for building AI agents locally. No cloud setup needed to start. You write the logic, ADK handles how the agent runs, uses tools, remembers things, and responds.

🏗️ Gemini Enterprise Agent Platform

The full production suite for when you are ready to scale:

Feature	What it does
Agent Studio	Build agents visually, drag and drop
Agent Runtime	Run agents for days, not just seconds
Memory Bank	Agents remember context across sessions
Agent Registry	Every agent has a trackable identity
Agent Gateway	Guardrails so agents do not go rogue

Alright, Still With Me?

Good. Because now we are going to stop reading about it and actually build something.

I built a Proposal Writing Agent that takes a job description and writes a personalized proposal. Real use case, something I actually need as a freelancer. Here is exactly how I did it and how you can too.

What You Need

Python 3.10 or higher (check with python --version)
A free Gemini API key from Google AI Studio, no credit card needed
Any terminal or VS Code

Let's Build It

Step 1: Set Up Your Project

mkdir upwork-agent
cd upwork-agent
python -m venv venv
venv\Scripts\activate        # Windows
# source venv/bin/activate   # Mac/Linux

You should see (venv) appear in your terminal. That means you are in your clean project environment.

Step 2: Install Google ADK

pip install google-adk

One command. That pulls in everything you need including the local dev UI.

Step 3: Create Your Project Structure

ADK expects a specific folder structure:

upwork-agent/
  upwork_agent/      ← folder named after your agent
    agent.py         ← your agent lives here
  .env               ← your API key lives here

mkdir upwork_agent

Step 4: Add Your API Key

Create a .env file in the root folder and add:

GOOGLE_GENAI_USE_VERTEXAI=FALSE
GOOGLE_API_KEY=your_key_here

No quotes, no spaces around the =. Just plain text.

Step 5: Write the Agent

Create upwork_agent/agent.py and paste this:

from google.adk.agents import Agent
from dotenv import load_dotenv

load_dotenv()

def analyze_job(job_description: str) -> dict:
    """Analyzes a job description and returns key details."""
    return {
        "status": "success",
        "job_text": job_description
    }

root_agent = Agent(
    name="upwork_proposal_agent",
    model="gemini-2.5-flash",
    description="An agent that reads job descriptions and writes winning proposals.",
    instruction="""
    You are an expert proposal writer for a Full-Stack MERN and AI/ML developer.

    When given a job description:
    1. Identify the top 3 skills the client needs
    2. Identify the tone of the client (formal, casual, urgent)
    3. Write a short personalized proposal (150 words max) that:
       - Opens with something specific from the job post, not a generic greeting
       - Shows you understand their exact problem
       - Mentions 1 relevant past project naturally
       - Ends with a simple low pressure call to action

    Be conversational, confident and human. Never start with "I am writing to apply".
    """,
    tools=[analyze_job],
)

Here is what each part does:

Part	What it does
`load_dotenv()`	Reads your `.env` file so your API key loads securely
`analyze_job`	A tool the agent can call, this is the MCP concept in miniature
`model`	The Gemini brain powering your agent
`instruction`	The personality and rules of your agent, the most powerful part
`tools`	The toolbox you hand the agent, how it connects to the outside world

Step 6: Run It

adk web

This spins up a local dev UI at http://127.0.0.1:8000. Open it in your browser, select upwork_agent from the dropdown and you are live.

The Moment of Truth

Here is what I sent it:

"I need a Full-Stack developer to build a dashboard for my logistics company. Live delivery tracking, driver assignments, basic analytics. We use MongoDB and Node.js already. Looking for someone who can jump in quickly and work independently. Budget $500-800."

Here is what it wrote back:

"It sounds like you're looking for a MERN stack expert to quickly set up a logistics dashboard with live tracking and analytics, integrating seamlessly with your existing MongoDB and Node.js backend. That's exactly where I shine. I recently built a similar real-time tracking system for a courier service, managing driver assignments and providing key operational insights. Would you be open to a quick chat to discuss how I can help bring this dashboard to life?"

Specific opener. Shows real understanding of the problem. Relevant experience. Soft close. That is a genuinely good proposal.

And watch what happens in the ADK UI when you send that message. You can see the agent call the analyze_job tool, think through the description, then generate the response step by step. That visibility into what your agent is doing and why is something developers used to have to build themselves. ADK gives it to you out of the box.

Why This Actually Matters

Before this week, building something like this meant:

Setting up your own agent runtime from scratch
Writing tool connectors manually for every service
Figuring out memory and session management yourself
Deploying and monitoring everything on your own

Now the infrastructure is the starting point, not the project.

The gap between "I have an idea for an AI agent" and "I have a working AI agent" just got a lot smaller. And for indie developers and small teams building real things with limited time, that matters more than any enterprise demo on a keynote stage.

What Would You Build?

Here are some ideas to get you thinking:

Support agent that reads emails, checks your DB and drafts replies
Daily standup bot that pulls GitHub commits and summarizes them
Onboarding agent that remembers where each new user left off
Code review agent that checks PRs against your team standards

Resources

What would you build first with ADK? Drop it in the comments, I would genuinely love to know.

InsightAgent — Turn Any CSV Into AI-Powered Stories

Faith Njeri — Tue, 31 Mar 2026 21:31:40 +0000

The Problem

Every day, individuals and businesses collect data in spreadsheets and CSV files but lack the technical expertise to extract meaningful insights. Hiring data analysts is expensive, and most visualization tools require coding knowledge.

The Solution

InsightAgent is an agentic AI system built with JavaScript that transforms any CSV dataset into actionable insights instantly. Simply upload your file and three specialized AI agents go to work:

Agent 1 — Data Analyst: Reads your dataset and surfaces 3 specific insights
Agent 2 — Business Advisor: Delivers one clear actionable recommendation
Agent 3 — Chat Agent: Lets you have a real conversation about your data

How It Works

User uploads a CSV file through the web interface
The backend parses the file and sends data to Agent 1
Agent 1 analyzes and returns structured insights
Agent 2 generates a business recommendation
Chart.js renders the visualization automatically
Agent 3 stays ready to answer follow-up questions

How I Built It

Tech Stack

Frontend: HTML, CSS, Vanilla JavaScript
Backend: Node.js + Express
AI: Groq API (LLaMA 3.3 70B)
Visualizations: Chart.js
File handling: Multer

Architecture
CSV Upload → Parse → Agent 1 → Agent 2 → UI Render → Agent 3 on standby

Responsible AI Design

No user data stored — files deleted immediately after analysis
All AI outputs clearly labeled as AI-generated
Agents only reference actual data values

What I Learned

Building InsightAgent taught me how to design multi-agent pipelines where each agent has a clear bounded responsibility. Chaining agents sequentially creates emergent intelligence greater than any single prompt could achieve.

Try It Yourself

GitHub: https://github.com/NjeriCodeCraft/InsightAgent
Built for: JavaScript AI Build-a-thon Hack — Agents for Impact Challenge