DEV Community: Andy Mak

Why Gemma 4 E4B Was the Right Fit for Anti-FraudX

Andy Mak — Mon, 18 May 2026 14:19:56 +0000

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

What I Built

Anti-FraudX is a local anti-scam training platform for Hong Kong.

It simulates scam conversations, explains red flags, and helps users practise responses before they face a real fraud attempt. The project is designed for privacy-sensitive, community-friendly deployment, so the experience runs locally through Ollama instead of depending on cloud AI for every interaction.

The system combines role-based simulation, trust scoring, and local model serving. That means users can see not just what a scam looks like, but how it unfolds under pressure.

Gemma 4 E4B is the model that makes this practical. It powers the default reasoning path, victim simulation, recorder analysis, and the broader anti-fraud workflow.

Why I Chose Gemma 4 E4B

Gemma 4 comes in different sizes, and the right one depends on the job.

2B / 4B models are best for tiny edge or browser-style deployments
E4B is the right balance for local, privacy-sensitive applications that still need useful reasoning
26B MoE is better when throughput and richer reasoning matter more than footprint
31B Dense is a stronger server-grade option when hardware is available

For Anti-FraudX, the deciding factor was deployment reality. The system needs to run in schools, homes, and community centres, where local execution and practicality matter as much as raw model size. E4B is large enough to support conversation, scoring, and explanation, but still small enough to remain usable on local infrastructure.

That trade-off is important. A model can be technically impressive and still be the wrong choice for a product if it is too expensive, too heavy, or too difficult to deploy where people actually need it.

How I Used Gemma 4

Gemma 4 E4B is used in the parts of the product that matter most:

Default model path for general local reasoning
Victim agent for realistic responses under scam pressure
Recorder agent for analysis, scoring, and feedback generation

That makes Gemma 4 part of the actual learning loop, not just a model sitting behind the UI. The system uses it to simulate behaviour, explain risk in plain language, and help users understand how scams work in real situations.

The runtime configuration is simple:

GEMINI_ENABLED=false
AGENT_MODEL=gemma4:e4b
AGENT_MODEL_VICTIM=gemma4:e4b
AGENT_MODEL_RECORDER=gemma4:e4b

The point of making this configuration visible is reproducibility. If someone wants to understand how the system behaves, the model choice is not hidden in a prompt or a private script. It is explicit in the environment and in the code.

What I Learned

1. Model choice should match deployment

A larger model is not automatically a better product choice. For anti-scam training, usability and local access matter just as much as model capability.

2. The model should be visible in the code

The Gemma 4 choice is reflected in environment variables, backend defaults, Docker configuration, and tests. That makes the setup reproducible and easy to verify.

3. Useful AI systems need more than generation

Anti-FraudX combines Gemma 4 with trust scoring, role-based simulation, local serving, and testable workflows. The value comes from the system design, not only from the base model.

4. Good local AI should serve a real purpose

The most interesting thing about Gemma 4 here is not that it is powerful, but that it is practical. It can support a local training tool that helps users build safer habits before a scam reaches them.

Why This Matters

Scams are emotional, fast-moving, and highly localised. In Hong Kong, people are often targeted through WhatsApp messages, phishing SMS, fake banking pages, fake police calls, romance scams, investment scams, and QR code payment traps.

Gemma 4 makes it possible to build tools that are not only smart, but also deployable, privacy-aware, and useful in real communities. That is why E4B was the right fit for Anti-FraudX.

The broader lesson is that open local models can matter in everyday safety work. When a model is small enough to run locally but capable enough to reason clearly, it becomes useful in places where cloud AI is not the right answer.

Conclusion

Anti-FraudX needed a model that could support local inference, practical reasoning, and multimodal scam education without making deployment too heavy. Gemma 4 E4B fits that job well.

It is not just a model choice for a benchmark. It is the model choice that makes the product usable.

The project demonstrates how open local models can create meaningful safety impact: not by replacing human judgment, but by training it before the moment of risk.

Code

Repository: https://github.com/LamChingFung-2425/Anti-FraudX/tree/andy-v7(gemma-4.0)

Key implementation files:

backend/main.py — loads environment variables, applies startup checks, and serves the FastAPI app
backend/config.py — centralizes the default model selection for each agent
backend/api/chat_routes.py — routes chat requests through the configured local model
backend/services/vision_service.py — shared local model setup for analysis paths
backend/tests/test_environment.py — checks that the required Gemma 4 model is available
backend/tests/test_ollama_direct.py — verifies the direct Ollama path against Gemma 4

Demo

Demo video: https://youtu.be/BLYm_VUpMUI

Live demo: https://anti-fraudx-frontend-5gznvtwxga-uc.a.run.app/

Anti-FraudX: Local Scam Defense Training with Gemma 4 E4B

Andy Mak — Mon, 18 May 2026 14:07:17 +0000

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

What I Built

