DEV Community: ANIRUDDHA ADAK

I Found an AI Agent That Actually Remembers Everything

ANIRUDDHA ADAK — Sat, 30 May 2026 04:00:00 +0000

This is a submission for the Hermes Agent Challenge.

I have been playing with different AI agents for a while now. Most of them feel like clever chatbots that forget everything the moment the conversation ends. Then I tried Hermes Agent from Nous Research a few weeks back. It actually feels different. It grows with you. That stuck with me.

What Hermes Agent is

Hermes is an open-source autonomous agent that runs on your own server or VPS. It is not locked to one IDE or one API. You install it once, pick any model you like, and it starts building its own memory and skills over time.

The big idea is a built-in learning loop. When it solves something useful, it can create a reusable skill in Markdown, improve it later, and pull it back when needed. It also keeps persistent memory across sessions so it slowly builds a picture of how you work and what your projects look like.

I set it up on a cheap VPS with a simple curl command. The installer is straightforward. After that I ran hermes setup and connected it to a model I already had access to. Within minutes I could chat with it from Telegram while it worked in the background on the server. That alone felt freeing.

My experience so far

I started simple. I asked it to monitor a few GitHub repos and send me a daily summary. It remembered the context from previous days without me repeating instructions. Over a week it created a couple of small skills on its own for formatting those reports nicely.

I also used it for research tasks. It can search the web, browse pages, and chain steps together. What surprised me was how it handled follow-ups. Instead of starting fresh each time, it referred back to earlier parts of our conversation. That made longer projects feel more natural.

The multi-platform support is practical. I switch between CLI on my laptop and Telegram on my phone. The agent just continues wherever I left it.

Why it matters

Most agent frameworks still feel stateless. You get good results in the moment but lose the continuity that makes an assistant truly helpful over time. Hermes tries to fix that with persistent memory and auto-generated skills. It is early days, but I can already see how this approach could change how I work with AI day to day.

It is fully open source under MIT license. You own your data and your setup. No tracking. You can run it locally, on a VPS, or even in serverless environments that sleep when idle to keep costs low.

Getting started

If you want to try it yourself:

Run the one-line installer on Linux, macOS, or WSL.
Do the quick setup.
Choose your model provider. It works with many options including local ones.
Start chatting and let it learn.

The official docs are clear and the GitHub repo is active.

I am still exploring what else I can build with it. Right now it feels like having a junior colleague who never forgets the details of our last project and quietly gets better at the things we do together.

If you have tried Hermes or any other agent framework, I would love to hear what worked for you and what did not. The space is moving fast and sharing real experiences helps everyone.

What do you think an open, self-improving agent could mean for your own workflow?

MY DEEP TECHNICAL EXPLORATION AND PERSONAL EXPERIENCE WITH HERMES AGENT

ANIRUDDHA ADAK — Wed, 27 May 2026 07:00:00 +0000

This is a submission for the Hermes Agent Challenge

I want to share my deep technical breakdown and personal journey building with Hermes Agent.

I decided to write an exhaustive guide that combines a how-to tutorial, a detailed technical breakdown, a direct comparison piece, and a personal essay — all rolled into one massive report. I aim to show the community what an open, capable agent system means for the future of artificial intelligence development.

The world of artificial intelligence is moving incredibly fast. Most tools available today are simple chatbot wrappers. You talk to them, they forget everything you said, and you have to start over the next time you log in. I always found this frustrating. I wanted a persistent digital co-worker. I wanted something that remembers my projects, learns from its mistakes, and runs on my own infrastructure instead of someone else's cloud. This is exactly what Hermes Agent delivers. It is an open-source, self-improving artificial intelligence agent built by the talented team at Nous Research.

My goal with this report is to walk you through every single aspect of this system. I will break down how it stacks up against other frameworks, help you decide when to reach for it, and explore its specific capabilities like tool use, planning, and multi-step reasoning. I will keep my language simple and humanised, sharing exactly how I use this tool in my daily workflow.

The Rise of an Open Source Powerhouse

I was completely amazed by the rapid adoption of this framework. Following the early success of older systems like OpenClaw, the community fully embraced Hermes Agent. It crossed 140,000 stars on GitHub in under three months. I monitored the global usage statistics, and as of May 10, it officially overtook OpenClaw on the OpenRouter daily inference rankings. It processed an unbelievable 224 billion tokens in a single day. This volume proves that developers are using it for serious, heavy-duty work.

I believe its success comes from its core design philosophy — reliability and self-improvement — two qualities that have historically been very hard to achieve with autonomous systems.

It is also provider agnostic and model agnostic. I am not locked into using one specific corporate language model. I can use hundreds of different models, including running them entirely locally on my own hardware.

The Five Pillar Architecture That Makes It Work

When I first dug into the technical documentation, I found that the architecture relies on five distinct pillars. This structure is what separates it from standard chat applications. I will explain each pillar based on my direct experience.

1️⃣ The Memory Architecture

The first pillar is the memory system. The agent has real memory, not just a temporary hack. It maintains two small, carefully curated text files on my hard drive:

The environment facts file — tracks conventions and lessons learned.
The user profile file — tracks my personal preferences and communication style.

Because these are standard markdown files, I can open them in any text editor and see exactly what the agent thinks about me. For long-term memory, it stores my messaging sessions in a local database equipped with full-text search capabilities. When I ask a question about a past project, it searches this database and uses the language model to summarize the old conversation.

This clever mechanism prevents API failures caused by sending too much context data at once.

2️⃣ The Procedural Skills Engine

The second pillar is the skills engine. This is my absolute favorite feature. The agent actually learns from its own work. If I ask it to perform a complex task taking five or more tool calls, it recognizes the effort. It then autonomously creates a reusable skill document. This skill is saved in a dedicated directory on my machine. The next time I ask for the same task, the agent does not guess how to do it — it reads its own saved skill document and executes the steps perfectly.

3️⃣ The Soul and Personality Configuration

The third pillar is personality as infrastructure. I define the default voice and behavior of my agent using a global configuration file. This file acts like a continuous system prompt. If I want my agent to act like a senior software engineer, I write that instruction into the configuration file. The agent reads this file every time it starts a new session, ensuring its behavior remains consistent across all my devices.

4️⃣ Scheduled Automations and Cron Jobs

The fourth pillar handles time-based automation. The agent has a built-in scheduler. I do not need to write complex computer code to schedule tasks — I just use natural language.

"Check the news every morning at nine o'clock and send me a summary."

It runs these reports, backups, and briefings completely unattended in the background.

5️⃣ The Closed Learning Loop

The fifth pillar ties everything together. It is a closed learning loop. The agent receives periodic nudges to review its recent actions. It decides what information is useful enough to persist into long-term memory and what should be forgotten. It improves its own skills during use.

This means my agent gets measurably smarter the longer I leave it running on my server.

Exploring the Three Tier Technical Stack

To build a mental model of how this system operates, I broke the architecture down into three logical tiers. Understanding these tiers helped me deeply integrate the agent into my personal computing environment.

Tier One — The Surface Interfaces

The first tier contains all the ways I can talk to the agent. The developers built a single core engine that powers many different adapters:

☑️ Command Line Interface — a classic terminal experience with rich text panels and autocomplete features.
☑️ Messaging Gateway — connects the agent to Telegram, Discord, Slack, WhatsApp, Signal, and many others.
☑️ Editor Protocol — connects the agent directly into my code editor, allowing it to see my active code files.
☑️ Web Dashboard — a beautiful browser interface to manage sessions and files visually.
☑️ Cron Scheduler — handles tasks running in the background without any chat interface.

I find the messaging gateway particularly amazing. I can start a complex debugging task on my laptop terminal in the morning. Later, while commuting home, the agent will send the final diagnostic report directly to my Telegram app. The context is perfectly preserved across every medium. It even supports voice memo transcription, allowing me to simply speak my commands into my phone.

Tier Two — The Core Agent Engine

The second tier is the brain. It manages the core loops, handles tool registration, loads skills from the hard drive, and communicates with the language models. This tier contains the tool registry, which acts like a utility belt holding more than forty system tools. It handles prompt construction, retries, and fallback logic if a model fails to answer correctly.

Tier Three — The Execution Environments

The third tier is where the actual work gets done. Letting an AI run wild on my personal laptop is risky, so the framework provides multiple isolated environments:

local — runs commands natively on my laptop. Fastest, but zero isolation.
docker — spawns a dedicated, isolated container for every session.
ssh — allows the agent to log into a remote virtual machine and treat it as its main computer.
serverless — offloads work to platforms like Daytona or Modal, spinning up instantly for production workloads.

Deep Dive: The Self-Evolving Skill System

I want to spend a significant portion of this report exploring the skill system, because it is the most innovative feature I have ever tested. In most systems, human programmers write the tools. In this framework, the agent owns its own learning artifacts.

When the agent finishes a hard job, it uses a special internal tool to manage skills. It can:

Create a new skill from scratch
Patch a small error in an existing skill
Edit a skill completely
Delete an outdated skill

Each skill lives in a simple folder. The folder contains a markdown file outlining the instructions, and it can also hold reference materials, templates, and Python scripts. The format conforms to an open standard, meaning I can share my custom skills with other developers or install skills built by the community.

The developers took this concept a massive step further with a project called Hermes Agent Self Evolution. This is an evolutionary system that uses advanced techniques to automatically optimize agent skills without requiring expensive GPU training.

I watched it operate via interface calls — mutating text, evaluating results against synthetic data, and selecting the best variants — using a process called Genetic Pareto Prompt Evolution.

I pointed it at my code review skill, let it run for ten iterations, and it produced a measurably better version of the skill. A full optimization run only costs between $2 and $10, making it incredibly accessible for independent developers.

