DEV Community: Okeke Chukwudubem

21 build logs. Months of work. One shipped project. An autonomous AI agent that controls a phone. Web interface. Multi-app workflows. 94% accuracy. Full setup guide included so you can run it yourself. 👉 github.com/Dexter2344/phone-agent

Okeke Chukwudubem — Sun, 09 Aug 2026 09:32:18 +0000

Okeke Chukwudubem

Aug 9

Project Log #21: The Grand Finale. We Shipped. (Plus: Full Setup Guide)

#ai #webdev #python #automation

4 min read

Project Log #21: The Grand Finale. We Shipped. (Plus: Full Setup Guide)

Okeke Chukwudubem — Sun, 09 Aug 2026 09:30:30 +0000

21 build logs. Months of work. One shipped project. Here's the full journey—and how to set up the Phone Agent on your own device.

The first build log was published months ago. "I'm building an AI agent that controls a phone." No code. No repo. Just an idea and a cracked phone.

Today, after 21 build logs spread across months, the project is shipped.

This wasn't a straight line. There were gaps. Weeks where the log went silent—not because the work stopped, but because life doesn't pause for build logs. I took breaks to survive exam season. I paused to ship 9 portfolio websites. I stepped away when the code refused to cooperate and my brain needed rest.

But every time I came back, the agent was still there. Waiting. And every log picked up where the last one left off.

What We Built

An autonomous AI agent that controls an Android phone using natural language commands. It can parse your words into actions, read the screen, tap buttons, type text, switch between apps, verify financial data, and serve a web interface—all offline.

The Real Timeline

Phase	What Happened
Days 1-4	Foundation. Gemma 4 + ADB. First working pipeline.
Days 5-8	Vision overhaul. UI tree. OCR. Template matching.
Days 9-12	Accessibility audit. 30 apps scored.
Days 13-16	Multi-app workflows. Task memory. Home reset.
Days 17-19	Financial verification. Accuracy from 80% to 94%.
Breaks	Exams. Portfolio sites. Life.
Days 20-21	Web interface. Flask backend. Shipped.

📖 FULL SETUP GUIDE: How to Install and Use the Phone Agent

Follow these steps to get the agent running on your own Android phone.

Prerequisites

An Android phone (Android 7 or later)
At least 6GB of free storage space
A WiFi connection for the initial download

Step 1: Install Termux

Do NOT install Termux from the Google Play Store—that version is outdated. Install it from F-Droid instead.

Open your phone's browser
Go to f-droid.org
Download and install the F-Droid app
Open F-Droid and search for "Termux"
Install Termux from F-Droid

Step 2: Set Up Termux

Open Termux and run these commands one by one. Wait for each to finish before typing the next.


bash
pkg update
pkg upgrade
pkg install python git curl wget
pkg install tesseract
pkg install android-tools

Step 3: Install Ollama
Ollama is the tool that runs Gemma 4 locally on your phone.

bash
curl -fsSL https://ollama.com/install.sh | sh
After installation, start Ollama:

bash
ollama serve
Open a new Termux session (swipe from left, tap "New session") and pull the Gemma 4 model:

bash
ollama pull gemma4:4b
This downloads about 2-3GB. Use WiFi. Be patient.

Step 4: Clone the Phone Agent Repository
bash
git clone https://github.com/Dexter2344/phone-agent.git
cd phone-agent
Step 5: Install Python Dependencies
bash
pip install flask flask-cors requests numpy PyPDF2 lancedb
Step 6: Enable Developer Options and ADB
Go to Settings → About Phone

Tap "Build Number" 7 times until you see "You are now a developer"

Go back to Settings → Developer Options

Enable "USB Debugging"

Connect your phone to itself via ADB:

bash
adb devices
You may need to approve a prompt on your phone. Once approved, you'll see your device listed.

Step 7: Start the Phone Agent
Using the Web Interface (Recommended):

bash
python server.py
Then open your phone's browser and go to: http://localhost:5000

You'll see a chat interface. Type commands like:

"Open WhatsApp and send a message to Mom saying I'll call later"

"Copy my bank balance and send it to Mom on WhatsApp"

Using the Terminal (Alternative):

bash
python agent.py
Then type commands directly into the terminal.

