DEV Community: Rajab Baig

Mr.PERFECT---TO PERFORM AGENTIC TASKS USING LOCAL LLM

Rajab Baig — Sun, 07 Jun 2026 05:16:49 +0000

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

What I Built

What I Built: Agent Mr. Perfect
The Backstory
I started with a folder full of local LLM tools and a desire and wish to run AI model locally completely offline for accuracy, privacy and speed. However, for a long time due to my workings, the project was just a "server in a box"—I could chat with it, but it couldn't do anything. It was a powerful engine with no wheels. This challenge gave me the push to build the "wheels": a custom agentic layer I call Agent Mr. Perfect.
The "Before": A Local LLM Server
Before this submission, my project was essentially a local hosting setup.
The Tech: I was using text-generation-webui as a backend to run quantized models like Gemma (via llama.cpp). It run perfectly on only CPU 20 GB RAM and 1TD SSD and NVME device.
The Workflow: It was a "Prompt-In, Text-Out" system. I had a server listening on main: model loaded
main: server is listening on http://127.0.0.1:5005
main: starting the main loop...
02:07:49-662877 INFO Loaded "D:\NEW-MODELS\New folder (22)\gemma-4-E4B-it-Q4_K_M.gguf" in 27.61 seconds.
02:07:49-662877 INFO LOADER: "llama.cpp"
02:07:49-662877 INFO CONTEXT LENGTH: 131072
02:10:22-236834 INFO OpenAI/Anthropic-compatible API URL:

                     http://127.0.0.1:5000/v1

Running on local URL: http://127.0.0.1:7860, providing an OpenAI-compatible API, but I had to manually interact with it for every single response.
The Limitation: The AI was "limited" in the terminal. It had no way to access my local files, search the web, or execute multi-step tasks. If I wanted to research a topic and summarize it, I had to do the research myself and paste the text into the UI.
The "After": Agent Mr. Perfect (The Agentic Shift)
For my submission, I transformed this local server into a fully-functional Agentic System. I built Agent Mr. Perfect to bridge the gap between "Chatting" and "Acting."
Autonomous Task Planning: Instead of just responding to a prompt, Mr. Perfect now breaks down complex goals into smaller, executable steps.
Tool Integration: I connected the local LLM to a suite of "tools" (Python scripts and APIs) that allow it to perform actions like file manipulation, web searching, and data processing.
Persistent Memory: I implemented a local state-management system so the agent remembers the context of a long-term project across different sessions, rather than forgetting everything the moment the server restarts. With Save Session and Load Session Commands, one can start where it stopped his work.
The "Perfect" Standard: I refined the system prompts and error-handling loops to ensure the agent self-corrects. If a task fails, Mr. Perfect analyzes the error and tries a different approach until the task is complete. I has four steps loop to complete a task.
Why it matters
By moving from a standard UI to an agentic workflow, I've created a private, local-first assistant that can actually manage workflows. I’m no longer just running an LLM; I’ve built a partner that handles the "heavy lifting" of my development tasks and work loads without a single byte of data leaving my machine.
Key Technical Details for your Documentation:
Model Used: gemma-4-E4B-it-Q4_K_M.gguf (Quantized for efficiency)
Inference Engine: llama.cpp[1]
Architecture: Local API Server + Custom Agentic Logic Layer
Primary Focus: Privacy-focused automation and multi-step task execution.

Demo

rajab-rajab / github-challenge-2026-Mr.Perfect

I Built: Agent Mr. Perfect for github dev challenge-May-2026

github-challenge-2026-Mr.Perfect

I Built: Agent Mr. Perfect for github dev challenge-May-2026

View on GitHub

The Comeback Story

As earlier mentioned before it was a simple local model server running locally on my windows machine. After reading cgallenge, I decided to work for a Agent to perform different agentic tasks, coding, web browsing, system commands etc 109 tolls running on my machine.Before I prepared single file Agent comprised of more than 4000 lines of code . which I presented for Dev Gemma 4 challenge. But for Github challenge I decided to choose Divide and Conquer rule. Breaking my code in different code files using decorative approach using instances rather than static methods.

My Experience with GitHub Copilot

It really helped me in preparing Mr. Perfect. I used first plan and then implement approach. Github copilot and AI suggested decorative approach to divide my code base into tool files, and as a result I created a remarkable application.

MY PROTRAIT MAKER

Rajab Baig — Sat, 23 May 2026 20:40:42 +0000