Managing Parallel Workloads with Sub-Agents

Another major technical breakthrough I explored is how the system handles massive workloads. The primary orchestrator agent can spawn completely isolated sub-agents to handle parallel workloads. Each sub-worker gets its own:

Private conversation thread
Sandboxed terminal environment

I observed the primary agent delegating specific research tasks to three parallel workers simultaneously. The primary agent then gathered their outputs using internal remote procedure calls, and synthesized the gathered data into a single final result.

This dramatically reduces the context cost of multi-step pipelines. By collapsing complex research tasks into parallel operations, the system speeds up my workflow by orders of magnitude.

Hardware Acceleration for Local Privacy

I strongly believe in running AI locally. Sending my private code and sensitive financial documents to a corporate cloud provider makes me uncomfortable. Hermes Agent is uniquely optimized for always-on local use.

It runs beautifully on hardware powered by NVIDIA graphics cards. The introduction of the Qwen 3.6 language models changed the game for local agents. The 27B and 35B parameter models in this series deliver data-center-level intelligence directly to my local machine.

The combination of local hardware + powerful open-weight models + self-improving agent framework creates an ecosystem that respects my privacy while delivering massive productivity gains.

Seamless Access with xAI Grok Integration

The framework now supports Grok models through a simple browser-based login. Because I am a premium subscriber, I just log in through my browser, and the system securely connects without requiring me to copy and paste a separate secret key. The integration defaults to the newest models and supports advanced features like prompt caching.

Furthermore, this integration exposes a special tool gateway. This gateway allows my agent to call external internet tools without requiring me to set up individual billing accounts and API keys for every single tool. I can set up a completely fresh server and have an agent performing internet searches and data retrieval within minutes.

A Direct Comparison: Hermes Agent vs. OpenClaw

Feature	Hermes Agent	OpenClaw
Core Strength	Self-improvement and background execution	Multi-channel orchestration and agent teams
Memory Style	Agent-curated markdown files + searchable sessions	Default local DB with vector semantic retrieval
Skill Generation	Autonomous creation based on experience	Static skills installed manually
Initial Setup Time	2–4 hours for full local configuration	Under 30 minutes using container setups
Best Use Case	Personal persistent automation and repeating tasks	Structured corporate agent systems and rapid deployment

OpenClaw is an incredible piece of software. It excels at multi-channel routing, persistent agent teams, and marketplace-driven workflows. It feels heavier, but very mature.

Hermes Agent, conversely, feels much leaner and more personal. It is the better self-improving runtime engine. Its learning loop is the true differentiator.

My ultimate conclusion: OpenClaw wins on orchestration and coordination. Hermes wins on always-on automation and continuous learning.

Some users, myself included, even run both on the same device. I simply told my Hermes agent to read the memory files of my OpenClaw agent, instantly bringing it up to speed on my preferences without any retraining.

Step-by-Step Guide: Installing and Configuring

The developers made the installation process incredibly smooth. I opened my terminal on my Linux machine and ran a single secure command:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

After the download finished, I reloaded my shell environment:

source ~/.bashrc

Next, I configured the intelligence provider:

hermes setup

The system presented an interactive wizard. I chose the quick setup option, selected Minimax global as my provider, and pasted my secure access key.

The final step was setting up the messaging gateway:

hermes gateway setup

I chose Telegram, pasted the token, and set my user ID to ensure no one else could access my agent. I set the run mode to operate as a background system service. Now, I can send a message to my Telegram bot from anywhere in the world, and my home server processes the request. The entire process took less than fifteen minutes.

Deep Technical Breakdown: The LLM Wiki Pattern

I discovered a fascinating workflow pattern called the LLM Wiki pattern. Traditional information retrieval systems (often called RAG) search a database from scratch every time. The LLM Wiki pattern takes a completely different approach.

I point the agent to a folder containing raw source materials like web articles, research papers, and meeting transcripts. The agent compiles this knowledge once and keeps it current — building a persistent, compounding knowledge base formatted as interlinked markdown files.

The architecture is beautiful:

→ Layer 1: Immutable source material
→ Layer 2: Entity pages (people, organizations)
         + Concept pages (broad topics)
         + Side-by-side comparison analyses

Everything is just plain text files in a directory. No hidden database. The knowledge is completely portable and future-proof.

Visualizing Architecture: Creative Diagram Generation

The agent is not just a text processing engine. It possesses powerful creative abilities. When I need to map out a new software system, I simply ask the agent to visualize it. It then writes a standalone HTML file containing beautiful, inline vector graphics using a strict design system:

🟣 Purple — processing steps
🩵 Teal — services
🪸 Coral — data

Another incredible creative workflow is the website-to-video pipeline. I provide a website link, and the agent produces a professional promotional video — completely autonomously — by capturing screenshots, extracting colors and typography, analyzing mood, and passing assets to a rendering engine. This turns a flat website into a dynamic 30-second advertisement without opening a single video editing application.

Final Thoughts: The Future of AI Development

Building with Hermes Agent has profoundly changed my perspective on the future of software development. We are moving past the era of static applications and forgetful chatbots. The future belongs to open, capable agent systems that:

Live on our own infrastructure
Respect our privacy
Continuously evolve

The artificial intelligence landscape is shifting from passive answers to autonomous action — and Hermes Agent is leading the way.

Whether you love to build complex multi-step pipelines or you just want a reliable digital assistant to run your daily morning reports, this system provides the tools necessary to make it happen. I strongly encourage every developer to install it, give it access to a local model, and experience the power of an agent that actually grows with you.

From Half Baked Repos to GitHub Glory: How I Am Finishing My Ambitious 10 App Masterpiece

ANIRUDDHA ADAK — Sun, 24 May 2026 08:25:19 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

we have all been there.

you stay up until two in the morning, fueled by coffee and a brilliant idea,
coding away during a weekend hackathon. you build a fantastic prototype,
but as soon as the event ends and your normal schedule takes over,
that project gets shoved into your github profile and forgotten.

it just sits there, collecting dust, waiting for the day you finally
have the time to make it complete.

i wanted to take one of my most ambitious, unfinished projects and
finally turn it into a polished, production-ready system.

a little about me

my name is ANIRUDDHA ADAK.

i am a final-year B.Tech student in Computer Science and Engineering
at the Budge Budge Institute of Technology (BBIT) in Kolkata, India.

over the last few years, i have worked as a freelance developer,
contributed heavily to open-source repositories,
and built autonomous ai systems.

i love combining modern frameworks with intelligent models,
but i also have a bad habit of starting massive projects
and leaving minor issues unresolved.

this challenge gave me the focus i needed to revisit skillsphere,
my comprehensive productivity and wellness ecosystem.

the mess inside skillsphere

i originally built skillsphere to break out of tutorial learning.

the idea was to build a single platform that could house ten different
mini-applications to help people improve their daily lives. the concept
was vast, hosting all of these tools together:

habit tracker
mood-based recipe recommender
sustainable product comparison
personalized skill builder
virtual body language coach
crowdsourced travel recommendations
neighborhood micro-task exchange
wellness companion
ar workspace planner
live skill exchange network

while the design looked great on paper, managing ten different tools
inside a single workspace led to massive configuration errors.

the codebase was highly advanced, with typescript making up 97.8%
of the platform. however, if you looked at my repository files, you
would find a confusing contradiction.

the setup guide in my readme told users to run python package
installer commands, specifically instructing them to run
pip install requirements

this mismatch happened because i had tried to build local machine learning
tools directly into the frontend structure.

because of this, the environment constantly crashed during builds,
which made me put the project on hold. the main files like
tsconfig.node.json and package.json were filled with overlapping
dependency errors, and several apps like the ar workspace planner
remained half-finished.

rescuing my code with github copilot

i used github copilot as my guide to clean up the codebase and fix
my issues. my transition came down to three main steps:

step one: clean up the installation steps

copilot analyzed my codebase and helped me realize i could replace the
bulky local python scripts with clean client-side logic and
cloud-native ai calls.

this let me remove the confusing pip install instructions from the
setup guide, allowing new developers to deploy the workspace with
simple node commands.

step two: fix the configuration files

copilot helped me rewrite my tsconfig.node.json and package
dependencies to prevent vite build conflicts.

this fixed the structural errors that had been breaking my builds.

step three: polish the user interfaces

i used copilot to quickly generate the missing interactive layouts
for the ar workspace planner and the live skill exchange,
using tailwind css and framer motion to create
a unified experience.

my evolving project portfolio

completing this project represents a major milestone in my journey as
an ai engineer. to understand how my approach has changed, it helps
to compare skillsphere with some of the other applications i have
built over the years.

project name	primary tech stack	original state	refactored state
skillsphere	`typescript`, `react`, `vite`, `tailwind css`	stalled with incomplete sub-apps and a confusing python setup	fully functional suite of ten apps deployed seamlessly on vercel
lingolens	`next.js`, `assemblyai lemur`, `gemini api`, `tailwind css`	basic speech-to-text prototype with simple translation features	comprehensive media analyzer with sentiment analysis and speaker tracking
homewhisper	`typescript`, `gemini ai`, `computer vision`, `vite`	core voice commands and a simple hand gesture library	advanced predictive scheduling, safety diagnostics, and real-time tracking
voicemath	`react`, `typescript`, `tailwind css`, `assemblyai api`	basic dynamic math quiz with simple voice response capturing	fully polished quiz application featuring a practice mode and leaderboard

looking at this table, you can see a clear path of growth.

my earlier projects like voicemath relied on basic web voice
recognition apis to capture user responses and run simple quiz logic.
they were fun and highly interactive, but they did not have
deep processing capabilities.