Troubleshooting
Problem Fix
"Ollama not found"  Make sure you ran ollama serve in a separate Termux session
"ADB device not found"  Check USB Debugging is enabled. Run adb kill-server then adb devices again
"Module not found"  Run pip install for the missing module
"Tesseract not found"   Run pkg install tesseract
Phone gets hot  Close other apps. The agent is CPU-intensive. Take breaks.
Agent misreads numbers  The verification layer will catch most errors. For financial data, always double-check.
Using the Web Interface
Once server.py is running and you've opened http://localhost:5000:

Status bar: Green dots mean Ollama and ADB are connected. Red dots mean something is wrong.

Command input: Type what you want the agent to do. Be specific.

Example commands: Click any example to auto-fill and send.

History: Your last 20 commands and responses are stored.

The Repo

👉 github.com/Dexter2344/phone-agent

21 build logs. Months of work. One shipped project. Full setup guide included.

Thank You

To everyone who followed this log—through the daily posts and the weeks of silence—thank you. This was never about shipping fast. It was about shipping honestly.

This was Log #1:

"I'm starting a new project. It's the most ambitious thing I've attempted from a phone."

This is Log #21. We shipped.

Day 20: Hours of debugging. CORS errors. Broken paths. Misspelled IDs. But the Phone Agent finally has a web interface. Flask backend. Chat-style frontend. No more terminal-only. 👉 github.com/Dexter2344/phone-agent

Okeke Chukwudubem — Tue, 04 Aug 2026 23:30:34 +0000

Okeke Chukwudubem

Aug 4

Project Log #20: After Hours of Screen Time, the Agent Has a Face

#ai #webdev #python #automation

2 min read

Project Log #20: After Hours of Screen Time, the Agent Has a Face

Okeke Chukwudubem — Tue, 04 Aug 2026 23:29:31 +0000

Day 20. I stared at my screen until my eyes burned. But the web interface is live. Flask backend connected. The agent is finally usable.

I've been staring at this screen for hours.

Not the productive kind of staring. The frustrating kind. The kind where you write 50 lines of code, test it, watch it break, rewrite it, test it again, and repeat until you forget what time it is.

Today was that kind of day.

What Got Built

After hours of debugging, I shipped two things:

A Flask server (server.py) that wraps the agent in a REST API. Three endpoints: /status checks if Ollama and ADB are connected. /command sends a natural language command to the agent and returns the result. /history returns the last 20 commands.
A web interface (interface.html) that looks like a chat app. Dark terminal theme. Gold accents. Type a command. See the agent respond. Real-time status indicators showing whether Ollama and ADB are alive.

The interface talks to Flask on localhost:5000. Flask talks to the agent. The agent talks to the phone. Everything local. No cloud. No external servers. Just a phone running its own AI.

The Grind

Here's what the polished build log doesn't show:

Flask refused to serve the HTML file for 45 minutes because I forgot send_file needs an absolute path.
The status endpoint kept returning false for ADB because I was checking the wrong string in the output.
The interface looked like a developer's debug page until the third redesign.
CORS errors because I forgot flask-cors. Ten minutes of confusion for a one-line fix.
The send button wasn't working because I misspelled getElementById. Thirty minutes. One missing character.

This is the real build log. Not the clean version. The "I need to step away from this screen before I throw my phone" version.

The Result

The interface works. It's not beautiful yet. The design will evolve. But you can type a command in a browser, hit enter, and watch the agent execute it on the phone. That's the milestone.

Status bar at the top. Chat display in the middle. Input area at the bottom. Example commands you can click. Loading states. Error messages. All the basics.

What Still Needs Work

The setup process is still manual. Install Termux. Pull Ollama. Configure ADB. Run the server. Open the browser. Too many steps. A setup script is next.
The interface needs polish. Animations are basic. The design is functional but not premium. I'll iterate.
End-to-end testing hasn't happened yet. The agent works in controlled tests. Real-world reliability is the next frontier.

What's Next

Day 21: Write the setup script. One command. Full install.
Day 22: End-to-end testing. Fix everything that breaks.
Day 23: Ship v1.0.

The Repo

👉 github.com/Dexter2344/phone-agent

server.py is live. interface.html is live. README is updated. The project has a face.

This is Day 20. My eyes hurt. But the agent is no longer trapped in a terminal.

