DEV Community: ahmad rabbani

From Tools to Agentic Systems

ahmad rabbani — Wed, 29 Apr 2026 21:26:02 +0000

The announcement I picked
The Google Cloud NEXT '26 release that spoke to me most was Gemini Enterprise Agent Platform. Google described it as a platform to build, scale, govern, and optimize agents, with capabilities such as Agent Studio, agent-to-agent orchestration, agent registry, agent identity, agent gateway, and observability.
That matters because it changes the developer mindset. We are no longer only adding AI features to apps. We are designing systems where agents can observe work, take action, coordinate with other agents, and improve outcomes over time.
My honest reaction: this is bigger than a product update. It is a signal that the next serious software products will not be judged only by what feature they provide, but by whether they can evaluate, adapt, and improve themselves.
The old way: build a tool and ship it
Most developers, including me, often build tools in a simple pattern:

A user uploads a file.
The tool performs one task.
The user downloads the result.
The workflow ends.
That works for utility websites, but it creates a ceiling. A PDF compressor compresses. An image converter converts. A text formatter formats. Useful, yes - but static.
The tool does not ask:
Was the output actually good?
Was the process fast enough?
Did the user get the best possible result?
Could the tool improve next time?
Google Cloud NEXT '26 pushed me to think differently. What if every tool had an evaluation layer? What if the app did not only execute the task, but also measured quality, learned from outcomes, and suggested improvements?
My practical angle: NextGenTools + Passmark evaluation
I run NextGenTools, a growing platform of online utilities for PDF, image, text, developer, and productivity workflows. The idea is simple: fast, privacy-first tools that people can use without installing software.
But after reflecting on Gemini Enterprise Agent Platform, I realized the next step is not just adding more tools. The next step is adding intelligence around the tools.
That is where my Passmark-based evaluation idea fits.
Instead of treating each tool as a one-time action, I want to evaluate every important workflow through measurable tests:
•       speed
•       output quality
•       accuracy
•       usability
•       failure cases
•       SEO visibility
•       competitor comparison
The goal is not only to say, "the tool works." The goal is to prove how well it works and what should improve next.
The agentic evaluation loop
User Action -> Tool Execution on NextGenTools -> Passmark Test Layer -> Performance and Accuracy Score -> AI Simulation / Gemini-style Reasoning -> Suggested Improvements -> Backlog or Auto-Optimization -> Better Tool Experience
This is where the NEXT '26 announcement becomes practical for me.
Gemini Enterprise Agent Platform is not only about a chatbot answering questions. The bigger idea is that agents can be connected to workflows, tools, governance, and observability. That is exactly what small developers should learn from enterprise AI: do not build isolated AI moments; build measurable AI systems.
Example: a PDF compression tool
A traditional PDF compressor does this:
Upload PDF -> Compress -> Download
An agentic version does more:
Upload PDF -> Compress -> Measure compression ratio -> Check quality loss -> Compare speed -> Detect failure cases -> Suggest algorithm or UX improvements
For example, if a PDF is reduced from 10 MB to 4 MB but the visual quality becomes poor, the system should not call that a win. It should score the output honestly. If the compression is slow compared to competitors, that should be visible. If a file type fails repeatedly, the system should create an improvement task.
That is how a simple tool becomes a living system.
What developers should learn from this announcement
The most important lesson from Gemini Enterprise Agent Platform is not simply "use agents."
Build software that can observe, evaluate, and improve the workflow it is part of.
For developers, this means we should start adding these layers to our applications:
Evaluation layer
Do not only run the feature. Measure its output. Track accuracy, speed, failures, user friction, and repeat problems.
Reasoning layer
Use AI to interpret those measurements. Let the system explain why performance dropped, why users abandoned a flow, or why one tool performs worse than a competitor.
Action layer
Turn insights into backlog items, code tasks, prompt improvements, UI changes, documentation updates, or automated tests.
Governance layer
This part matters. Agentic systems can become dangerous if they are allowed to act without boundaries. Every system needs logging, approval, role control, human review, and rollback.
This is one reason the Google Cloud framing is important. Enterprise AI is not just about intelligence. It is about controlled intelligence.
My critique: agentic AI still needs proof, not hype
I am excited about Gemini Enterprise Agent Platform, but I also think developers should stay practical.
The AI world has too many demos that look magical for five minutes but fail inside real workflows. The real test is not whether an agent can produce a nice answer. The real test is whether it can survive messy inputs, incomplete data, user mistakes, edge cases, permissions, cost limits, and production monitoring.
That is why I like the direction of agent observability and governance. Agents should not be treated like black boxes. They need logs, scores, confidence checks, and human review.
In my own NextGenTools idea, I do not want AI to blindly rewrite everything. I want AI to help evaluate, suggest, and prioritize - while the developer stays responsible for the final decision.
Why this matters for small builders
Some people may think Gemini Enterprise Agent Platform is only for large companies. I see it differently.
Small builders can learn the pattern even before they use the full enterprise stack:
•       connect tools to evaluation data
•       create feedback loops
•       compare outputs against competitors
•       use AI to explain problems
•       turn analysis into improvements
That is a powerful mindset for indie developers, startup founders, and people building utility platforms like mine.
The winners in the next phase will not simply be the people with the most tools. They will be the people with the best learning loop.
Final thought
Google Cloud NEXT '26 made one thing clear to me:
AI is moving from a feature inside software to an operating layer around software.
That shift changes how I want to build NextGenTools.
I do not only want a website full of useful utilities. I want a system where every tool can be tested, scored, compared, improved, and eventually optimized through an agentic workflow.
That is the real opportunity I see in Gemini Enterprise Agent Platform. Not just smarter chat. Smarter systems.
References
•       Google Cloud: Introducing Gemini Enterprise Agent Platform - https://cloud.google.com/blog/products/ai-machine-learning/introducing-gemini-enterprise-agent-platform
•       Google Cloud: Welcome to Google Cloud Next '26 - https://cloud.google.com/blog/topics/google-cloud-next/welcome-to-google-cloud-next26
•       Google Cloud: Google Cloud Next 2026 wrap up - https://cloud.google.com/blog/topics/google-cloud-next/google-cloud-next-2026-wrap-up