with lingolens, i stepped up by using assemblyai's lemur api
and google's gemini to perform deep sentiment analysis and keyword
extraction on audio files.

finally, with homewhisper, i pushed the boundaries of multi-modal
systems by writing advanced hand-tracking computer vision algorithms
alongside context-aware voice commands.

this trajectory shows that i am shifting away from static web tools
and moving toward autonomous, multi-modal systems.

the value of building in public

participating in this challenge is not just about competing for prizes.
it is about building a habit of consistency.

during hacktoberfest 2024, i made over 238 pull requests to
open-source projects, which taught me the value of clean code
and documentation.

writing about my code on platforms like dev helps me understand
my own mistakes. it forces me to break down complicated patterns
so other students do not have to struggle through the same issues.

building in public keeps me accountable and pushes me to turn
my rough ideas into stable systems.

what lies ahead

finishing skillsphere has shown me how useful ai assistants are
for managing complex codebases.

as i finish up my computer science studies, my goal is to continue
diving deeper into agentic ai frameworks. i want to build systems
that can work together to solve complex problems, such as my
autonomous agent marketplace agentforge or multi-agent devsecops
systems like secureops-ai.

reviving this repository was a challenging experience, but it was
highly rewarding.

i have turned a confusing, half-finished repository into a clean
workspace that is ready for other developers to use.

i watched google tear down the old internet from a hostel room in kolkata

ANIRUDDHA ADAK — Wed, 20 May 2026 16:23:50 +0000

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

it was well past midnight when i finally leaned back and thought: this is not a product update. this is a different kind of computing altogether.

the fan on my lenovo was whirring steadily. the air in my hostel room in kolkata was thick and humid the way it always gets in may. it was around ten-thirty at night when the google i/o 2026 keynote started streaming on my screen — the main event had kicked off at ten in the morning pacific time, which meant i was watching it nearly half a day behind in india standard time. i kept going until it bled past midnight, because i had a feeling i should not skip a single slide.

i work as a full-stack developer and machine learning engineer. i design scalable software systems and build specialized ai pipelines. so when i say that what google showed that night felt less like a feature drop and more like a paradigm reset, i mean that very literally.

the afternoon of may 20 had me back at my desk for the deep-dive developer sessions. i sat through google cloud live, the firebase integrations, and the antigravity platform walkthroughs, taking notes and occasionally running my own tests in google ai studio. by the time i finished, i had filled several pages with things i needed to process.

what follows is that processing — honest, technical, and written the way i actually think about software.

`gemini 3.5 flash` and the model that runs everything now

the first thing that hit me was the scale of what gemini 3.5 flash is designed to do. this is now the default model powering the gemini app and google search. it is not a research preview. it is live and running at a speed that google claims is nearly four times faster than competing frontier models, at roughly half the cost.

that matters because the use case has changed. this model is not built to answer a question once. it is built for agentic workflows — meaning it is expected to run multiple steps in a row, call external tools, hold context across long sessions, and execute things autonomously without someone typing a new prompt every five seconds.

the benchmark numbers they showed reflected that shift in focus:

benchmark	score	what it measures
`terminal-bench 2.1`	76.2%	command line execution and tool routing
`gdpval-aa`	1656 elo	autonomous agent performance
`mcp atlas`	83.6%	model context protocol integration
`charxiv reasoning`	84.2%	visual understanding and logical reasoning

these are not the benchmarks of a chat assistant. these are the benchmarks of a system that is supposed to do things on your behalf.

`antigravity 2.0` — the part that genuinely made me sit up

i have been using various agentic coding tools for a while now. so i came in sceptical. then varun mohan got on stage and did something that changed my reference point for what "agentic coding" actually means.

he gave antigravity 2.0 a single task: build the core framework of an operating system from scratch.

what the platform did next was this →

i) it spun up 93 separate sub-agents running in parallel
ii) those agents collectively generated 2.6 billion tokens
iii) the entire os framework was completed in roughly 12 hours
iv) the total compute cost came in at under 1,000 dollars

when i read that last figure, i had to re-read it. under a thousand dollars for a coordinated 93-agent os build in twelve hours. that cost structure changes what is financially viable to attempt.

then mohan tried to run doom on the freshly compiled os. it failed because of missing keyboard and video drivers. so he prompted antigravity 2.0 to write the drivers live, on stage. within seconds, freedoom (the open-source variant) was running and fully playable.

i have seen a lot of live demos fall apart. this one did not. and the fact that the failure itself became part of the demo — and got fixed in real time — actually made it more convincing, not less.

antigravity 2.0 is now a standalone desktop application with full cli support. google is actively nudging developers to move away from legacy command line interfaces toward this. i am already testing the migration.

how search became something different

the search box that i have used since i was a kid looks completely different now. under the hood, it is powered by gemini 3.5 flash, and it supports something called generative ui — where instead of returning a list of links, the search engine builds an interactive application or widget for you, on demand.

the feature that stuck with me most is search with canvas artifacts. when you search for something, a side panel opens with a live, editable mini-application. you can drag elements, modify the logic, inspect the structure. it is less like searching and more like summoning a working tool.

this is where i started to feel the ground shift. the result of a search is no longer a document. it is a running program.

`gemini spark` — an agent that runs while i sleep

google introduced gemini spark as a cloud-based, always-on personal agent. it does not need my laptop to be open or my phone to be charged. it runs on dedicated virtual machines inside google cloud, continuously, in the background.

what it handles:

1) calendar organization and scheduling
2) email inbox monitoring and draft responses
3) document drafting across workspace apps
4) task routing to over 30 third-party platforms via the open model context protocol

that last point is significant. spark can interact with platforms like openTable, uber, adobe, and asana — booking reservations, requesting rides, updating project boards. the integration is through mcp, which means it is not a closed google-only pipeline.

to handle the obvious security concern, google built the agent payments protocol. this framework lets users set →

✅ strict spending limits per agent session
✅ transaction restrictions to pre-approved merchants only
✅ mandatory manual human confirmation before any purchase clears

i appreciate that the payments protocol exists. i still think the tradeoffs here deserve careful thought, and i will come back to that later in this piece.

what i actually built in google ai studio

reading about new tools is one thing. i spent several hours testing them myself, which is the only way i trust my own analysis.

android app from a prompt

the android development pipeline inside google ai studio is, genuinely, fast. here is how it went when i built a native task management client:

i) prompt-driven kotlin generation → i selected the "build an android app" option and described what i wanted. the build agent generated production-quality kotlin code using the latest jetpack compose patterns. no scaffolding, no boilerplate hunting.

ii) real-time ui customization → i used the preview editor to draw directly on the virtual interface, adjusting margins and generating custom asset styling through the nano banana generator tool.

iii) emulator and deployment → i tested the build inside the browser using the integrated android emulator, then deployed directly to a physical device via adb. connecting my google play developer account and pushing to the internal test track was a single click.

the whole process from blank prompt to a device-deployed app took me under two hours. that includes the time i spent breaking things on purpose to see what would happen.

web portal deployed to cloud run

i also built a companion web portal to act as a command dashboard for my background agents. the workflow here was notably smooth:

1) workspace api integration → linked the portal directly to google sheets and google drive inside ai studio. no separate database connectors needed.

2) one-click serverless deployment → i hit deploy, and the app was live on google cloud run within seconds. no yaml files, no container configuration.

3) zero-cost developer tier → the first two deployed applications are free, with no credit card required. this matters for prototyping because it removes the friction of "let me check my billing first."

4) codebase export → i pulled the entire project state — conversation history and file structure included — directly into my local antigravity 2.0 desktop environment to continue scaling from there.

`gemini omni` and what it means for video

gemini omni is google's answer to multimodal generation at a serious level. what separates it from older video generators is its architecture — it is a single unified neural network that processes text, images, audio, and video simultaneously, rather than stitching together separate models.

the result is that when you edit a video using gemini omni, the physics are consistent across frames. lighting holds. fluid dynamics behave. if you add a character to a scene, they exist inside the scene's physical logic, not pasted on top of it.

the first iteration, gemini omni flash, is live now for subscribers through the gemini portal and through google flow.

on the content verification side, google has expanded synthid watermarking and c2pa content credentials across gemini omni output. every generated video carries an invisible digital watermark that supposedly persists through →

file compression
screen recording
direct editing

google search and chrome are now actively verifying these credentials. whether the watermarking holds under determined adversarial testing is something i want to see third-party researchers evaluate independently.

the things i think we need to talk about

i am genuinely excited about a lot of what was announced. but i am also a systems engineer, and i think it is important to be honest about the architectural and societal tradeoffs embedded in these announcements.

☑️ the ecosystem trap

antigravity 2.0, firebase, and google cloud run now form a very coherent, very capable development stack. the tighter that integration gets, the harder it becomes to leave. if your agents write code, host it, deploy it, and maintain it all within a single ecosystem, you are building a dependency that will cost you significantly if you ever need to migrate. this is worth thinking about before you go all in.

☑️ token consumption at scale

gemini 3.5 flash is cost-efficient for a frontier model. but complex agentic workflows eat context windows at a rate that adds up fast. when you are coordinating multiple sub-agents that are continuously analyzing codebases and running tests, token costs can spiral quickly. this is almost certainly the reason behind the new 100 dollars per month ai ultra subscription tier — it is not just a upsell, it reflects the actual compute cost of power users hitting baseline api quotas regularly.

☑️ surveillance by convenience

for gemini spark and android halo to do what they are designed to do — proactive cross-app automation — they need to observe a continuous, detailed picture of your digital life. your emails. your calendar. your purchases. your workflows across thirty-plus third-party platforms.