Day 19: My AI Phone Agent has lived in a terminal for 18 days. That changes today. I'm building a web frontend a chat interface so normal people can actually use it. Flask backend. Single-file HTML frontend. All local.

Okeke Chukwudubem — Sun, 02 Aug 2026 12:29:41 +0000

Okeke Chukwudubem

Aug 2

Project Log #19: I'm Building a Web Frontend for My AI Phone Agent

#ai #webdev #programming #python

3 min read

Project Log #19: I'm Building a Web Frontend for My AI Phone Agent

Okeke Chukwudubem — Sun, 02 Aug 2026 12:29:02 +0000

Day 19. The agent works in a terminal. That's useless for anyone else. Today, I started building a real interface.

For 18 days, my AI Phone Agent has lived entirely in a terminal. Black screen. White text. Python scripts. ADB commands. It works—but only for me.

Anyone else would take one look at Termux and walk away.

That changes today.

The Problem

The agent currently runs like this: I open Termux on my Android phone, type python agent.py, and enter commands like "Send a WhatsApp message to Mom." The agent parses the command, executes the steps, and prints results to the terminal.

This is fine for a developer. It's useless for a user. If I want this project to be more than a portfolio piece, it needs an interface that a normal person can use.

What I'm Building

A simple web frontend that runs locally on the phone. Think of it as a chat interface—like WhatsApp Web, but for talking to your AI agent.

The interface will have:

A text input field where you type commands ("Send a message to Mom," "Check my bank balance")
A chat-style display showing the agent's responses
Status indicators showing what the agent is doing (Opening WhatsApp... Finding contact... Sending message...)
A simple setup screen for first-time users

Everything runs locally. No cloud. No external servers. The web interface talks to the same Python backend that's been running in Termux for 18 days.

The Tech

I'm building this as a single HTML file with embedded CSS and JavaScript. The frontend communicates with the agent via HTTP—the Python backend exposes a simple REST API using Flask, and the frontend sends commands and receives responses.

The stack:

Frontend: HTML, CSS, JavaScript (single file)
Backend: Python Flask (lightweight, runs in Termux)
Communication: Local HTTP requests (localhost)
Styling: Dark theme matching the agent's aesthetic—black background, green terminal-style text, clean input field

Today's Progress

Task	Status
Set up Flask in Termux	✅ Done
Created basic API endpoint (/command)	✅ Done
Built HTML frontend with chat interface	🔧 In progress
Connected frontend to backend	🔧 In progress
Styled the interface	⏳ Next

What Works So Far

The Flask server runs in Termux alongside the agent. I can send a POST request to http://localhost:5000/command with a JSON body like {"command": "Open WhatsApp"}, and the agent responds with the result.

The frontend is a single HTML file with a text input and a response display area. When I type a command and press enter, JavaScript sends a fetch request to the Flask backend and displays the response. It's basic, but it works.

What's Still Broken

Flask and the agent are fighting for the same terminal. I need to run Flask in the background while keeping the agent accessible. Currently using flask run --host=0.0.0.0 --port=5000 in one Termux session and the agent in another. It's clunky but functional.

The frontend is ugly. Pure HTML with minimal CSS. I'm designing the interface tomorrow—dark theme, clean typography, smooth animations. It needs to feel premium, not like a developer tool.

What's Next (Day 20)

Complete the frontend design
Add status indicators (showing what the agent is doing in real-time)
Test the full pipeline: type command in browser → agent executes → response displayed
Start writing the setup script

The Repo

👉 github.com/Dexter2344/phone-agent

The Flask backend is in server.py. The frontend will be in interface.html. Both will be in the repo by Day 20.

This is Day 19. The agent is getting a face. No more terminal-only. Let's build something people can actually use.

Took a month off. Shipped 9 portfolio sites across different industries. Preparing for exams. The Phone Agent is still alive. Day 18 just dropped. 👉 github.com/Dexter2344/phone-agent

Okeke Chukwudubem — Fri, 31 Jul 2026 17:22:14 +0000

Okeke Chukwudubem

Jul 31

Project Log #18: I Took a Month Off. Here's Where the Agent Stands.

#ai #webdev #programming #productivity

2 min read

Project Log #18: I Took a Month Off. Here's Where the Agent Stands.