The Actual Lead Generation System using OpenClaw

ahmad rabbani — Sun, 26 Apr 2026 13:29:33 +0000

I built a lead generation system that can simulate and verify AI outreach without sending a single real email.

While building an AI outreach workflow for Play2Earn Sports, a Canada-based sports platform, I ran into a familiar problem: it is easy to demo an AI feature once, and much harder to prove it actually works inside a real backend flow.

So instead of stopping at “the prompt looks good,” I added a dedicated Laravel seeder that creates synthetic global club leads and runs them through the same OpenClaw drafting path the production app uses.
That turned the feature from a demo into something I could verify.
🛠️ Build This Yourself
To reproduce this workflow:

Install OpenClaw and make sure the gateway is running locally.
Add a small Node.js proxy that exposes /v1/chat/completions.
In Laravel, send club lead data as a structured prompt.
Ask OpenClaw to return JSON with subject and body.
Save the draft back to the lead record.
Store draft_provider in metadata so you can verify the source.
Sample prompt
System:
Write a concise, professional cold outreach email for a sports club.
Return valid JSON only with subject and body.

User:
Business: Play2Earn Sports
Business location: Canada
Club name: Toronto Falcons Football Academy
Sport: football
City: Toronto
Country: Canada
Booking link: https://play2earn.example/outreach/book/demo-token-123
Sample curl

curl -X POST http://127.0.0.1:3000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openclaw-local",
    "messages": [
      {
        "role": "system",
        "content": "Write a concise, professional cold outreach email for a sports club. Return valid JSON only with subject and body."
      },
      {
        "role": "user",
        "content": "Business: Play2Earn Sports\nBusiness location: Canada\nClub name: Toronto Falcons Football Academy\nSport: football\nCity: Toronto\nCountry: Canada\nBooking link: https://play2earn.example/outreach/book/demo-token-123"
      }
    ]
  }'

Expected response

{
  "choices": [
    {
      "message": {
        "content": "{\"subject\":\"Partnership Opportunity...\",\"body\":\"Hi Toronto Falcons Football Academy team...\"}"
      }
    }
  ]
}

Sample Laravel save flow

$rawContent = $response['choices'][0]['message']['content'] ?? null;
$draft = json_decode($rawContent, true);

$lead->update([
    'email_subject' => $draft['subject'] ?? null,
    'email_body' => $draft['body'] ?? null,
    'status' => 'draft_ready',
    'metadata' => [
        'draft_provider' => 'openclaw',
    ],
]);

That last part is important. Storing draft_provider made the OpenClaw integration verifiable, especially when running the seeded demo leads through the real draft pipeline.

**The Workflow
The outreach module helps admins:

discover sports clubs
store public business contact info
generate personalized outreach drafts
approve or reject leads
log emails
offer demo booking links
automate follow-ups
OpenClaw is used for one narrow but important part: generating the initial outreach draft.

**The Architecture
**The path looks like this:

Laravel talks to an OpenAI-style HTTP endpoint, and the proxy bridges that into the OpenClaw side.

That kept the application code simple and gave me a clean provider boundary.

Why the Seeder Matters
The most useful part of this integration was not the prompt. It was the seeder.