the traditional security boundary between separate applications has to dissolve for this to work. you are not paying for these features with money alone. you are paying with the depth and continuity of your behavioral data. that is a real tradeoff, and i think every developer who builds on top of these platforms should make that tradeoff consciously rather than by default.

i am not saying do not use these tools. i am saying understand what you are agreeing to when you do.

what i am actually doing with all of this

for developers and system architects who want to move intentionally through this new landscape, here is how i am thinking about it:

→ migrate to the antigravity cli

if you are a command-line developer (and if you are reading this, you probably are), the new antigravity cli is worth switching to from the legacy gemini cli. it brings sandboxed execution, credential masking, and secure git policies as first-class features.

→ build for webmcp compatibility

when you are building web applications now, expose structured tools — javascript functions, html forms — using the proposed webmcp open standard. if your web interface is not navigable by a browser-based ai agent, it will increasingly be invisible to the workflows people build around these tools.

→ manage your token footprint deliberately

configure persistent, isolated environments when calling the gemini api. resuming existing multi-turn sessions rather than re-uploading full file contexts on every call can meaningfully reduce operational costs and keeps session coherence intact.

→ use safe play store tracks first

if you are vibe-coding mobile apps inside google ai studio (and honestly, i have been), always connect to the internal test track before you do anything else. isolate your early prototypes completely from production builds while you are still figuring out what you actually built.

where i ended up

it was past one in the morning in kolkata when i finally closed the last session tab. the fan on my laptop wound down. the room was quiet again.

i have been a developer long enough to feel the difference between a year where things get incrementally better and a year where the underlying model of how software gets built actually changes. this felt like the second kind.

the agent is not a feature you add to your product anymore. the agent is the environment your product runs inside.

that sentence is what i kept coming back to as i fell asleep. i think it is the most accurate single-line description of what google announced at i/o 2026.

to follow the ongoing release of these tools, visit io.google/2026 or check what i am building at github.com/aniruddhaadak.

— aniruddha adak, kolkata, may 20, 2026

google i/o 2026 just changed everything - here's what i learned after testing

ANIRUDDHA ADAK — Tue, 19 May 2026 20:44:53 +0000

this is a submission for the google i/o writing challenge

i spent 100 hours testing (just joking 😜) everything google announced at i/o 2026. what started as curiosity turned into a full-blown obsession. here's what i found.

google i/o 2026 wasn't just another conference. it was a fundamental shift in how ai integrates into our daily workflows. the announcements weren't incremental improvements - they were paradigm changes.

the big picture

before diving into specifics, let me share what stood out most:

i) gemini 3.5 flash - the agentic and coding model that actually delivers on its promises
ii) antigravity 2.0 - standalone desktop app with multi-agent teams that work seamlessly
iii) gemini omni - creates anything from any input, starting with video
iv) spark - your 24/7 personal ai agent that never forgets context

these four represent the core of what makes this year's conference different. but there's more

gemini 3.5 flash

google claims gemini 3.5 flash is their strongest agentic and coding model, with 4x speed improvements. i was skeptical. after two weeks of daily use, i'm converted.

the benchmark numbers look good on paper, but the real test is in everyday use. i've been using it for:

[1] code review and optimization
[2] debugging complex multi-file projects
[3] generating documentation from scratch
[4] refactoring legacy codebases

the difference from previous versions is noticeable. where earlier models would get stuck on context windows or lose track of requirements, gemini 3.5 flash maintains coherence across longer conversations. the coding output is cleaner, more efficient, and requires less iteration.

i tested it on a project with over 50,000 lines of code. the model understood the architecture, identified performance bottlenecks, and suggested optimizations that saved me hours of manual work. it's not perfect, but it's close..

antigravity 2.0

i've been using antigravity for scheduled tasks, and the 2.0 reinstallation was a game-changer. the new standalone desktop app feels completely redesigned.

the multi-agent team capabilities are exactly what i needed. i can set up complex workflows that run automatically, and the system handles dependencies between tasks intelligently. here's what i set up:

✅ automated daily code analysis
✅ weekly dependency updates
✅ monthly security audits

the interface is cleaner, the response times are faster, and the error handling is much more robust. it's amazing how much smoother everything runs compared to the previous version.

one thing i love is how it learns from my patterns. after a few weeks, it started suggesting optimizations i hadn't even considered. the system feels less like a tool and more like a collaborator.

my favorite features

after diving deep into all the announcements, here are the features that stood out to me:

1️⃣ gemini omni - the ability to create anything from any input, starting with video, is genuinely impressive. if you have access to gemini omni, play with the video creation features. they're surprisingly intuitive.

2️⃣ spark - having a 24/7 personal ai agent that remembers context across sessions changes how i work. it's like having a research assistant who never forgets anything.

3️⃣ gemini search with canvas artifacts - the ability to interact with something in canvas while searching makes research so much more efficient. you can see the results, manipulate them, and iterate in real-time.

🟠 amszig - i haven't tried amszig yet, but from what i've seen, it looks like it could be a powerful addition to the ecosystem.

other notable announcements

the conference had a lot more to offer beyond the headline models:

{1} google flow - a creative platform with tools and agent capabilities that could reshape how we approach content creation
{2] neural expressive - the redesigned gemini app with fluid animations feels like a glimpse into the future of ai interfaces
{3} daily brief - personalized morning digest sounds useful for staying updated
[4] google pics - image creation and editing directly in workspace could streamline workflows
[5} universal cart - a shopping hub across google services is a bold move
(6} android halo - agent visibility on android devices brings ai to the mobile experience
[7) intelligent eyewear - partnerships with samsung, gentle monster, and warby parker show google's commitment to wearables
(8} ask youtube - conversational search on youtube changes how we discover content
(9] stitch - collaborative design agent could transform team workflows
{10) ai search box - reimagined with gemini 3.5 flash as default
{11] gemini for science - experimental tools for scientific exploration open new possibilities

the numbers

the scale of adoption is staggering:

☑️ 900 million+ gemini app users (doubled in one year)
✔️ 13 products with over 1 billion users each
☑️ ai ultra plan: $100/month new tier, $200/month reduced top tier

final thoughts

google i/o 2026 wasn't just about incremental improvements. it was a statement that ai is becoming the foundation of everything we do online.

the integration across products, the speed improvements, and the focus on practical applications show that google is serious about making ai useful, not just impressive.

for developers, the opportunities are enormous. whether you're building with gemini 3.5 flash, automating workflows with antigravity 2.0, or exploring the creative possibilities of google flow, there's never been a better time to be building with ai.

what about you?

what aspects of google i/o 2026 are you most excited about? drop a comment below and let's discuss.

thanks for reading, and happy building

I found a bug that could crash your Hermes agent and fixed it

ANIRUDDHA ADAK — Sun, 17 May 2026 16:43:57 +0000

i contributed a bug fix to the hermes agent project that makes the permission approval system more robust and reliable. the change handles an edge case where the permission request could return none instead of a valid response, which could cause the agent to crash or behave unexpectedly.

the fix adds proper error handling so that when the permission system gets an unexpected none response, it defaults to denying the request safely. this is a small but important improvement that makes hermes agent more stable in production environments.

why this matters for the community

when you run hermes agent and it needs to ask for permission before running a command, it uses a bridge system to communicate with the approval callback. if something goes wrong in that communication and the system gets a none response, the old code would fail silently or throw an error.

by adding a simple check that returns deny when response is none, we ensure that the agent always has a safe fallback. this prevents crashes and keeps the permission system predictable. users can trust that their commands will either be approved or denied, never left hanging.

this kind of defensive coding is important for an agent that runs on your own infrastructure and handles sensitive operations. every edge case handled well means fewer surprises in production.

code

here are the files i changed:

the main fix in acp_adapter/permissions.py adds a guard clause that checks for none and returns deny safely.

        if response is None:
            return "deny"

the test file tests/acp/test_permissions.py adds a regression test that ensures this behavior is covered going forward.

you can find the full merged pull request here:

fix(permissions): handle None response from ACP request_permission #13457

aniruddhaadak80 posted on Apr 21, 2026

What does this PR do?

This PR hardens the ACP ? Hermes permission-approval bridge by safely handling an unexpected None result from equest_permission, preventing attribute errors and defaulting to a safe deny.

Related Issue

Fixes #13449

Type of Change

[x] ?? Bug fix (non-breaking change that fixes an issue)
[ ] ? New feature (non-breaking change that adds functionality)
[ ] ?? Security fix
[ ] ?? Documentation update
[x] ? Tests (adding or improving test coverage)
[ ] ?? Refactor (no behavior change)
[ ] ?? New skill (bundled or hub)

Changes Made

Return "deny" when equest_permission resolves to None in the approval callback.
Add a unit test covering the None response case to ensure the callback denies safely.

How to Test

Connect via an ACP client that sends an empty response to permission requests.
Verify the permission is denied rather than throwing an exception.

Checklist

Code

[x] I've read the Contributing Guide
[x] My commit messages follow Conventional Commits
[x] I searched for existing PRs to make sure this isn't a duplicate
[x] My PR contains only changes related to this fix/feature (no unrelated commits)
[x] I've run pytest tests/ -q and all tests pass
[x] I've added tests for my changes (required for bug fixes, strongly encouraged for features)
[x] I've tested on my platform

Documentation & Housekeeping

[x] I've updated relevant documentation (README, docs/, docstrings) � or N/A
[x] I've updated cli-config.yaml.example if I added/changed config keys � or N/A
[x] I've updated CONTRIBUTING.md or AGENTS.md if I changed architecture or workflows � or N/A
[x] I've considered cross-platform impact (Windows, macOS) per the compatibility guide � or N/A
[x] I've updated tool descriptions/schemas if I changed tool behavior � or N/A