Okeke Chukwudubem — Fri, 31 Jul 2026 17:21:51 +0000

Between portfolio building and exam preparation, the build log paused—but the work never stopped. Now it's time to finish.

I haven't posted in 28 days.

Not because the project died. Not because I gave up. But because life doesn't pause for build logs.

In the last month, I've been juggling three things at once: building out my portfolio, preparing for my second semester exams, and keeping the Phone Agent alive in the background.

What I've Been Doing

I shipped 9 premium websites across different industries—restaurants, law firms, salons, gyms, construction companies, electricians, plumbers, banks, and driving schools. These aren't client projects. They're portfolio pieces. My goal was simple: make sure I have a sample site for every industry I might pitch to. When a potential client asks "do you have something for a salon?", I can say yes and send a link.

Each site is a custom single-file or multi-file HTML/CSS/JS build. Working contact forms. Responsive design. Live on Netlify. Ready to show.

I've also been preparing for second semester exams—summarizing course materials, creating study schedules, and using AI tutors to make sure I don't repeat last semester's mistakes.

And through all of that, the Phone Agent sat in the background. Not abandoned. Just waiting.

Where We Left Off

Day 17 ended with a working numeric verification layer. The agent could read bank balances, double-check them, and send them to Mom on WhatsApp. Accuracy went from 80% to 94%. Multi-app workflows were functional.

What 4 Weeks of Distance Taught Me

Stepping away gave me clarity. Building those portfolio sites taught me something: preparation beats improvisation. Having samples ready means I'm never scrambling when an opportunity comes. The same applies to the Phone Agent. It's time to stop adding features and start preparing it for the real world.

Here's the plan to close this out:

End-to-end testing. Run each multi-app workflow 10 times. Fix every edge case. No more "works on my machine."
A simple frontend. A minimal HTML interface so the agent is usable by someone other than me.
A setup script. One script that automates the entire installation—Termux, Ollama, ADB, Python dependencies.
Ship v1.0. Tag it on GitHub. Full README. Everything documented.

What's Next

Finish second semester exams
Test all workflows end-to-end
Build the web frontend
Write the setup script
Ship v1.0

No more month-long breaks. Let's finish this thing.

The Repo

👉 github.com/Dexter2344/phone-agent

The code is still there. The vision module is still solid. The multi-app workflows still work. Nothing broke in 4 weeks. That's a good sign.

My AI agent was misreading bank balances 1 in 5 times. No crashes. No exceptions. Just quiet, dangerous wrong numbers. I built a three-layer verification system that caught the bug hiding in plain sight. Format validation. Double-read confirmation.

Okeke Chukwudubem — Sat, 18 Jul 2026 18:56:15 +0000

Summer Bug Smash: Smash Stories 🐛🛹

Okeke Chukwudubem

Jul 18

Smash Stories: The Bug That Whispered for Two Weeks Before I Heard It

#devchallenge #bugsmash #ai #gemma

4 min read

Smash Stories: The Bug That Whispered for Two Weeks Before I Heard It

Okeke Chukwudubem — Sat, 18 Jul 2026 18:51:38 +0000

This is a submission for DEV's Summer Bug Smash: Smash Stories powered by Sentry.

My AI agent was misreading financial data 1 in 5 times. No crashes. No exceptions. Just quiet, dangerous wrong numbers.

Some bugs scream. Null pointer exceptions. Segmentation faults. Crash logs that light up your screen like a Christmas tree.

This one whispered.

The Setup

I'm building an AI agent that controls Android phones using Gemma 4. Natural language commands get parsed into structured JSON, translated into ADB instructions, and executed on-device. No cloud. No API keys. Just a phone that does what you tell it.

By Day 16, I'd hit a milestone: the agent completed its first multi-app workflow. "Copy my bank balance and send it to Mom on WhatsApp."

Three apps. Banking → WhatsApp. Seven steps. Success.

I celebrated. Shipped the code. Published the build log. Went to sleep feeling like an engineer.

Then I tested it again the next morning. And again. And again.

The Whisper

Out of 50 test runs, the balance was wrong 10 times. Twenty percent.

The agent wasn't crashing. No exceptions were thrown. The logs showed success. But "₦15,000" was quietly becoming "₦15.000" or "₦15,00" or "₦15000." A currency symbol mistaken for a digit. A comma parsed as a decimal. A zero dropped from the end.