This post is my submission for DEV Education Track: Build Apps with Google AI Studio.

What I Built

I build an RPG Character Portrait Generator that successfully uses both Gemini
(to expand simple ideas into detailed descriptions) and Imagen (to turn those descriptions into art), use the prompts below.
Prompt: "Build a web application called 'My Portrait Maker.'

Features:

User Input: A text field for character name and a dropdown for 'Universe' (choices: High Fantasy, Cyberpunk, Cosmic Horror, Steampunk, Post-Apocalyptic).
Character Traits: Add buttons or chips for Race (Human, Elf, Orc, Android, etc.) and Class (Warrior, Mage, Hacker, Pilot).
The Logic: When the user clicks 'Generate', the app should first send the user's choices to Gemini to write a 50-word, highly detailed cinematic visual description of the character.
Image Generation: Take that Gemini-generated description and pass it automatically to the Imagen API to generate a high-quality 1:1 portrait.
Gallery: Display the generated image alongside the character name and the description Gemini wrote. Include a 'Download' button to save the portrait as a PNG.
Persistence: Use localStorage so the user can see their previous character creations in a 'History' section.
Add an API Key input field in the App UI so I can paste my key directly into the running app to test it. Styling: Use a dark, professional 'gaming' theme with gold accents and a responsive layout."

Demo

https://my-portrait-maker-652806875882.asia-southeast1.run.app

My Experience

I learned how a good and powerful prompt can be converted into a stunning application. Technology is getting so advanced that user can create what he imagines.

AGENT Mr. PERFECT AND GEMMA 4 E4B

Rajab Baig — Sat, 23 May 2026 06:13:50 +0000

This is a submission for the Gemma 4 Challenge: Build with Gemma 4

What I Built

My project is based on Google Gemma 4 variant E4B model. 1- I created an Agent that perform different agentic tasks named as tools which consists of powershell commands, content creation, coding tasks using python, html, php, c, c++ languages. I used gguf file of E4B model 4.63 GB named gemma-4-E4B-it-Q4_K_M.gguf
I developed powerful Agentic AI - Local LLM Assistant, a high-performance desktop orchestration layer powered by the Google Gemma 4 E4B (it-Q4_K_M) model.
As many AI assistants are confined to a chat box, my project bridges the gap between conversational AI and OS-level execution. I designed it for developers, system administrators, and power users who need a powerful local, private agent capable of managing a Windows environment through natural language.
By leveraging the advanced reasoning and instruction-following capabilities of the Gemma 4 E4B model, the agent can intelligently select and chain together over 50+ specialized tools to perform complex system tasks. No doubt Agent Mr. Perfect works as Brain and Gemma 4 E4B as Heart in the project.
Core Capabilities:
🖥️ Advanced System & Windows Admin: The agent uses Gemma 4’s logic to generate and execute precise authorized PowerShell commands for monitoring system health, managing Windows services, inspecting registry keys, and analyzing event log and using other tools----- all without the user needing to remember complex syntax.
💻 Multi-Language Coding Assistant: A sandbox-ready environment where the agent can write, debug, and execute code in Python, HTML, PHP, C, and C++. It doesn't just write code; it can create the files and execute them locally to verify results.
🌐 Autonomous Web-Augmented Reasoning: When the local model identifies a gap in its training data (such as current events or specific documentation), it autonomously triggers a web search via the Tavily API, parses the results, and provides answers with verified URLs.
📁 Intelligent File Management: A robust suite of tools for file operations (create, hash, move, search) protected by a sophisticated Self-Protection Layer that prevents the AI from modifying critical system files or its own source code.
🛡️ Secure Local Execution: Built for privacy-conscious users, the system runs entirely on a local server (via text-generation-webui), ensuring that sensitive system data and code never leave the local machine.
Here is the command used to load Gemma4 E4B
python server.py --cpu --listen-host 127.0.0.1 --listen-port 7860 --loader llama.cpp --model "D:\NEW-MODELS\New folder (22)\gemma-4-E4B-it-Q4_K_M.gguf" --auto-launch
Here is the output of generated command
main: model loaded
main: server is listening on http://127.0.0.1:5005
main: starting the main loop...
22:33:57-707819 INFO Loaded "D:\NEW-MODELS\New folder (22)\gemma-4-E4B-it-Q4_K_M.gguf" in 42.22 seconds.
22:33:57-707819 INFO LOADER: "llama.cpp"
22:33:57-707819 INFO CONTEXT LENGTH: 131072
22:37:00-762808 INFO OpenAI/Anthropic-compatible API URL:

                     http://127.0.0.1:5000/v1