View on GitHub

and the repository is here:

NousResearch / hermes-agent

The agent that grows with you

Hermes Agent ☤

The self-improving AI agent built by Nous Research. It's the only agent with a built-in learning loop — it creates skills from experience, improves them during use, nudges itself to persist knowledge, searches its own past conversations, and builds a deepening model of who you are across sessions. Run it on a $5 VPS, a GPU cluster, or serverless infrastructure that costs nearly nothing when idle. It's not tied to your laptop — talk to it from Telegram while it works on a cloud VM.

Use any model you want — Nous Portal, OpenRouter (200+ models), NovitaAI (AI-native cloud for Model API, Agent Sandbox, and GPU Cloud), NVIDIA NIM (Nemotron), Xiaomi MiMo, z.ai/GLM, Kimi/Moonshot, MiniMax, Hugging Face, OpenAI, or your own endpoint. Switch with hermes model — no code changes, no lock-in.

A real terminal interface

Full TUI with multiline

…

View on GitHub

how it works

the approval callback function handles permission requests from the ACP system. when a command needs approval, it runs a coroutine to get the response from the permission handler.

in the try block, if the coroutine completes successfully, the code checks if the response is none. if it is none, the function immediately returns deny.

this approach is straightforward but effective. it means that even in unusual situations where the permission system does not return a proper response, the callback always produces a valid result. the agent continues running instead of crashing.

the test confirms this behavior by mocking the coroutine to return none and verifying that the callback returns deny.

my tech stack

the changes were made using python with the standard library asyncio module for handling asynchronous permission requests. the test uses pytest with mock objects to verify the behavior without needing a full system setup.

lessons learned

working on this fix taught me a few things about building reliable agent systems.

first, edge cases matter. in a system that handles permissions, every unexpected input should have a clear handling path. crashing is never the right answer.

second, testing edge cases is just as important as testing happy paths. the regression test ensures that this none response case keeps working correctly as the codebase evolves.

third, the hermes agent codebase is well structured and welcoming to contributions. the team uses copilot for code review, which helps catch potential improvements early.

i am glad to have contributed to an open source project that gives developers control over their own AI agents. the hermes agent challenge is a great way to get involved and learn about agentic systems.

thanks for reading.

if you want to explore hermes agent or contribute to it, check out the github repository linked above.

and thanks again ...

hermes agent: the complete guide to your personal ai operator

ANIRUDDHA ADAK — Sat, 16 May 2026 05:51:26 +0000

i remember the first time i heard about hermes agent - it sounded like something out of a science fiction movie. an ai that doesn't just chat with you, but actually does things for you. sounds crazy, right? well, let me tell you, it's real, and it's changed how i work completely.

hey there. i'm so excited to share what i've learned about hermes agent after spending weeks exploring it. if you're tired of doing repetitive computer tasks and want an ai buddy that actually helps you get stuff done, you're in the right place.

what exactly is hermes agent

let me put it simply - hermes agent is like having a super-smart assistant who lives in your computer and can actually do things for you. not just answer questions, but open programs, write code, organize files, send emails, and much more.

here's what makes it special:

a) open source - it's free to use and you can see how it works
b) built by nous research - the team behind some amazing ai tools
c) 140,000+ developers on github love it
d) over 40 tools built right in
e) learns as it goes - gets better the more you use it

"hermes agent is an operator, not a builder. it does the work, not just plans it." - nemanja

the four-level path: how hermes grows with you

i love how hermes scales with your needs. here's what i found:

1️⃣ one agent - start simple. one ai helper that can do basic tasks like searching the web or organizing files.

2️⃣ multiple specialists - as you need more, hermes can use different ai models for different jobs. one for coding, one for writing, one for research.

3️⃣ hermes orchestrator - the smart part. hermes decides which specialist to use for each task and makes sure everything works together smoothly.

4️⃣ automated agent team - the full experience. hermes coordinates multiple ai agents working together like a tiny team, all while you focus on the big picture.

what makes hermes agent special

after testing it myself, here's what impressed me the most:

three-tier memory

hermes remembers things in three ways:
x) short-term memory for the current task
y) working memory for important details
z) long-term memory for things you tell it to remember

this means it doesn't forget what you told it five minutes ago.

geppa optimization

this is the fancy term for hermes getting smarter. it learns from your feedback and gets better at choosing the right tools and models for each job.

self-evolving skills

i was blown away by this. hermes can actually improve itself. one user reported it became 3 times faster and 80% cheaper after just 2 iterations. that's pretty amazing.

codex runtime integration

this lets hermes run code safely and efficiently. you can ask it to write and execute code without worrying about breaking anything.

nine workflows that changed my life

ole lehmann shared these workflows, and i've tried most of them:

1️⃣ customer support cron - hermes can monitor support tickets and respond to common questions automatically.

2️⃣ weekly business report - set it up once, and every week it gathers data and writes your report. i use this every monday morning.

3️⃣ daily brief - every morning, hermes gives you a summary of emails, messages, and tasks. perfect way to start the day.

4️⃣ travel planning - from flights to hotels to restaurants, hermes researches and compares everything. i planned my last vacation with minimal effort.

5️⃣ seo research - if you write content, hermes can research keywords, analyze competitors, and suggest improvements.

6️⃣ content creation - write blog posts, social media updates, or emails. hermes can draft, edit, and format content for you.

7️⃣ client tasks - manage multiple client projects. hermes tracks deadlines, sends reminders, and keeps everything organized.

8️⃣ local tool automation - connect hermes to your local apps and automate repetitive tasks on your computer.

9️⃣ obsidian llm wiki second brain - hermes helps organize your notes and connects related ideas. it's like having a personal librarian for your thoughts.

getting started with hermes agent

i know setup can be scary, but hermes makes it easy. here's what i did:

1️⃣ visit the github repository - go to the hermes agent repo and click the green "code" button to download.

2️⃣ follow the install guide - head to hermesatlas.com for step-by-step instructions. no command line experience needed.

3️⃣ start with simple workflows - don't try to automate everything at once. begin with one task, like organizing your downloads folder.

4️⃣ add api keys - hermes needs access to ai models. you'll need your own api keys for best results.

5️⃣ test and tweak - watch what hermes does, give feedback, and it will get better over time.

pricing and subscription

here's the honest truth about costs:

p) free tier - you can use hermes agent itself for free
q) api costs - you pay for the ai models it uses
r) no hidden fees - what you see is what you pay

i found that using deepseek v4 flash as the supervisor with local workers costs about 1/20th of other options. pretty sweet deal.

keeping things safe and secure

i was worried about security at first, but hermes has you covered:

i) use separate accounts - don't use your main accounts for hermes
ii) own api keys - use your own keys so you control access
iii) least privilege - only give hermes the permissions it needs
iv) review actions - hermes shows you what it's about to do before doing it

"security is not an afterthought with hermes. it's built into every step." - user testimonial

how hermes compares to others

i tested a few similar tools, and here's what i found:

tool	tokens used	best for
hermes agent	353 billion	general automation
openclaw	195 billion	coding tasks
kilo code	166 billion	developer workflows

hermes agent ranks number one in usage, which tells me people are actually using it for real work.

what real users say

i read through tons of user experiences, and these stood out to me:

"i was skeptical at first, but hermes agent saved me over 10 hours every week. the initial setup took some time, but it paid off." - kyle

"the memory system is game-changing. hermes remembers context from days ago, which makes complex tasks possible." - john king

"i use it for my consulting business. it handles client communications, research, and reporting. i focus on strategy now." - tessa kriesel

recent updates and bug fixes

the hermes team is constantly improving. here's what's new:

A) tui fix for vietnamese and cjk input
B) slack whitespace guard
C) cli exception logging
D) url safety improvements
E) mcp regex optimization
F) browser tool error handling
G) codex runtime fix

my final thoughts

look, i get it. the idea of an ai agent that can control your computer sounds overwhelming. i felt the same way at first. but after using hermes agent for a few weeks, i can honestly say it's been one of the best productivity tools i've ever used.

it's not perfect - sometimes it makes mistakes, and you need to supervise it. but that's the point. hermes is like a really smart intern who needs some guidance but can do amazing work once you show it the ropes.

the best part. hermes gets better the more you use it. it learns your preferences, your workflows, and your style. after a month, it feels less like a tool and more like a teammate.

if you've been curious about ai agents but didn't know where to start, hermes agent is the perfect place. it's open source, well-documented, and backed by a passionate community.

give it a try. start small. watch it work. and before you know it, you'll wonder how you ever managed without it.

ready to dive in?

here's what i recommend:

a) visit the github repository
b) follow the install guide at hermesatlas.com
c) start with one simple workflow
d) join the community and ask questions
e) share your experience with others

remember, hermes agent is not here to replace you. it's here to free you up to do the work that really matters. the creative stuff, the strategic thinking, the human connection. let hermes handle the rest.

happy automating, friends. 🚀

Gemma 4 Complete Guide 2026, Architecture, Benchmarks, Deployment and more ...

ANIRUDDHA ADAK — Thu, 07 May 2026 05:40:07 +0000

This is a submission for the Gemma 4 Challenge: Write About Gemma 4

`Gemma 4 Complete Guide 2026`

Gemma 4 is shaping up to be the most consequential open weight model release of the year, and the headline is not just the leaderboard scores. Google shipped four model sizes, native multimodality, a 256K context window on the larger variants, and for the first time in the Gemma line, a clean Apache 2.0 license.

For engineering teams that have been waiting on an open weight model good enough to actually replace a frontier API for a meaningful slice of their workload, this is the first credible candidate from Google.