The wrong number was being sent to Mom. And I had no idea for two weeks because nothing was failing loudly enough to make me look.

The Root Cause

I traced the problem to a single bad assumption: I was treating OCR output as ground truth.

Banking apps scored F on my accessibility audit. Zero UI labels. The agent had to rely entirely on optical character recognition to read anything on screen. And banking apps are a hostile environment for OCR:

Condensed fonts designed for dense data, not readability
Grey text on slightly-darker-grey backgrounds
Currency symbols (₦) that OCR models frequently confuse with digits
Commas in large numbers that OCR sometimes parses as decimal points

One screenshot. One OCR pass. One number stored in memory. No verification. No double-check. No sanity check. I had built a pipeline that trusted a single, unreliable data source with financial information.

The Fix: Defense in Depth

I didn't try to make the OCR better. Tesseract and ML Kit are what they are. Instead, I built a three-layer verification system that treats every financial number as unverified until proven otherwise.

Layer 1: Format Validation

Before a number is accepted, it must match a valid currency pattern. The regex checks for currency symbols (₦, $, £, €) followed by properly formatted digits. Anything that doesn't match gets rejected instantly.


python
pattern = r'[₦$£€]?\s?\d{1,3}(?:,\d{3})*(?:\.\d{2})?'
matches = re.findall(pattern, extracted_text)
if not matches:
    return False, "", "No currency values found"

This alone catches about half the errors garbled text, partial reads, and non-numeric data that OCR sometimes returns.

Layer 2: Double-Read Confirmation

The agent captures two separate screenshots and runs OCR on both independently. If the numbers match, the value is accepted with high confidence. If they differ, a third screenshot is captured and the best-of-three wins.

# Read twice
text1 = extract_text(screenshot1)
text2 = extract_text(screenshot2)

num1 = extract_number(text1)
num2 = extract_number(text2)

if num1 == num2:
    return True, num1, "High confidence"

# Tiebreaker
text3 = extract_text(screenshot3)
num3 = extract_number(text3)

if num1 == num3:
    return True, num1, "Medium confidence (2/3)"
elif num2 == num3:
    return True, num2, "Medium confidence (2/3)"

This catches transient OCR errors—pixel-level variations between screenshots that produce different readings. The cost is 4-6 extra seconds per financial read. The benefit is catching errors that would otherwise silently corrupt data.

Layer 3: Range Validation

Even a correctly formatted, double-confirmed number can be nonsensical. A balance of "₦0" might mean an empty account—or it might mean the OCR failed completely and returned nothing. A balance of "₦999,999,999,999" is almost certainly an error.

if 1 <= value <= 1_000_000_000:
    return True
else:
    return False  # Suspicious. Re-read.

This catches the edge cases—numbers that pass format and double-read checks but are clearly wrong in context.

The Celebration

After implementing all three layers, I re-ran the 50-test battery. The error rate dropped from 20% to 6%. For the specific "₦15,000" test case, 20 out of 20 reads were correct with double-read confirmation.

The agent now succeeds 19 times out of 20 on multi-app financial tasks. The one failure is a timeout (banking app loads slowly on an old device), not a misread. And critically, when verification fails, the agent now knows it failed. It reports low confidence and aborts the task instead of silently sending wrong data.

What This Taught Me

The bug wasn't in the OCR engine. It was in my architecture. I had built a system that trusted a single, unreliable data source with financial information. That wasn't a Tesseract problem. That was a design problem.

The fix wasn't a better model. It was a better process. Three cheap, fast checks that together create confidence where no single check could. Defense in depth applied to data integrity.

This changed how I think about every feature I build. I now ask: "If this component silently returns wrong data, will I know? If not, where's the verification?"

The Code

The full verification system is open source on GitHub:

👉 github.com/Dexter2344/phone-agent

vision.py contains the verify_financial_data() function. agent.py calls it before storing any financial value in task memory.

The Build Log

I've been documenting this project publicly for 17 days on Dev.to. Every breakthrough, every dead end, every "why is this broken" debugging session at 1 AM.

This bug was Day 17. The one that almost shipped. The one that whispered.

It's not the loudest bug I've ever caught. But it's the one that taught me the most.