Running on local URL: http://127.0.0.1:7860
As model is running on http port 7860 with chat-ui. It means user can chat directly with Gemma 4 E4B and set Question & Answer session with loaded model.
And for agentic tasks I would first run my agent.py file which would use OpenAI/Anthropic-compatible API URL:

                     http://127.0.0.1:5000/v1

to make API calls to the loaded Gemma 4 E4B model i.e Agent would work as Brain and Gemma 4 E4B as Heart of the project.
Here is the command to launch my Agent Mr. Perfect
C:\Users\RAJAB BAIG\Documents\GitHub\BAIG\PERFECT>python agent.py
It would open our GUI-Interface based Agent Mr. PERFECT
The Brain (Agent Mr. Perfect): This is the orchestration layer of my Project. It handles the "cold logic"—the 65+ tools, the PowerShell administration, file hashing, and multi-language code execution (Python, C, PHP). It is the structural "Perfect" execution of tasks.
My Agent Mr. PERFECT answers in FOUR STEPS ONE BY ONE.
The Problem It Solves:
As modern workflows often require jumping between a web browser for research or visiting a URL, a terminal for system commands, and an IDE for coding. Agentic AI combines and unifies these into a single, modern GUI. By using Gemma 4 E4B, the assistant understands the "intent" behind a user's request—like "Optimize my system for gaming"—and translates that into a series of diagnostic and administrative actions. It works as mind body relationship.
I also added SAVE SESSION AND LOAD SESSION functionalities to make my Agent and Gemma 4 E4B project modern and robust. The Save/Load functionality transforms Agent Mr. Perfect from a temporary chat interface into a persistent engineering assistant. By capturing and ensuring the synergy between Gemma 4’s reasoning and local tool execution in a structured JSON format, I provide users with a transparent, safe, auditable, and private record of their AI-driven workflow that they can check and use anytime.

Demo