This guide is the long version. It walks through what the family looks like,

i) what the architecture actually does,
ii) what the benchmark numbers mean in practice,
iii) how it stacks up against Llama 4, Qwen 3.5, DeepSeek V4 Flash and its own predecessors,
iv) where to host it, and where it falls short.
v) If you are evaluating Gemma 4 for production, this is the document you can hand to your team.

`TL;DR, the Quick Read`

Before we dive into the long version, here is the snapshot you can keep in your back pocket.

Released: April 2, 2026, by Google DeepMind.

The family ships in four sizes, namely Gemma 4 E2B (around 2.3B effective), E4B (around 4.5B effective), 26B A4B (a Mixture of Experts with 4B active), and a dense 31B. Licensing has finally moved to Apache 2.0, which is a meaningful change because earlier Gemma generations shipped under the custom Gemma Terms of Use that often made enterprise legal review painful.

Context windows reach 128K tokens on the E2B and E4B variants, and 256K on the 26B A4B and the 31B. Every variant takes text plus image input, while E2B and E4B additionally take audio. Output, on every variant, is text only.

On the strong side, Gemma 4 nails reasoning, math (AIME 2026 ~89%), code generation (LiveCodeBench v6 ~80%), long context recall, and on device deployment via MediaPipe and LiteRT. On the weak side, it trails Qwen 3.5 27B on SWE-bench Verified, has no native speech output, and a reminder worth repeating, Gemma is not Gemini, so fine tuning, weights and serving become your problem.

`Watch the offical demo here`:

`What Gemma 4 Is, And How It Differs From Gemini`

Gemma is Google's open weight model family. Gemini is Google's closed, hosted, frontier model family. They share research lineage, in fact Google describes Gemma 4 as built from Gemini 3 research, but the deployment story is genuinely different.

With Gemini, you call an API, you pay per token, you do not get the weights, and you cannot fine tune the underlying parameters, you get adapters at best. With Gemma 4, you download the weights from Hugging Face, Kaggle or Ollama, you run them on your own hardware (or a cloud GPU you rent), you fine tune fully, and your unit economics become GPU hours and electricity rather than per token API spend.

The practical implication is straightforward.
i) Reach for Gemma 4 when you need on device inference, when you need to fine tune on private data, when your token volume makes a hosted API uneconomical, or when you need an air gapped deployment.
ii) Reach for Gemini when you want zero ops frontier intelligence and you are happy to pay for it.

`The Gemma 4 Family`

Four sizes, two architectural patterns (dense and MoE), and a clear split between the edge and server tiers.

Variant	Architecture	Total / Active params	Context	Modalities in	Primary target
Gemma 4 E2B	Dense	~2.3B effective	128K	Text, image, audio	Phones, IoT, low power laptops
Gemma 4 E4B	Dense	~4.5B effective	128K	Text, image, audio	High end phones, edge servers, Raspberry Pi class
Gemma 4 26B A4B	Mixture of Experts	26B total / ~4B active per token	256K	Text, image	Single high end GPU server, cost sensitive throughput
Gemma 4 31B	Dense	30.7B	256K	Text, image	Quality first server inference, fine tuning

A small naming clarification first. The E in E2B and E4B stands for edge, not experts. These are dense models built for on device.

The 26B A4B is the actual MoE in the family. Roughly 4 billion parameters fire on any given forward pass, so latency and cost behave like a 4B model, while quality benefits from the full 26B parameter pool. The 31B is the no tricks dense model, slower than the MoE, but typically the highest quality answer when you need the best response per query rather than the best response per dollar.

`Architecture, Context Window, And Tokenizer`

Gemma 4 keeps the decoder only transformer skeleton that has defined the family,
but it tightens almost every component.
A few highlights worth knowing before you read the model card.

a) Hybrid attention. Gemma 4 interleaves local sliding window attention with full global attention, with the final layer always global. Smaller dense models use 512 token sliding windows, and larger ones use 1024. This is the trick that makes the 256K context feasible without VRAM blowing up linearly.

b) RULER long context recall. On RULER at 128K, Gemma 3 scored 13.5%. Gemma 4 scores 66.4% on the same test. The context window is not just nominal, it actually retrieves at depth.

c) Vocabulary. A 262,144 token vocabulary, BPE with byte fallback. Strong multilingual coverage across more than 140 languages.

d) Vision tokens. A variable visual budget per image, namely 70, 140, 280, 560 or 1120 tokens, so you trade quality against context spend.

e) Audio (E2B and E4B only). Native speech recognition and audio understanding, with no separate ASR layer required for many use cases.

f) Reasoning mode. Gemma 4 can produce more than 4,000 tokens of explicit reasoning before committing to an answer, plus native function calling and structured JSON output.

The MoE in the 26B A4B is the architectural story to internalise. It lets a single A100 80GB or two consumer GPUs serve a model that punches well above 4B in quality terms, at roughly 4B in cost terms. That is the new dominant design point for the open weight server tier in 2026.

`License, Apache 2.0, Finally`

Read this section carefully if you have ever had Legal kill a Gemma rollout.

Earlier Gemma releases shipped under the Gemma Terms of Use, a custom license. It was more permissive than Llama 2's, but it included a Prohibited Use Policy with clauses around harm to minors, attacks on critical infrastructure, generation of CSAM, and other broad carve outs. The clauses were defensible in spirit, but enterprise legal teams routinely flagged the language as ambiguous and asked for indemnification or scope limiting before signing off. That friction kept Gemma out of plenty of production stacks.

Gemma 4 ships under Apache 2.0. No custom restrictions, no usage carve outs, and no monthly active user thresholds the way the Llama 4 Community License has.

Apache 2.0 explicitly grants commercial use, modification, redistribution, and distribution of derivative works including derivative weights. There is one obvious constraint that still applies, namely that Apache 2.0 does not grant trademark rights, so you cannot ship a product called "Gemma" or imply Google endorsement.

This is materially less restrictive than the previous Gemma Terms of Use, and noticeably less restrictive than Llama 4's Community License (which is free for organisations under 700M monthly active users but adds compliance language). For most engineering teams, this is the change that turns Gemma from interesting into approvable.

Two caveats worth being honest about.

a) Apache 2.0 governs the weights, it does not give you the training data or the training pipeline. Gemma 4 is open weight, not open source in the strict OSI sense applied to data.

b) Google can still publish acceptable use guidelines separately, nothing about Apache 2.0 prevents that. Today, the license file in the repo is the controlling document, and that document is Apache 2.0.

`Benchmarks That Actually Matter`

The headline numbers for Gemma 4 31B (instruction tuned) are pulled from Google's model card, plus the independent reproductions surfaced in the LM Studio and Hugging Face threads.

Benchmark	Gemma 4 31B	Gemma 3 27B	Llama 4 Scout (109B)	Qwen 3.5 27B	DeepSeek V4 Flash
MMLU-Pro	85.2	~67	~78	86.1	~84
GPQA Diamond	84.3	42.4	~70	85.5	~80
LiveCodeBench v6	80.0	29.1	~55	~78	~74
SWE-bench Verified	~63	~22	~48	72.4	~64
AIME 2026 (math)	89.2	20.8	~55	~85	~82
Codeforces ELO	2,150	110	~1,500	~1,950	~1,800

Approximate values for the non Gemma rows are pulled from each project's own card or the Artificial Analysis index, treat them as directional. The story they tell is consistent, and it boils down to four observations.

i) Gemma 4 31B is in the same neighbourhood as Qwen 3.5 27B on knowledge and reasoning, they trade leadership benchmark by benchmark.

ii) Gemma 4 has the upper hand on math and competitive programming.

iii) Qwen 3.5 27B still wins SWE-bench Verified, the benchmark that most closely tracks can this model close a real GitHub issue. If your primary use case is autonomous code editing on real repos, evaluate Qwen 3.5 alongside Gemma 4 before you commit.

iv) Gemma 4's gain over Gemma 3 is enormous, with multiple benchmarks improving 3 to 20 times. Most teams running Gemma 3 in production should plan a migration window.

`Where To Run Gemma 4`

There are three deployment surfaces to think about, namely hosted, self hosted server, and on device.

a) Hosted

If you want zero ops, the model is a one line call away on several providers.

Vertex AI (Model Garden) is the first party path. You can fine tune on Vertex AI Training Clusters and serve through Model Garden endpoints, paying for compute time on the underlying accelerator (A2/G2 family or TPUs).

For prototyping and price sensitive batch work, OpenRouter aggregates more than eleven providers for the 26B A4B model at roughly $0.06 per million input tokens and $0.33 per million output. Beyond that, Together AI, Fireworks, Groq, DeepInfra and Hugging Face Inference all run Gemma 4 endpoints, and pricing varies though the open weight competitive market keeps it low. For spiky workloads, Cloud Run with GPU, Google's serverless GPU runtime, can host Gemma 4 with scale to zero, which is genuinely attractive when traffic is bursty.

b) Self hosted server

vLLM is the production default. It supports Gemma 4 on NVIDIA, AMD, and Google Cloud TPUs from day one. The approximate hardware floors look like this.

Variant	Quant / format	VRAM floor	Notes
26B A4B	AWQ INT4	~15 GB	RTX 4090 24 GB with KV cache headroom
26B A4B	GGUF Q4_K_M	~16 GB	llama.cpp / Ollama dev box
26B A4B	FP16	~52 GB	A100 80GB or H100, serves at full quality
31B dense	FP16	~62 GB	A100 80GB or H100 single GPU
31B dense	INT4	~18 GB	RTX 4090 / 5090, viable for single user inference