I created AiOutreachDemoSeeder to:
seed global synthetic clubs from Canada, the UK, Australia, and South Africa
create outreach settings and demo slots
generate drafts through the real EmailCampaignService -> AiEmailService path
create visible admin data for approved, emailed, and demo-booked leads
That means I can test the full workflow without touching real contacts.

The Important Detail: Verifiability
Each generated draft stores its source in lead metadata using draft_provider.

So after seeding, I can tell whether a lead was drafted by:

openclaw
openai
template
That one field made the integration much easier to trust.

If OpenClaw fails and the app falls back, I do not have to guess. The record tells me.

Why This Is Better Than Fake Sample Content
A lot of teams seed nice-looking AI output directly into the database.

I did not want that.

I wanted the seed to exercise the real application path, because that proves more than formatting. It proves:

config is wired
prompt settings are loaded
provider calls are working
results are saved correctly
admin screens reflect the real state
That is a much more honest test.

What I Learned
A few things became clear very quickly.

First, AI features need observability more than they need hype.

Second, backend workflows are where a lot of AI work becomes real. The interesting part is not “can the model answer?” It is “can the system show what happened?”

Third, OpenClaw felt most useful when treated as an infrastructure component, not just a chat interface.

The Reproducible Flow
The workflow is now simple:

configure the OpenClaw endpoint
run migrations
seed the outreach demo data
open the admin outreach dashboard
inspect lead status, email logs, and draft_provider
That makes verification repeatable for anyone on the team.

Closing Thought
The best part of this build was not the generated email. It was making the AI layer testable inside the product.

That changed my view of AI integration a bit: a useful AI feature is not just one that produces output. It is one that another developer can verify without guesswork.

For this project, the seeder ended up being just as important as the model call.

ClawCon Michigan
I like that this challenge pushes people to share practical OpenClaw workflows, not just screenshots of prompts. That is where the real engineering lessons are.

How JavaScript Evolved — And Why Modern Browsers Don’t Need Your Backend Anymore

ahmad rabbani — Sun, 19 Apr 2026 14:56:54 +0000

JavaScript has come a long way.

From simple button clicks in the 90s… to running full applications, AI models, and even file processing — right inside your browser.

Today, we’re entering a new era where:

You don’t always need a backend
Your data doesn’t leave your device
Privacy is built-in, not added later Let’s break it down.

🕰️ The Early Days: JavaScript Was Just “Sprinkles”

Back in the days of Netscape Navigator (1995), JavaScript was introduced as a lightweight scripting language.

Its job?

Validate forms
Show alerts
Add small interactivity

Everything important still happened on the server.

The AJAX Revolution

Then came AJAX.

This changed everything.

Instead of reloading pages:

Data could be fetched dynamically
Interfaces became smoother
Web apps started feeling like desktop apps

This was the first step toward frontend power.

⚡ The Rise of Modern JavaScript Engines

Enter Google Chrome and its V8 engine.

Suddenly:

JavaScript became insanely fast
Complex logic could run in-browser
Frameworks like React, Angular, and Vue.js took over

Frontend wasn’t “just UI” anymore — it became the application layer.

Today: The Browser Is a Full Runtime

Modern browsers now support:

WebAssembly (WASM) → Run near-native performance code
Web Workers → Multi-threading in browser
File APIs → Direct file manipulation
Canvas & WebGL → Image and video processing
AI models in browser → No server required

This means…

You can process files, images, and data locally
No upload required
No backend needed

🔐 Why This Is a Big Deal (Privacy + Security)

Traditional apps:

Upload your files to servers
Process data remotely
Store/log user information

Modern browser-based apps:

Process everything on your device
No data leaves your system
No risk of server leaks

This is privacy-first computing.

🌍 Real Example: NextGenTools

One of the best examples of this shift is NextGenTools.

👉 A browser-based toolkit where everything runs locally.

What it can do:
📄 Convert PDF to Word
🗜️ Compress PDF files
🖼️ Remove image backgrounds
🔄 Merge, split, and edit PDFs

And the best part?

👉 No login required
👉 No file upload to server
👉 Everything runs inside your browser

This is exactly what modern JavaScript enables.

🧪 What’s Happening Under the Hood?

Tools like these use:

WebAssembly for performance-heavy tasks
JavaScript File APIs for file handling
Canvas for image manipulation
In-browser processing libraries

This replaces what used to require:

PHP / Node backend
Cloud storage
Processing queues
🚀 The Future: Backend Optional?

We’re not saying backend is dead.

But we are saying:

👉 It’s no longer required for many use cases.

Use browser-only apps when:

Privacy matters
Speed matters
Simplicity matters