This is my entry for the Dev.to Smash Stories contest. The Gemma 4 model powers the agent's command parsing and reasoning. The verification layer is my own work.

Project Log #17: My Agent Misreads Bank Balances. Here's How I'm Fixing It.

Okeke Chukwudubem — Sat, 18 Jul 2026 18:21:54 +0000

Day 17. OCR on banking apps is unreliable. I built a verification layer that double-checks every number.

Day 16 was a milestone: multi-app workflows. The agent copied my bank balance and sent it to Mom on WhatsApp. Three apps. One task.

But behind that success was an uncomfortable truth: the agent misreads numbers about 20% of the time.

For a message to Mom, that's a typo. For a financial transaction, that's a disaster.

Today, I built the fix.

The Problem

Banking apps scored F on my accessibility audit. No UI labels. No content descriptions. The agent has to rely entirely on OCR to read anything on screen.

And banking apps have terrible OCR conditions:

Small, condensed fonts for account numbers and balances
Low contrast (grey text on slightly darker grey backgrounds)
Currency symbols (₦, $, £) that OCR often confuses with numbers
Commas in large numbers that OCR sometimes reads as decimals

The result? A balance of "₦15,000" sometimes gets read as "₦15.000" or "₦15,00" or "₦15000." One missing digit. One wrong decimal. And the entire task is compromised.

The Fix: Numeric Verification Layer

I built a verification step specifically for financial data. Before any number gets stored in task memory, it goes through three checks.

Check 1: Format Validation
The extracted text must match a valid currency format. It must contain a currency symbol (₦, $, £, €) followed by digits, optionally with commas and a decimal point. Anything that doesn't match this pattern is rejected immediately.

Check 2: Double-Read Confirmation
The agent reads the same number twice—two separate screenshots, two separate OCR passes. If both readings match exactly, the number is accepted. If they differ, the agent reads a third time. If two out of three match, that value wins. If all three differ, the task is aborted with an error message.

Check 3: Range Validation
The extracted number must fall within a reasonable range. A bank balance of "₦0" or "₦999,999,999,999" is probably an OCR error. The agent checks that the number is between ₦1 and ₦1,000,000,000. Anything outside that range triggers a re-read.

Today's Progress

Task	Status
Built numeric verification layer	✅ Done
Tested on banking app balance (50 attempts)	✅ 94% accuracy (up from ~80%)
Tested on "₦15,000" specifically (20 attempts)	✅ 100% accuracy with double-read
Added verification to `vision.py`	✅ Done
Updated `agent.py` to use verification for financial data	✅ Done

The Results

Before the verification layer: 20% error rate on financial data.
After the verification layer: 6% error rate. Still not perfect, but dramatically better.

For the specific task of reading a bank balance and sending it to Mom, the agent now succeeds 19 times out of 20. The one failure is usually a timeout (banking app loads slowly) rather than a misread.

What Still Breaks

The double-read confirmation adds about 4-6 seconds to any task involving financial data. For a 3-app workflow, that's an extra 10-15 seconds. Not a dealbreaker, but noticeable.

The range validation is crude. A legitimate bank balance of "₦0" (empty account) would be rejected as an error. I need a way to distinguish between "zero" and "OCR failed completely."

And the verification only works for numbers. Text extraction—names, addresses, transaction descriptions—still has no verification. The agent could send "Mom" the wrong transaction description and have no way of knowing.

What's Next (Day 18)

Add text verification for transaction descriptions
Test with real financial data (multiple transactions, not just balance)
Start building the demo video

The Repo

👉 github.com/Dexter2344/phone-agent

vision.py now includes verify_financial_data() with format validation, double-read confirmation, and range checking. agent.py calls it before storing any financial data in task memory.

This is Day 17. The agent is learning to double-check its own work.

Day 16: My AI agent now resets to the home screen between app switches. The first 3-app workflow just worked—banking app summarise WhatsApp. Reliability went from "sometimes" to "almost always." github.com/Dexter2344/phone-agent

Okeke Chukwudubem — Tue, 14 Jul 2026 15:08:45 +0000

Okeke Chukwudubem

Jul 14

Project Log #16: I Fixed the App-Switching Problem That Kept Breaking My Agent

#ai #webdev #programming #productivity

3 min read