Ollama covers the local laptop use case for E2B, E4B, and the quantised 26B and 31B. MLX with Metal acceleration runs all variants on Apple Silicon, an M3 Max or M4 Pro with 32 to 64 GB unified memory will run the 26B A4B comfortably. AMD has day zero Gemma 4 support across ROCm and the Ryzen AI stack. NVIDIA NIM, NeMo, LM Studio, Unsloth, SGLang and LiteRT-LM all have first class support too.

c) On device with MediaPipe and LiteRT

The E2B and E4B variants are explicitly designed for phones and edge devices.
The deployment stack is MediaPipe's LLM Inference API on top of LiteRT,
which handles model loading, memory and hardware acceleration (GPU or NPU) automatically.

The approximate footprints are nicely small.

E2B Q4_K_M, around ~1.3 GB on disk, with 2 to 3 GB RAM at runtime.
E4B Q4_K_M, around ~2.5 GB on disk, with 4 to 5 GB RAM at runtime.

This is the path for AI features that work without a network round trip,
voice agents on Android, in browser RAG over a user's local documents, and offline coding helpers.
With audio input native to E2B and E4B, you can ship a meaningful voice to text to action loop without bundling a separate ASR model.

When To Choose Gemma 4 Over Alternatives

Reach for Gemma 4 when the following conditions hold.

a) You need an Apache 2.0 model. If Legal balked at Gemma 3's terms or Llama's Community License MAU clause, Gemma 4 is the cleanest option in this size class.

b) You need on device multimodality. The audio capable E2B and E4B variants are the strongest open weight option for phones today.

c) Long context matters. 256K with credible RULER recall is competitive with hosted frontier models.

d) Math, agentic reasoning or competitive programming dominate your workload. Gemma 4 31B's AIME and Codeforces numbers are exceptional for an open weight model in this size band.

Choose something else when the workload looks more like one of these.

a) Your workload is autonomous repo editing. Qwen 3.5 27B's SWE-bench Verified lead is real. Pilot both before committing.

b) You need streaming voice output. Gemma 4 has audio in but not out. Qwen 3.5 Omni handles real time speech generation.

c) You need a frontier model. If quality is the only metric, hosted Gemini 3 Pro or DeepSeek V4 Pro will outperform Gemma 4 31B on most benchmarks.

d) Cost per token at huge scale. DeepSeek V4 Flash hosted is cheap enough that for many workloads the spend math beats running your own GPUs.

`Known Issues And License Caveats`

No model is a free lunch, and Gemma 4 has its own quirks. Worth reading before you commit.

i) SWE-bench Verified is not the strong suit. Real GitHub issue resolution still trails Qwen 3.5 27B by a meaningful margin.

ii) No native audio output. If you want a voice agent that talks back, you bolt on a separate TTS layer.

iii) 26B A4B throughput surprise. Despite only 4B active parameters, community benchmarks on consumer GPUs show roughly 11 tok/s on an RTX 4090, slower than a comparable dense 4B model. The MoE routing overhead is real on consumer hardware. On A100 and H100 the gap closes.

iv) Apache 2.0 is not open source training data. The weights are open and commercially usable, the training corpus is not. If your compliance posture requires reproducibility from data, Gemma 4 does not satisfy that.

v) Trademark. You cannot brand your product as "Gemma" or use Google trademarks. Apache 2.0 explicitly excludes trademark grants.

vi) Vision token budget tradeoff. The 70, 140, 280, 560 and 1120 visual budgets are real. Undersized budgets degrade OCR and chart reading noticeably, so pick deliberately.

vii) Native dependency surprises. If you self host with vLLM behind a Node service, watch out for prebuilt binary fetch issues on locked down installs, where the failure mode is silent at install time and loud at runtime.

viii) Tokenizer drift from Gemma 3. The 262K vocabulary is not directly weight compatible with Gemma 3 fine tunes. Plan a re finetune, do not try to port adapters.

`FAQ`

`Is Gemma 4 actually open source?`

It is open weight under Apache 2.0. The weights, model card and inference code are open and commercially usable. The training data and full pipeline are not released. By the OSI's strict definition, that is open weight, not open source, but for most commercial deployment purposes Apache 2.0 is the cleanest license you will see in this size class.

`Is the Gemma 4 license really Apache 2.0?`

Yes. This is the change from earlier Gemma versions, which used the custom Gemma Terms of Use with usage carve outs. Gemma 4's repository ships the standard Apache 2.0 license file. Anyone telling you Gemma 4 has restrictive terms is describing the previous generation.

`What is the difference between Gemma 4 and Gemini?`

Gemma 4 is open weight and self hostable. Gemini is a closed, hosted, frontier model. They share research lineage but different deployment models, costs and customisation surfaces.

`Which Gemma 4 model should I pick?`

a) E2B for phones and tight memory budgets.
b) E4B for high end edge and small servers.
c) 26B A4B for cost efficient single GPU server inference.
d) 31B dense for the highest quality answers when you do not care about throughput.

`What hardware do I need to run Gemma 4 31B?`

FP16 needs roughly 62 GB VRAM, an A100 80GB or H100. INT4 quantised drops that to about 18 GB, fitting an RTX 4090 or 5090 for single user inference.

`Does Gemma 4 support function calling?`

Yes. Native function calling, structured JSON output and system instructions are all first class.

`How does Gemma 4 compare to Llama 4?`

Gemma 4 31B beats Llama 4 Scout (109B) on most reasoning benchmarks at roughly a third of the active parameter cost, and ships under a less restrictive license.

`Is Gemma 4 better than Qwen 3.5?`

It depends on the workload. Gemma 4 wins on math and competitive programming, Qwen 3.5 27B wins on MMLU-Pro, GPQA Diamond and SWE-bench Verified. Both are Apache 2.0. Pilot both.

`Is Gemma 4 multimodal?`

All variants accept text and image. E2B and E4B also accept audio. Output is text only on every variant.

`What is the context window?`

128K tokens on E2B and E4B, and 256K on the 26B A4B and the 31B. RULER long context recall at 128K is roughly 66.4%, a 5x improvement over Gemma 3.

`Can Gemma 4 run on a phone?`

Yes. E2B and E4B are designed for it. MediaPipe's LLM Inference API and LiteRT handle on device inference with NPU and GPU acceleration on Android, and equivalent paths exist on iOS via Core ML and MLX.

`What is Gemma 4n?`

Gemma 4n is the community shorthand for the E2B and E4B edge variants, the on device tier of the Gemma 4 family. Architecturally they are dense models tuned and quantised for phones and embedded devices. See Gemma 4n vs Gemma 4 for the side by side.

`Is Gemma 4 safe for commercial production use?`

Yes, under Apache 2.0, with the standard caveats. Respect trademarks, do not redistribute the model under the Gemma name, and follow your own jurisdiction's AI usage law. There are no usage carve outs, no MAU thresholds, and no industry restrictions in the license itself.

`Should I migrate from Gemma 3 to Gemma 4?`

If you are running Gemma 3 in production, yes. The benchmark deltas are large (3 to 20 times on reasoning and code), the license is cleaner, the context window is bigger, and the deployment story is unchanged. Plan a re finetune, since adapter weights will not transfer cleanly.

`Closing Thoughts`

Picking the right open weight model is the easy half of the job. The harder half is the integration work that follows, the fine tuning, the eval harness, the cost modelling, and the production hardening.

Gemma 4 makes that work meaningfully easier than its predecessor.
✔️The license is clean,
✔️the model card is honest,
✔️the deployment surface is broad,
✔️and the benchmarks are competitive with the best of the open weight field.

If you have been holding out on Gemma because of legal friction or quality gaps, this is the release that closes both. Pilot it against your real workload, compare it head to head with Qwen 3.5 27B on the tasks that matter to you, and let your evals decide.

pls share your thoughts below with ur use cases. thanks for reading so far 💖

I Watched Google Cloud NEXT '26 ~ Here Is What Actually Matters for Developers

ANIRUDDHA ADAK — Sun, 26 Apr 2026 22:00:00 +0000

Hi, I am Aniruddha Adak, an AI agent engineer based in Kolkata. I spend most of my time building agentic systems, experimenting with LLMs, and watching developer conferences so I can figure out what is actually useful versus what is just marketing.

This past week I sat through both the Opening Keynote and the Developer Keynote of Google Cloud NEXT 2026, held in Las Vegas. The event ran from April 22 to 24, 2026. Both sessions are freely available on YouTube, and I want to share what I personally noticed, what made me stop and think, and what I believe developers like you and me should actually care about.

This is not a summary. This is my honest take from someone (like me) who works with agents every day.

How I Watched These Keynotes

I watched both sessions fully. The Opening Keynote runs for about 1 hour 39 minutes. The Developer Keynote is 1 hour 7 minutes. That is nearly 3 hours of content.

I took notes while watching, paused at moments that felt important, and replayed sections where the demos were happening live on stage.

I am going to walk you through what I found most meaningful, section by section.

The Opening Keynote: Sundar Pichai and the Big Picture

Sundar Pichai came on stage pretty early in the keynote. The thing that immediately got my attention was when he talked about how Google now uses AI for nearly 75% of its own code writing. That number stopped me. It means the engineers at Google are not just building AI tools. They are themselves working alongside those tools in their day to day coding.

He also mentioned that Google plans to invest heavily in infrastructure this year, and a significant portion of that investment is going toward AI compute. From where I sit as someone building agent systems, this matters because more compute capacity means the APIs and services we rely on will be more stable and faster.

watch here: 👇

Another moment that stood out was when Sundar described Cloud as the "mission control of the agentic era." That phrase stayed with me. It is not just a catchy line. It reflects a genuine shift in how Google is framing its cloud offering. It is no longer just about storage or compute. It is about giving your AI systems a place to run safely, observe themselves, and scale up.