Use backend when:

You need persistence
Multi-user systems
Heavy data processing at scale
💡 Final Thought

JavaScript didn’t just evolve…

It redefined what’s possible on the web.

We’ve gone from:

“Click a button → send to server”

To:

“Process everything instantly — right where you are”

And this is just the beginning.

Have you used browser-based tools like this?

Do you think backend-free apps are the future?

👇 Let’s discuss in the comments.

🌍 GreenLens — AI That Tells You Exactly Where to Plant Trees

ahmad rabbani — Sun, 19 Apr 2026 06:06:41 +0000

What I Built

I built GreenLens, an AI-powered platform that turns any location into actionable environmental intelligence.

Most tools show:

AQI
climate data
reports

👉 But they don’t answer:

“Where exactly should we plant trees?”

🌳 The Breakthrough

GreenLens doesn’t just analyze — it decides.

It tells you:

📍 where to plant trees
🌱 how many trees are needed
🌳 where dense forests are possible
🧠 what strategy to follow
🌿 Miyawaki Forest Detection (Core Feature)

Using the Miyawaki method, the system identifies:

high-impact plantation zones
small-area dense forests
fast-growing urban greening opportunities

⚡ How It Works
User selects location
↓
Fetch environmental data
↓
Calculate tree opportunity
↓
AI generates recommendations
↓
Dashboard displays results
🧠 AI Layer (What Makes It Special)

Instead of a chatbot, Google Gemini acts as a decision engine:

interprets environmental signals
generates human-readable insights
suggests real-world actions
💡 Core Idea

Data provides facts. AI provides direction.

🚀 From Analysis → Real Impact

This is not just a tool — it’s a platform vision.

🌍 Community Tree Tracking
tag planted trees
upload images
track growth
build local communities

👉 “This area needs 500 trees → fund → plant → track”

🏗️ How I Built It
Tech Stack
Laravel + Blade
Bootstrap
Google Maps API
Google Air Quality API
Google Gemini
SQLite
Nginx
⚡ Real Engineering Challenge

The app runs under:

/earth-health/

This required:

fixing Laravel routing
handling base paths
configuring nginx
🌍 Why This Matters

Environmental tools usually fail because they:

show data
but don’t guide action

GreenLens bridges:

👉 data → decisions → action

Demo Links
🌐 Live App: http://104.207.64.25/earth-health/
🧪 Assessment: http://104.207.64.25/earth-health/assess
💻 Code: https://github.com/ahmadrabbani/earth-health
💰 Call for Collaboration

I’m looking to take this further:

🌍 environmental partners
💻 developers
💰 early supporters
Prize Categories
🥇 Best Use of Google Gemini

Gemini is deeply integrated as:

interpretation layer
recommendation engine
decision support
Final Thoughts

AI shouldn’t just inform.
It should help us act.

Prize Categories
🥇 Best Use of Google Gemini

Gemini is deeply integrated as:

interpretation layer
recommendation engine
decision support

💬 Feedback welcome
⭐ Star the repo if you like it

I Built a Free Developer Tools Hub — No Login, No Tracking, Just Speed

ahmad rabbani — Sun, 12 Apr 2026 19:54:48 +0000

As developers, we constantly jump between tools like:

JSON formatters
Base64 encoders
Regex testers
API testers

And honestly… most of them are either:

cluttered with ads
painfully slow
or require login for no reason 🤦‍♂️

So I decided to build something simpler.

🧰 Introducing NextGenTools (Developer Tools Section)

A clean, fast, and privacy-first developer toolkit.

👉 https://nextgentools.live

💡 What Makes It Different?
⚡ Instant Usage (No Login)

No accounts. No friction.
Open → Use → Done.

🔒 Privacy First
No data storage
No tracking scripts messing with your workflow
Everything runs cleanly without unnecessary overhead
🧪 Tools You Actually Use Daily

From the current version 👇

API Tester
JSON Formatter
Base64 Encoder / Decoder
UUID Generator
URL Encoder / Decoder
Color Picker
Regex Tester

All in one place.

🎯 Built for Real Dev Workflow

The idea was simple:

Reduce tab switching and remove friction.

Instead of:

Opening 5 different sites
Waiting for them to load
Closing popups

You just use one clean interface.

🖼️ UI Preview

The goal was minimal + functional:

Fast search bar
Quick access cards
No distractions
🔥 What’s Coming Next
Request-based tool additions
More advanced API utilities
Dev-focused automation tools
💬 Looking for Feedback

I’d really appreciate honest feedback from devs here:

What tool do you use daily that I should add?
Any UX improvements you’d suggest?
Performance issues on your device?
🙌 Try It Out

👉 https://nextgentools.live