Anti-FraudX is a local anti-scam training platform for Hong Kong learners.

Instead of only showing static scam warnings, it lets people practise scam detection through interactive AI conversations, RPG-style training, and automated multi-agent simulations. The idea is to turn anti-fraud education into something people can rehearse, not just read about.

The project focuses on a very real local problem: scams are fast, emotional, and often happen through familiar channels such as WhatsApp messages, phishing SMS, fake banking pages, fake police calls, romance scams, investment scams, and QR code payment traps. Anti-FraudX turns those risks into practice scenarios so users can see how pressure, urgency, trust, and manipulation appear in real conversations.

The system includes:

an RPG-style training mode for scenario-based learning
a personal chat mode where users can test their reactions
an auto simulation mode with scammer, victim, expert, and recorder agents
local model serving through Ollama for privacy-sensitive use
a workflow that can be deployed in schools, homes, and community centres

The goal is to make anti-fraud education more practical, more repeatable, and more accessible for people who need it most.

Demo

Demo video: https://youtu.be/BLYm_VUpMUI

A strong walkthrough should show:

a Hong Kong scam scenario, such as a suspicious message or fake payment request
the user entering the RPG or chat mode
the scammer applying pressure or urgency
the victim and recorder agents responding through Gemma 4 E4B
the expert agent explaining the red flags
the final trust score, risk explanation, and learning takeaway

Live demo: https://anti-fraudx-frontend-5gznvtwxga-uc.a.run.app/

Code

Repository: https://github.com/LamChingFung-2425/Anti-FraudX/tree/andy-v7(gemma-4.0)

Key implementation files:

backend/main.py — loads environment variables, applies startup checks, and serves the FastAPI app
backend/config.py — centralizes model defaults for each agent role
backend/api/chat_routes.py — routes chat requests through the configured local model
backend/services/vision_service.py — shared model setup for analysis paths
backend/tests/test_environment.py — checks that the required Gemma 4 model is available
backend/tests/test_ollama_direct.py — verifies the direct Ollama path against Gemma 4

Representative runtime configuration:

GEMINI_ENABLED=false
AGENT_MODEL=gemma4:e4b
AGENT_MODEL_VICTIM=gemma4:e4b
AGENT_MODEL_RECORDER=gemma4:e4b

Anti-FraudX keeps the older fine-tuned scammer and expert models for specialist behavior, while Gemma 4 E4B powers the default reasoning, victim simulation, recorder analysis, and the main local training loop.

How I Used Gemma 4

I used Gemma 4 E4B as the main local reasoning model for Anti-FraudX.

Gemma 4 powers the parts of the system where general reasoning and user-facing explanation matter most:

Default model path for general local reasoning
Victim agent for realistic responses under scam pressure
Recorder agent for analysis, scoring, and feedback generation

I chose E4B because Anti-FraudX needs to run in realistic community environments. A larger model such as 31B Dense may offer stronger reasoning, but it also increases hardware cost and makes local deployment harder. Smaller models are easier to run, but they do not give enough depth for role-based simulation, trust scoring, and clear anti-fraud explanations.

E4B is the best balance for this project because it is:

practical for local Ollama deployment
strong enough for short multi-step reasoning
suitable for privacy-sensitive scam training data
useful for both conversation and moderation-style feedback
accessible enough for schools, homes, and community workshops

This makes Gemma 4 more than a chatbot model inside the project. It sits inside the training loop: users interact with scenarios, agents respond, the recorder explains what happened, and the system turns the interaction into a learning experience.

What I Learned

1. Model choice should match deployment

A larger model is not automatically a better product choice. For anti-scam training, usability and local access matter just as much as model capability.

2. The model should be visible in the code

The Gemma 4 choice is reflected in environment variables, backend defaults, Docker configuration, and tests. That makes the setup reproducible and easy to verify.

3. Useful AI systems need more than generation

Anti-FraudX combines Gemma 4 with trust scoring, role-based simulation, local serving, and testable workflows. The value comes from the system design, not only from the base model.

4. Product value comes from context

The model alone is not the story. The real value comes from using Gemma 4 in a product that helps people make safer decisions under pressure. That is what turns the model into something meaningful for everyday users.

Why This Matters

Gemma 4 makes it possible to build tools that are not only smart, but also deployable, privacy-aware, and useful in real communities. That is why E4B was the right fit for Anti-FraudX.

The larger point is that local AI is not only about convenience. It is about trust. When conversations, training data, and scam examples can stay local, the system becomes easier to use in real environments where privacy and access are just as important as model quality.

Conclusion

Anti-FraudX needed a model that could support local inference, practical reasoning, and multimodal scam education without making deployment too heavy. Gemma 4 E4B fits that job well.

It is not just a model choice for a benchmark. It is the model choice that makes the product usable.

The project shows that open local models can do more than answer questions. They can help people build resilience before the moment of risk, and that makes them especially valuable in safety and education settings.