[(https://youtu.be/cbrrgWRNvkw)]

Code

https://github.com/rajab-rajab/gemma4-agentic-gui-app

How I Used Gemma 4

For this project, I chose the Gemma 4 E4B (it-Q4_K_M) model. As an "Engineering-for-Business" variant, it provides the precise reasoning required to handle system-level administration and multi-language coding tasks without the massive hardware requirements of larger dense models. As it has suitable memory space i.e 4.63 GB, it is easy to work for 20 GB RAM of mine only CPU machine.
🧠 The Heart of the Orchestration Layer
Gemma 4 E4B serves as the central decision-maker. Unlike standard chat models, I utilized Gemma’s advanced instruction-following capabilities to act as a Tool Orchestrator. When a user submits a prompt like "Check my CPU and if it's over 80%, tell me which process is the culprit," Gemma 4:
Analyzes the intent.
Selects the appropriate system tools (get_system_info and get_processes).
Parses the raw data returned by the OS.
Synthesizes a human-readable explanation.
🛠️ Precision Engineering & PowerShell Generation
The E4B variant shines in its ability to generate syntactically correct code. I leveraged its strengths to:
Generate PowerShell Scripts: Gemma 4 generates complex Windows Admin commands for registry queries and service management on the fly.
Multi-Language Logic: The model handles logic across Python, HTML, PHP, C, and C++, allowing the agent to not only write scripts but also explain the logic and debug execution errors in the local environment.
🔍 Autonomous Reasoning & Web Fallback
I implemented a "Self-Awareness" loop using Gemma 4. If the model determines that its local tools or internal training data are insufficient to answer a query (e.g., "What is the current version of React?"), it is programmed to autonomously trigger a Web Search Fallback. It then processes the search snippets to extract the most relevant information and presents them as interactive, URLs.
🛡️ Safety and Constraint Adherence
A critical part of using Gemma 4 was its ability to respect strict Self-Protection Rules. I provided the model with a system context that forbids it from interacting with its own source code (agent.py) or the LLM's binary files or pc system files and system disk. Through testing, Gemma 4 E4B demonstrated superior adherence to these safety guardrails compared to smaller models, ensuring the agent remains a helpful assistant rather than a system risk.
⚡ Optimized Local Performance
By using the 4.63 GB GGUF quantization (Q4_K_M), I achieved a balance of high intelligence and low latency. The model runs locally on consumer-grade hardware, ensuring that the system monitoring and file operations happen in near real-time, providing a "snappy" desktop experience while keeping all user data 100% private.
"Mr. Perfect is not just a wrapper for Gemma 4; but it is a safety-first orchestration layer that translates Gemma’s engineering-grade reasoning into safe, fast, reliable, local actions."
Here is a comprehensive list of the "Plus Points" for my project.

The "Heart & Brain" Architecture (Conceptual Innovation)
- Dual-Layer Intelligence: Instead of a generic chatbot, I have created a synergy between the Heart (Gemma 4 E4B) for high-level reasoning and the Brain (Mr. Perfect) for precise and exact and error free system execution. Intent Recognition: The system doesn't just "chat"; it also understands and uses engineering intent. If a user asks to "Fix the PC or want to run system commands," the agent knows to trigger diagnostic tools and commands rather than just giving advice.
Powered by Gemma 4 E4B (Model Optimization)
- Engineering-for-Business (E4B) Precision: I chose the E4B variant specifically for its superior performance in generating high level technical programming code (Python, PowerShell, C++) and following complex and difficult business logic.
- Local Performance: By using the it-Q4_K_M GGUF quantization, I have achieved a perfect balance: high intelligence (reasoning) and accuracy with low latency (speed) on consumer-grade hardware. As it uses minimal resources in RAM and disk space.
- Private & Offline: The model runs 100% locally. A protected environment where no data ever leaves the user's machine, making it suitable and important for corporate and sensitive engineering environments.
Professional Grade Toolset (65+ Built-in Tools)
- OS-Level Integration: While most AI agents are "sandboxed," Mr. Perfect has deep integration with Windows via PowerShell Admin Tools, allowing for real-time system monitoring, registry edits, and service management.
- The Developer's Swiss Army Knife: Built-in capabilities for Code Creation, Creating files and folders, Syntax Checking, and Immediate Execution across multiple languages (Python, HTML, JS).
- Web-Augmented Reasoning: When local knowledge isn't enough, the agent autonomously and efficiently uses the Tavily API to fetch real-time data, presenting it with Verified URLs.
Advanced Session Management (The "Black Box")
- Persistence (Save/Load): Its ability to save sessions to JSON transforms the agent from a temporary chat into a persistent workspace for developers and software engineers.
- Auditability: The JSON logs provide a transparent and neat record of each and every step of "Action" and "Argument," which is critical for business stability, accountability and debugging.
- Ease of Any time Context Restoration: Users can stop and close mid-project, save their current session, and reload it later to pick up and start exactly where Gemma 4 left off.
"Responsible AI" & Safety (The Self-Protection Layer)
- Self-Preservation Logic: The agent is hard-coded to never delete its own source code (agent.py) or the LLM binaries. This prevents "Agentic Suicide" or accidental system damage.
- System Guardrails: It recognizes protected Windows directories and system files, refusing to perform "Delete" operations on critical OS components.
- Human-in-the-Loop: Critical actions (like system shutdown or bulk file deletion) require explicit user confirmation through the modern GUI.
Modern & Intuitive UX (CustomTkinter GUI)
- Clean Dark Theme: A professional, tech-focused interface that reduces eye strain for long engineering and coding sessions.
- Dynamic Status Feedback: The UI provides real-time updates (e.g., "Step 1/4: Tool Execution: "), so the user is never left wondering what the agent is "thinking."
- Rich Text Features: Support for URLs, color-coded message tags. Quick Prompt buttons for common tasks.
Resilient Execution (The 4-Iteration Loop)
- Autonomous Problem Solving: The agent uses a multi-step thinking process while working with Gemma4. If a code execution fails, it reads the error, searches for a fix, modifies the code, and tries again—all in one session.
- Synthetic Final Answers: if the agent exhausts its loop during a tool call, it provides a logical summary of its actions, ensuring the user is always well informed and aware.
Clean and neat Code & High Portability
- Single-File Power: Most of the core logic is contained in agent.py, making it incredibly easy for other developers to download, inspect, and run.
- Standardized Data: By using standard JSON for sessions and Markdown for code, your project integrates perfectly into existing developer workflows (like GitHub and VS Code). I am still working on Install, Uninstall, Update, Shutdown and Restart functionalities. However, most of powershell tools are working fine.