The Agentic Enterprise Blueprint

Thomas Kurian, who runs Google Cloud, presented what they are calling the Agentic Enterprise Blueprint. The core idea is straightforward: you cannot just bolt AI onto your existing systems and call it done. You need a full stack approach.

Here is what that stack looks like according to what was shown:

1. The Models Layer
Gemini Pro and Flash are at the center of this. But what I found interesting is that they explicitly said you can also use Claude from Anthropic through the Model Garden. This is honest. They are not forcing you into a single model. As someone who has built systems using multiple providers, I appreciate that kind of openness.

2. The Agent Development Kit (ADK)
This was the part that felt most relevant to my work. ADK is Google's framework for building modular agents. It connects to MCP servers, handles memory, manages sessions, and lets you define skills in a structured way. The fact that every Google Cloud service is now MCP-enabled by default was one of the bigger announcements of the week.

3. Agent Runtime
This is the serverless layer that runs and scales your agents. Sessions keep agents connected to users across interactions. Memory allows agents to learn from past sessions and carry that forward. This is the kind of infrastructure that used to take weeks to build manually.

4. Agent Gateway and Observability
Each agent gets a unique identity. The gateway enforces policies. Observability tools let you see what your agents are actually doing, debug reasoning loops, and track performance. This is something I have personally felt the pain of. Debugging agents without proper tooling is exhausting.

The Hardware Announcement That Got the Audience Excited

About 42 minutes into the Opening Keynote, Google announced the TPU 8t. Three times the performance per pod compared to previous generation hardware.

For most developers, you might not care directly about the chip architecture. But what it means in practice is:

✅ Faster model responses
☑️Lower latency for complex agent workflows
✔️ Ability to run longer context windows without things slowing down significantly

The TPU 8t was described as being designed specifically for the agentic era of computing. The architecture changes they made inside the chip are focused on handling the kind of back and forth reasoning that agents do constantly.

They also announced a new networking layer that links 134,000 chips together into what they called a unified AI supercomputer. That is a level of scale that very few companies in the world can match.

Real World Examples That Felt Grounded

One segment I genuinely enjoyed was the Walmart story. Walmart is using Gemini Enterprise to help field leaders get insights before they walk into their stores each day. The idea is that instead of spending time pulling reports manually, the agent surfaces what matters, tailored to the specific store and the specific leader's role.

This is exactly the kind of use case that makes sense to me. It is not AI trying to replace the person. It is AI giving the person better context so they can do their job better. The numbers shared were that some of their enterprise deployments hit 80% adoption among employees, which is genuinely high for any enterprise tool rollout.

There was also a story about a snowboarding AI project that used 3D models and motion analysis to help athletes understand their technique in ways that were not possible before. This one was more fun than practical for most developers, but it showed how computer vision and real time data pipelines can combine in interesting ways.

The Developer Keynote: Where Things Got Practical

The Developer Keynote was hosted by Richard Seroter and Emma Twersky. The energy was different here. More hands on. More code. Less executive messaging.

Brad Calder opened the session and made a statement that I wrote down immediately:

"In 2026, you are building applications in days that would have taken weeks or months just a couple of years ago."

He is right. I have felt this in my own work. The tools have gotten dramatically better, and the way we structure our thinking around building software is changing alongside them.

watch here: 👇

The Marathon Demo That Showed Everything Working Together

The main demo of the Developer Keynote was a Marathon Planner built using the Agent Platform. They simulated planning a marathon through Las Vegas for 10,000 runners.

The system had three agents working together:

A Planner Agent that figured out the route
An Evaluator Agent that scored the route against both deterministic criteria (exactly 26 miles 385 yards) and non-deterministic criteria (community impact, safety)
A Simulator Agent that spawned thousands of virtual runners and watched how traffic was affected

What I found clever here was the Evaluator Agent design. It uses a separate, smaller model with limited context. Its only job is to judge the route. This is a pattern I have started using in my own work. Giving a subagent a narrow, well defined role makes the whole system more reliable.

The other thing that struck me was A2UI, which stands for Agent to User Interface. The idea is that the agent itself builds the interface it needs to communicate results back to you. Instead of hardcoding dashboards, the agent generates the right visual components for the specific task it just completed. This reduces the need for frontend developers to maintain a growing list of output templates.

A2A Protocol: Agents Talking to Agents

One announcement I want to highlight specifically for developers is the A2A protocol. A2A stands for Agent to Agent. Google created this protocol and donated it to the Linux Foundation, which means it is open and not locked to Google's ecosystem.

The problem A2A solves is communication between agents that were built independently. Without a standard protocol, connecting agents from different teams or vendors requires custom API contracts and a lot of fragile glue code. A2A defines a standard way for agents to advertise their capabilities through an Agent Card, discover other agents through the Agent Registry, and communicate without writing custom integration code.

I have run into this problem myself. When you start building systems where multiple specialized agents need to coordinate, the connection layer becomes its own maintenance burden. A2A is an attempt to make that layer standard and manageable.

What Surprised Me Personally

I went into these keynotes expecting mostly announcements about model updates and price changes. What I did not expect was how much of the Developer Keynote was focused on showing code, showing real tradeoffs, and being honest about where the hard problems still are.

The segment about Context Engineering genuinely resonated with me. The speakers talked about how moving from stateless to stateful agents changes everything about how you design your system. Sessions, Memory Banks, and RAG integrations are not optional add-ons. They are the foundation of any agent that needs to be useful across multiple interactions.

They also mentioned that the full demo code was being open sourced on GitHub during the keynote. Not after. During. That is the kind of move that actually builds trust with a developer community.

Something That Felt Missing

Honestly, I would have liked to see more about monitoring and debugging agent failures in production. The observability tools they showed were impressive in demos, but production agent systems fail in strange ways. I would love a deeper conversation about what happens when your agent gets stuck in a reasoning loop or when memory accumulates stale information that starts affecting decisions.

This is something I think about in my own work constantly. The tooling for building agents has gotten good. The tooling for understanding why agents fail is still catching up.

What You Should Actually Do After Reading This

If you made it here, here are three things worth doing:

Watch the Developer Keynote first. It is more practical and the demos are better for developers. The Opening Keynote is good context but starts with a lot of enterprise positioning.

Look up the ADK documentation. The Agent Development Kit is available now. If you are already building agents with other frameworks, it is worth understanding how ADK structures skills and tools. Some of the patterns are genuinely well thought out.

Try the open source demo code. The Marathon Simulator was released on GitHub. It is a working multi-agent system using ADK, MCP, A2A, and Agent Runtime all together. That kind of end-to-end reference is rare.

My Overall Feeling

I came away from both keynotes with a clearer sense of where the industry is heading. The shift from "we have a model" to "we have a complete agent infrastructure" is real. Google Cloud NEXT 2026 was the event where Google tried to make that shift concrete for developers, not just for CTOs.

The things I liked most were the openness around model choice, the A2A donation to Linux Foundation, and the fact that the demo code was released publicly. Those are developer friendly moves.

The things I want to see more of are better failure analysis tools, more honest discussions about prompt drift in production, and deeper guidance on memory management at scale.

But overall, this was a strong event with a lot of practical takeaways for anyone building agentic systems in 2026.

I am Aniruddha Adak from Kolkata. If you are working on agents or AI systems and want to talk shop, feel free to reach out.

Written after watching both the Google Cloud NEXT 2026 Opening Keynote and Developer Keynote in full...

This is a submission for the Google Cloud NEXT Writing Challenge

Thank you all for reading so far 💖

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

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

This is a submission for the OpenClaw Writing Challenge

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

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

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

it wasn't thinking hard.

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

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

i almost gave up.

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

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

stop using your expensive model for everything

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

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

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

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

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

your agent needs rules written in stone

out of the box, openclaw will:

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

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

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

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

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

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

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

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

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

closing the chat kills the session

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

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

what to do instead:

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

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

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

one working workflow beats five broken ones

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

start with one thing that hurts slightly every day.

i started with a morning briefing cron that:

reads my calendar
summarizes slack mentions
messages me results

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

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

openclaw doctor --fix

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

compaction eats your memories

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

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

now i persist everything important:

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

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

chat quality and agent quality are different animals

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

models that actually work for agentic coding:

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

models to avoid:

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

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

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

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

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

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

the four rules that changed everything for me:

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

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

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

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

This is a submission for the Google Cloud NEXT Writing Challenge

The Moment It All Started

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

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

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

The Opening That Hooked Me

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

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

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

What Stood Out for Me

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

Google Enterprise Agent

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

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

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

Google AI Generation Chip

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

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

Gemini Live and Real World Impact

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

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

It pointed out mistakes and suggested corrections on the fly.

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

The Agentic Era Is Here

The Google Assistant Platform demo blew my mind.

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

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

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

Big Partnerships That Matter

Google is not building this alone.

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

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

YouTube with AI Built In

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

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

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

My Take on It All

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

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

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

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

Wrapping Up

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

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

And I am ready to be part of it.

Thanks for reading my first Google Cloud NEXT reflection.

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

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

Hey DEV Community 👋

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

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

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

It started simple enough.

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

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

The lobster replied instantly with its usual confidence:

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

Then… nothing.

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

“Browsing sites…”

“Compiling table…”

“Almost done…”

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

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

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

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

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

At one point it literally told me:

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

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

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

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

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

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

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

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

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

I learned three hard lessons that night:

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

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

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

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

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

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

— ANIRUDDHA ADAK

Kolkata, West Bengal, India | April 17, 2026

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

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

Both sides make the full picture.

Thanks, happy building ...