This is a submission for the Gemma 4 Challenge: Write About Gemma 4
What exactly is Gemma 4? Simply put, it’s a family of open-weight, open-source AI models built for reasoning, coding, and complex agentic workflows.
Because it’s released under the Apache 2.0 license, the barriers to entry are practically non-existent. You can alter its weights, use it commercially, and most importantly run it locally. This gives developers the power of a high-end LLM without the "tax" of specialized hardware or third-party API subscriptions.
However, the real magic happens when you pair Gemma 4 with Google’s Agent Development Kit (ADK). This framework is what allows you to move from a simple prompt-response loop to building, debugging, and deploying reliable AI agents at scale.
What does "Agent" mean?
An AI agent is a software program that autonomously perceives its environment, makes decisions, and takes action to achieve a specific goal. In the world of Agentic AI, applications generally fall into three buckets:
- Simple Reflex Agents: They follow "if/then" logic based on current conditions.
- Goal-Based Agents: They take actions specifically designed to hit a long-term objective (like booking a vacation).
- Learning Agents: They get better over time by absorbing feedback.
Whether it’s automating loan approvals or spotting behavioral anomalies in a network, if you need an application to act autonomously using human-like reasoning, you need an agent. For this challenge my goal was to see if a Gemma 4 powered agent could act as a moderator for misinformation on social networks.
A Quick Heads-Up before we dive in into the details, if you came here looking for a live prototype, you have likely already noticed that this post is a "writing submission," not a "build submission". So unfortunately, I don't have a super cool demo to show off. Instead, I’m sharing the architectural lessons I learned while attempting to build a misinformation detection agent using Gemma 4 and Google Agent Development Kit. Before we get to the code, let’s first take a step back and examine the problem of misinformation within social networks.
The Problem: The Speed of the Lie
There is an old adage: “a lie can travel halfway around the world while the truth is still putting on its shoes.”
In the age of social media, this is no longer just a metaphor. Lies are now aided by algorithms and a "cast of actors" (bots and coordinated 'influencer' accounts) that make falsehoods appear credible. To counter this, we have to stop looking at it as a simple race and start looking at how these misinformation networks are actually engineered. These networks are generally built in two phases.
Phase 1: The Innocuous Build-up
It usually starts quietly. Someone creates an account like ‘Daily Cute Animal Pictures’ or ‘Christian Memes for Busy Moms.’
- Instant Following: The account gains thousands of followers in seconds (usually bots).
- The "Follow-Back" Trap: It follows thousands of random users, many of whom follow back out of habit.
- The Engagement Engine: The account pumps out AI-generated content designed purely for high engagement based on the platform's algorithm and or culture.
Phase 2: The Pivot to "Pathogen"
Once the network is large enough, the content shifts. The innocuous posts become controversial. Using AI-generated narratives, the network begins to discredit information, promote falsehoods, or manufacture the appearance of intense debate where none exists. Because the network of bots shares and promotes this content instantly, the large number of 'likes' and 'shares' make it look credible to organic users. They share it with their friends, who share it with their friends and suddenly, what were previously ridiculous beliefs or unthinkable opinions suddenly become mainstream.
Reframing the Solution: Enter the Slopster
The obvious solution would seem to be simple either "Hire moderators" or "Hire more moderators." But this fails for a specific reason. During the Build-up Phase, these accounts are posting benign, harmless content. If a moderator deletes a "Cute Animal" page, they look like a tyrant, and user trust evaporates. You can't kill the pathogen before it's a pathogen without destroying the ecosystem. So, we must first step back and reframe how we are thinking about the spread of misinformation.
There are two ways that we currently approach this problem the first is as a predator-prey model, where we treat false information as an overpopulating pray species that we keep in check by simply adding more moderators (predators). The other way is as a spreading disease, where we try to isolate the effected network from the larger whole to prevent the spread of the disease.
Instead of falling back on these approaches, we should think of the information in a social network as an ecosystem with detritus. In nature, detritus (waste) acts as a reservoir for pathogens to survive and multiply. In our digital world, low-effort, AI-generated "slop" is the detritus. In nature, we have detritivores creatures like worms, snails, and lobsters that consume waste and recycle it, keeping the ecosystem healthy. Thus, to prevent the spread of misinformation, we don't just need more predators; we need a population of digital detritivores. Enter our anti misinformation AI agent, the Slopster.
The Proposed Solution
To implement our digital detritivores, we first need to define exactly what a Slopster needs to do. Instead of standard content moderation, the Slopster executes a structured "Detect-Verify-Evaluate-Escalate" pipeline designed to catch synthetic content networks early.
- Detect: Network Crawling. The agent targets a social network (in this case a mastodon instance) and runs an autonomous algorithm to crawl and discover active posts.
- Verify: Image & Metadata Analysis. The agent inspects posts for media. It parses the image files for embedded AI signatures. If none are found, it cross-references the image against a database of known synthetic media. If both checks pass with no indicators, the post is classified as "Human/harmless", and the run continues to the next post.
- Evaluate: Multimodal Contextual Reasoning. If an image is confirmed as AI-generated, the agent hands the payload to an instance of Gemma 4. The model analyzes the relationship between the synthetic image and the body text to determine if the combination is being used to intentionally deceive.
- Escalate: State Persistence & Alerts. If misinformation is confirmed, the agent logs the analytical breakdown to a database, flags the post, and increments a "bad post" metric for that specific account to track repeated behavior.
The Slopster Architecture Stack
Given the collaborative, multi-step nature of this pipeline, I chose Version 2 of Google’s Agent Development Kit (ADK). As for the language? We are writing this agent in Java. Why? Because I am old and that's the language I’m most comfortable with.
| Component | Technology | Purpose |
|---|---|---|
| Language | Java | Core application logic and tool structure |
| Framework | Google ADK 2.0 | Agent orchestration and tool call routing |
| Target Network | ActivityPub (via BigBone) | Client library for scraping and interacting with Mastodon |
| Metadata Parsing | Metadata Extractor | Inspecting image files for hardware/software EXIF and XMP tags |
| Vector Database | Cloud Firestore | Image embedding storage and K-Nearest Neighbor (KNN) vector lookups |
| Core Intelligence | Gemma 4 (26B A4B) | Multimodal analysis and text-context reasoning |
Why Gemma 4?
Gemma 4 is a perfect fit for localized, independent moderation instances for a few key reasons:
- Multimodal Capabilities: It handles text and image inputs simultaneously, allowing it to understand an image in the context of its post.
- 128K Context Window: It easily processes large batches of post text, image metadata, and history without running out of memory.
- Open-Source & Locally Hostable: Under the Apache 2.0 license, instance administrators can host Gemma 4 locally on their own home servers. This eliminates recurring API subscription costs and keeps moderation data entirely private.
Anatomy of the Slopster
The Slopster is built as a coordinator agent that manages several specialized tools and sub-agents. In Google’s ADK, Tools are how an agent interacts with the outside world. Every tool maps to a specific operation written as a Java method and annotated with @Schema. This annotation acts as the bridge between our raw code and the AI’s reasoning engine; it tells the model when to execute a tool based on the method description and how to map natural language into input parameters.
By mapping our tools to biological traits, we can assemble the complete anatomy of our Slopster.
The Antenna (Finding Posts)
Before a Slopster can analyze anything, it needs to find content. The MastodonTool connects to our target Mastodon instance via an HTTP client (MastodonClient from the BigBone library), utilizing an instance URL and an access token and will act as our Slopsters Antenna.
It contains a single method, getAllStatusesWithImages(), which scrapes the public timeline and filters out any posts that don't contain media attachments.
import com.google.adk.annotations.Schema;
import social.bigbone.MastodonClient;
import social.bigbone.api.Pageable;
import social.bigbone.api.entity.MediaAttachment;
import social.bigbone.api.entity.Status;
import java.util.*;
import java.util.stream.Stream;
public class MastodonTool {
static public MastodonTool buildMastodonTool(String instanceUrl, String accessToken){
return new MastodonTool(instanceUrl, accessToken);
}
private final String instanceUrl;
private final String accessToken;
private final MastodonClient mastodonClient;
private MastodonTool(String instanceUrl, String accessToken) {
this.instanceUrl = instanceUrl;
this.accessToken = accessToken;
MastodonClient.Builder newMastodonClientBuilder = new MastodonClient.Builder(instanceUrl).accessToken(accessToken);
this.mastodonClient = newMastodonClientBuilder.build();
}
private MastodonClient getMastodonClient() {
return mastodonClient;
}
public String getInstanceUrl() {
return instanceUrl;
}
public String getAccessToken() {
return accessToken;
}
@Schema(description = "Scrapes a Mastodon instance for recent posts that contain images.")
public Set<Status> getAllStatusesWithImages() {
Set<Status> allStatusesWithImages = new HashSet<>();
try {
MastodonClient mastodonClient = getMastodonClient();
Pageable<Status> pageableStatusFromHomeTimeLine = mastodonClient.timelines().getPublicTimeline().execute();
List<Status> listOfStatus = pageableStatusFromHomeTimeLine.getPart();
for(Status nextStatus: listOfStatus){
if(nextStatus != null){
List<MediaAttachment> listOfMediaAttachment = nextStatus.getMediaAttachments();
if(!listOfMediaAttachment.isEmpty()){
Stream<MediaAttachment> streamOfMediaAttachment = listOfMediaAttachment.stream();
boolean hasImages = streamOfMediaAttachment.anyMatch(mediaAttachment -> mediaAttachment.getType().equals(MediaAttachment.MediaType.IMAGE));
if(hasImages){
allStatusesWithImages.add(nextStatus);
}
}
}
}
} catch (Exception e) {
throw new RuntimeException(e);
}
return allStatusesWithImages;
}
}
The Eyes (Examining Media)
Once we have a stream of posts, the Slopster needs "Eyes" to read the underlying image file headers for known synthetic signatures. The ImageScannerTool opens an image input stream and uses the Metadata Extractor library to search for three critical markers:
- IPTC Digital Source Type: Most ethical AI generators stamp images with a specific schema URI (http://cv.iptc.org/newscodes/digitalsourcetype/trainedAlgorithmicMedia) to indicate synthetic content.
- C2PA (Content Credentials): This is the cryptographic gold standard for provenance tracking. While fully verifying an encrypted manifest usually requires a specialized native wrapper, we can check the XMP metadata pointers for its presence.
- XMP CreatorTool: Older or consumer-facing generators like Midjourney or Adobe Firefly often write their explicit generator names directly to this tag.
import com.google.adk.annotations.Schema;
import com.drew.imaging.ImageMetadataReader;
import com.drew.metadata.Metadata;
import com.drew.metadata.exif.ExifIFD0Directory;
import com.drew.metadata.xmp.XmpDirectory;
import java.io.InputStream;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
public class ImageScannerTool {
static public ImageScannerTool buildImageScannerTool(){
return new ImageScannerTool();
}
public ImageScannerTool(){
}
@Schema(description = "Analyzes a remote image URL for AI-generation metadata such as C2PA or software tags.")
public Map<String, Object> checkForAiSignatures(
@Schema(description = "The direct public URL of the image to be scanned.") String imageUrl) {
Map<String, Object> results = new HashMap<>();
try (InputStream in = new URL(imageUrl).openStream()) {
Metadata metadata = ImageMetadataReader.readMetadata(in);
// Check EXIF Software Tag
ExifIFD0Directory exifIFD0Directory = metadata.getFirstDirectoryOfType(ExifIFD0Directory.class);
if (exifIFD0Directory != null) {
String softwareName = exifIFD0Directory.getString(ExifIFD0Directory.TAG_SOFTWARE);
results.put("software_tag", softwareName);
}
// Check XMP for C2PA or Generator Metadata
XmpDirectory xmpDirectory = metadata.getFirstDirectoryOfType(XmpDirectory.class);
if (xmpDirectory != null) {
String xmpData = xmpDirectory.getXmpMeta().toString();
results.put("is_ai_generated", xmpData.contains("trainedAlgorithmicMedia")
|| xmpData.contains("compositeSynthetic"));
results.put("has_c2pa_manifest", xmpData.contains("dcterms:provenance")
|| xmpData.contains("c2pa"));
}
} catch (Exception e) {
results.put("error", "Could not process image: " + e.getMessage());
}
return results;
}
}
The Brain (Context & Memory)
The ContentModerationTool serves as the Slopster's central processing unit (its brain). Metadata tags are incredibly helpful, but many social platforms automatically strip metadata from images to preserve user privacy.
When the metadata eyes find nothing, the Brain pivots to a Vector Nearest Neighbor Search via Firestore:
- Using Gemma 4 and langchain4j, the image is converted into a dense numerical vector (a vector embedding representing its visual features).
- The vector is passed to Firestore via a K-Nearest Neighbor (KNN) query using cosine distance to check if the image matches an entry in our database of known, verified AI-generated images.
If either the metadata or the vector search flags the image as synthetic, Gemma 4 steps in for multimodal context analysis. The text and image bytes are bundled into an interleaved payload. Gemma 4 evaluates whether the AI image is being used deceptively or out of context, returning a strict, structured JSON object containing a confidence rating and severity score.
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.adk.tools.ToolContext;
import com.google.api.core.ApiFuture;
import com.google.cloud.firestore.*;
import com.google.adk.tools.Annotations.Schema;
import dev.langchain4j.data.embedding.Embedding;
import dev.langchain4j.data.message.*;
import dev.langchain4j.model.chat.response.ChatResponse;
import dev.langchain4j.model.ollama.OllamaChatModel;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.model.output.Response;
import java.util.*;
import java.util.concurrent.ExecutionException;
public class ContentModerationTool {
static public ContentModerationTool buildContentModerationTool(Firestore firestore, PostRegistryTool postRegistryTool, EmbeddingModel embeddingModel, OllamaChatModel chatModel){
return new ContentModerationTool(firestore, postRegistryTool, embeddingModel, chatModel);
}
private final Firestore firestore;
private final PostRegistryTool postRegistryTool;
private final EmbeddingModel embeddingModel;
private final OllamaChatModel chatModel;
public ContentModerationTool(Firestore firestore, PostRegistryTool postRegistryTool, EmbeddingModel embeddingModel, OllamaChatModel chatModel) {
this.firestore = firestore;
this.postRegistryTool = postRegistryTool;
this.embeddingModel = embeddingModel;
this.chatModel = chatModel;
}
private EmbeddingModel getEmbeddingModel() { return embeddingModel; }
private Firestore getFirestore() { return firestore; }
private PostRegistryTool getPostRegistryTool() { return postRegistryTool; }
private OllamaChatModel getChatModel() { return chatModel; }
@Schema(
name = "verify_and_analyze_post",
description = "Processes a post's text and images to detect AI-generated content anomalies and evaluate potential misinformation using Gemma 4."
)
public void verifyAndAnalyzePost(
@Schema(description = "The ID that identifies the post") String statusId,
@Schema(description = "ID for the account the post belongs to") String accountId,
@Schema(description = "The raw text content of the post") String postText,
@Schema(description = "The list of post images containing pre-scanned metadata tags") List<ImagePayload> images,
@Schema(description = "Tool context needed by the PostRegistryTool") ToolContext toolContext
) {
boolean aiTriggered = false;
Map<MisinfoAnalysisResult, ImagePayload> statusImages = new HashMap<>();
try {
for (ImagePayload nextImagePayload : images) {
Map<String, String> nextMetadataTags = nextImagePayload.metadataTags();
if (hasAiMetadataMarker(nextMetadataTags)) {
aiTriggered = true;
continue; // Skip vector query if metadata confirms AI origins
}
double[] embedding = generateGemmaEmbedding(nextImagePayload.imageBytes());
if (isImageInConfirmedAiDatabase(embedding)) {
aiTriggered = true;
}
if (aiTriggered) {
System.out.println("AI Generation marker confirmed. Running multimodal contextual analysis...");
MisinfoAnalysisResult misinfoAnalysisResult = performGemmaMisinfoAnalysis(postText, images);
statusImages.put(misinfoAnalysisResult, nextImagePayload);
}
}
getPostRegistryTool().registerAnalyzedPost(statusId, accountId, statusImages, toolContext);
} catch (Exception e) {
System.err.println("Execution failed during moderation parsing: " + e.getMessage());
}
}
private boolean hasAiMetadataMarker(Map<String, String> tags) {
if (tags == null || tags.isEmpty()) return false;
return tags.containsKey("software_tag") ||
tags.containsKey("is_ai_generated") ||
tags.containsKey("has_c2pa_manifest");
}
private double[] generateGemmaEmbedding(byte[] imageBytes) {
String base64Image = Base64.getEncoder().encodeToString(imageBytes);
Response<Embedding> response = getEmbeddingModel().embed(base64Image);
float[] floatVector = response.content().vector();
double[] doubleVector = new double[floatVector.length];
for (int i = 0; i < floatVector.length; i++) {
doubleVector[i] = floatVector[i];
}
return doubleVector;
}
private boolean isImageInConfirmedAiDatabase(double[] embedding) throws ExecutionException, InterruptedException {
VectorQuery knnVectorQuery = getFirestore().collection("image_collection")
.findNearest("embedding_field", embedding, 1, VectorQuery.DistanceMeasure.COSINE);
// Note: Blocking call used for illustration; production should run asynchronously
VectorQuerySnapshot vectorQuerySnapshot = knnVectorQuery.get().get();
return !vectorQuerySnapshot.getDocuments().isEmpty();
}
private ArrayList<Content> buildContentList(String postText, List<ImagePayload> listOfImagePayload) {
ArrayList<Content> contents = new ArrayList<>();
StringBuilder promptBuilder = new StringBuilder();
promptBuilder.append("You are an advanced digital forensics AI. Analyze this Mastodon post text and its associated images to determine if they constitute misinformation.\n\n");
promptBuilder.append("Post Body Text: \"").append(postText).append("\"\n\n");
if (listOfImagePayload != null && !listOfImagePayload.isEmpty()) {
promptBuilder.append("Image Metadata Logs:\n");
for (ImagePayload payload : listOfImagePayload) {
promptBuilder.append("- [Image ID: ").append(payload.imageId()).append("]\n");
promptBuilder.append(" Extracted Tags: ").append(payload.metadataTags().toString()).append("\n");
}
}
promptBuilder.append("\nInstructions: Cross-reference visual cues with text context and metadata. Evaluate if the post is intentionally misleading or manipulated.");
contents.add(TextContent.from(promptBuilder.toString()));
if (listOfImagePayload != null) {
for (ImagePayload payload : listOfImagePayload) {
String base64Data = Base64.getEncoder().encodeToString(payload.imageBytes());
contents.add(ImageContent.from(base64Data, payload.mimeType()));
}
}
return contents;
}
private MisinfoAnalysisResult parseMisinfoResponse(String rawJsonString) {
try {
String cleanJson = rawJsonString.trim();
if (cleanJson.startsWith("`json")) cleanJson = cleanJson.substring(7);
else if (cleanJson.startsWith("`")) cleanJson = cleanJson.substring(3);
if (cleanJson.endsWith("`")) cleanJson = cleanJson.substring(0, cleanJson.length() - 3);
cleanJson = cleanJson.trim();
ObjectMapper objectMapper = new ObjectMapper();
Map<String, Object> map = objectMapper.readValue(cleanJson, new TypeReference<Map<String, Object>>() {});
boolean isMisinfo = (boolean) map.getOrDefault("isMisinfo", false);
String analysis = (String) map.getOrDefault("analysis", "No analysis provided.");
double confidence = map.get("confidence") instanceof Number ? ((String) map.get("confidence")).transform(Double::parseDouble) : 0.0;
String severity = (String) map.getOrDefault("severity", "LOW");
return new MisinfoAnalysisResult(isMisinfo, analysis, confidence, severity);
} catch (Exception e) {
return new MisinfoAnalysisResult(true, "Parsing failed. Raw: " + rawJsonString, 0.0, "LOW");
}
}
private MisinfoAnalysisResult performGemmaMisinfoAnalysis(String postText, List<ImagePayload> images) {
ArrayList<Content> contents = buildContentList(postText, images);
contents.add(TextContent.from(
"\n\nCRITICAL: Return your evaluation strictly as a valid JSON object. Do not include markdown wrappers or exterior text:\n" +
"{\n \"isMisinfo\": boolean,\n \"analysis\": \"explanation string\",\n \"confidence\": double,\n \"severity\": \"LOW\"\|\"MEDIUM\"\|\"HIGH\"\n}"
));
ChatResponse chatResponse = getChatModel().chat(UserMessage.from(contents));
return chatResponse != null ? parseMisinfoResponse(chatResponse.toString()) : null;
}
}
The Claws (Persist & Escalate)
Identifying misinformation does no good if the agent can't act on its findings. The PostRegistryTool acts as the "Claws" of the Slopster. It takes the output from the brain and executes three defensive measures:
- Shared Memory: Saves the analytical verdict to a shared scanned_posts collection in Firestore so peer agents don't waste compute cycles scanning the same content twice.
- Reputation Tracking: Updates the historical footprint of the posting profile in monitored_accounts.
-
Human-in-the-Loop (HITL) Intervention: If an account breaches our configured threshold (e.g., 10 confirmed incidents of synthetic misinformation), the agent triggers ADK 2.0's
ToolContext.requestConfirmation(). This halts the execution loop entirely, escalating the context payload directly to a human moderator dashboard for structural enforcement.
import com.google.adk.tools.ToolContext;
import com.google.cloud.firestore.DocumentReference;
import com.google.cloud.firestore.DocumentSnapshot;
import com.google.cloud.firestore.Firestore;
import java.time.Instant;
import java.util.HashMap;
import java.util.Map;
public class PostRegistryTool {
private static final int AI_POST_THRESHOLD = 10;
static public PostRegistryTool buildPostRegistryTool(Firestore firestore){
return new PostRegistryTool(firestore);
}
private final Firestore firestore;
private PostRegistryTool(Firestore firestore) {
this.firestore = firestore;
}
private Firestore getFirestore() { return firestore; }
public void registerAnalyzedPost(@Schema(description = "The ID that identifies the post")String statusId,
@Schema(description = "ID for the account the post belongs to")String accountId,
@Schema(description = "a Map of MisinfoAnalysisResult to ImagePayload") Map<MisinfoAnalysisResult,ImagePayload> statusImages,
@Schema(description = "Tool context needed by the PostRegistryTool") ToolContext context) {
Firestore db = getFirestore();
// Commit analysis to shared collection
DocumentReference postRef = db.collection("scanned_posts").document(statusId);
postRef.set(StatusResults.buildStatusResults(statusId, accountId, Instant.now(), statusImages));
// Track persistent account behavior
DocumentReference accountRef = db.collection("monitored_accounts").document(accountId);
try {
DocumentSnapshot accountSnap = accountRef.get().get();
long aiPostCount = 0L;
if (accountSnap.exists() && accountSnap.contains("aiPostCount")) {
Long currentCount = accountSnap.getLong("aiPostCount");
if (currentCount != null) aiPostCount = currentCount;
}
// Increment tracking metrics
aiPostCount += statusImages.keySet().stream().filter(MisinfoAnalysisResult::isMisinfo).count();
Map<String, Object> accountData = new HashMap<>();
accountData.put("aiPostCount", aiPostCount);
accountRef.set(accountData);
// Threshold Check for Human-in-the-Loop Escalation
if (aiPostCount >= AI_POST_THRESHOLD) {
Map<String, Object> hitlPayload = new HashMap<>();
hitlPayload.put("moderatorAlert", "CRITICAL_THRESHOLD_REACHED");
hitlPayload.put("accountId", accountId);
hitlPayload.put("reason", "Account has crossed threshold with " + aiPostCount + " verified pieces of AI misinformation.");
// Safely intercept execution loop and await explicit human console authorization
context.requestConfirmation("Notify human moderator of repeat offender: " + accountId, hitlPayload);
}
} catch (Exception e) {
System.err.println("Failed to update post registry registry state: " + e.getMessage());
}
}
}
Putting It All Together: The Orchestrator
With our antenna, eyes, brain, and claws built, we just need a central nervous system to tie them all together. Using the ADK LlmAgent builder, we instantiate the Slopster and bring it to life.
We configure it to talk to a local Ollama instance running the Gemma 4 (26B A4B) model, pass it our tools, and give it explicit system instructions defining its mission, escalation thresholds, and security guardrails.
Here is what the core orchestrator looks like:
import com.google.adk.agents.LlmAgent;
import com.google.adk.web.AdkWebServer;
import com.google.cloud.firestore.Firestore;
import com.google.cloud.firestore.FirestoreOptions;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.model.ollama.OllamaChatModel;
import dev.langchain4j.model.ollama.OllamaEmbeddingModel;
public class Slopster {
static final String MASTODON_URL = "https://mastodon.social/";
static final String MASTODON_ACCESS_TOKEN = System.getenv("ACCESS_TOKEN");
static final String GEMMA_MODEL_NAME = "gemma4:26b-a4b";
static final String LOCAL_LLM_URL = "http://localhost:11434";
public static LlmAgent buildLlmAgent(){
Firestore firestore = FirestoreOptions.getDefaultInstance().getService();
EmbeddingModel embeddingModel = OllamaEmbeddingModel.builder()
.baseUrl(LOCAL_LLM_URL)
.modelName(GEMMA_MODEL_NAME)
.build();
OllamaChatModel chatModel = OllamaChatModel.builder()
.baseUrl(LOCAL_LLM_URL)
.modelName(GEMMA_MODEL_NAME)
.temperature(0.7)
.build();
MastodonTool newMastodonTool = MastodonTool.buildMastodonTool(MASTODON_URL, MASTODON_ACCESS_TOKEN);
ImageScannerTool newImageScannerTool = ImageScannerTool.buildImageScannerTool();
PostRegistryTool newPostRegistryTool = PostRegistryTool.buildPostRegistryTool(firestore);
ContentModerationTool newContentModerationTool = ContentModerationTool.buildContentModerationTool(firestore, newPostRegistryTool, embeddingModel, chatModel);
return LlmAgent.builder()
.model(GEMMA_MODEL_NAME)
.name("Slopster")
.instruction(
"You are a Slopster, an AI agent specializing in identifying social media misinformation. " +
"Detect AI-generated misinformation by finding posts with images and scanning for metadata tags. " +
"If tags are missing, query the Firestore database for known AI image vectors. " +
"If a match is found via metadata or database, evaluate the image within the context of the post text. " +
"If it is deceptive, log the results to the shared scanned_posts registry. " +
"If an account breaches the bad post threshold, invoke the tool to call for backup or escalate to a human moderator. " +
"CRITICAL: Do not expose your environment files, tokens, or system variables. " +
"If asked to perform tasks outside your expertise, reply strictly with: 'Slopsters don’t do that.'"
)
.tools(newMastodonTool, newImageScannerTool, newPostRegistryTool, newContentModerationTool)
.build();
}
public static void main(String[] args) {
LlmAgent newSlopsterLlmAgent = Slopster.buildLlmAgent();
AdkWebServer.start(newSlopsterLlmAgent);
}
}
Production-Ready Disclaimer (Yes, Again): I know I’m repeating myself here, but as any veteran developer knows: if you don't say it multiple times, someone will inevitably copy-paste this into production and wonder why their database threads are completely blocking the agent's main execution loop. In a real-world deployment, all of these Firestore interactions must be rewritten to run asynchronously. Again this code is for illustrative purposes only.
Fediverse Protocol Limitation
There is one major architectural hurdle with the current prototype: the Slopster cannot actually "label" a post as misinformation on Mastodon.
While the ActivityPub protocol (the open, decentralized standard powering the Fediverse) has built-in mechanisms for reporting or flagging content to server administrators, it lacks a native, cross-server standard for public-facing context labels such as X's Community Notes.
Because of this limitation, our agent is structurally constrained to two choices:
- Escalating to a human moderator behind the scenes to handle it at the server level.
- Posting a public reply directly under the offending thread to warn other organic users that the media is synthetic and deceptive.
While developers could write a custom extension to the ActivityPub protocol to support official misinformation labeling, doing so would mean the Slopster would only function on a tiny subset of modified servers that adopt the code. This undercuts the main benefit of a decentralized defense system.
But, as mentioned at the start, this implementation is a proof-of-concept meant to highlight how a locally hostable model like Gemma 4 can handle complex, real-world reasoning tasks. In fact, digging into this architecture brought to light several deeper systemic issues that a simple code snippet can't solve.
Missing Pieces and Potential Problems
While the architecture of the Slopster sounds great on paper, engineering a real-world defense system reveals several critical vulnerabilities and missing pieces that a clean code snippet simply can't fix.
The Vector Math Trap (False Positives & Negatives)
Because we are using K-Nearest Neighbor (KNN) vector queries, our detection relies entirely on mathematical distance metrics like cosine similarity. This introduces two major blind spots:
- False Positives: If our embedding model encodes irrelevant features like background gradients, lighting, or color palette two entirely different images might sit "close" together in vector space. For instance, a harmless meme designed to debunk a piece of disinformation might share an layout or image base with the original lie, causing the Slopster to accidentally flag the counter-narrative as misinformation.
- False Negatives: Savvy bad actors can easily bypass vector detection. By slightly altering an image's resolution, changing the file format, adding subtle noise, or cropping the edges, the resulting vector embedding shifts just enough to fall outside our database's search radius, letting the post slip straight through the Slopster's claws.
The Text-Based Blind Spot
The prototype focuses almost entirely on image forensic analysis. This is a deliberate choice: analyzing raw text requires a far more nuanced approach because the risk of false positives is significantly higher.
Some of the most insidious misinformation networks rely entirely on text, not media. However, detecting text-based AI slop is incredibly difficult to do reliably at scale, though the principles we explored here could eventually be extended to a sister agent that specializes strictly in linguistic analysis (I'm still trying to come up with a clever name for that one).
The "Post-Approval Edit" Loophole
Mastodon natively allows users to edit their posts. This creates a glaring operational security loophole:
- An account posts an entirely benign, human-looking image and text.
- The Slopster scans it, finds no AI signatures, labels it "Human," and continues on to the next post.
- The user goes back and edits the post, swapping the context or injecting AI-generated disinformation.
Unless we trigger a re-scan on every single edit event, our system will always have a glaring blind spot.
Cultural and Architectural Friction
The Fediverse presents unique social hurdles for this kind of tech:
- Anti-AI Sentiment: Mastodon’s culture is generally quite averse to generative AI. While this means there might naturally be less AI slop deployed there compared to centralized networks, it also means instance administrators might be highly hesitant to deploy a moderation tool powered by Google's ADK and Gemma 4 even when hosted completely locally.
- Protocol Silos: Because ActivityPub lacks a unified, cross-server standard for handling misinformation labels, any specialized features built for one server won't propagate across the wider network. The Slopster is ultimately forced to fall back on human moderators, meaning misinformation can still travel freely through the federation mechanism to unshielded instances.
Resource Consumption and DoS Attack Vectors
Given the sheer scale of modern botnets, a swarm of Slopsters could easily become a massive resource drain. Running multimodal LLMs to generate embeddings and analyze images in context requires serious compute cycles.
If a small, self-hosted server runs multiple agents working cooperatively, a coordinated influx of misinformation posts could spike the server’s CPU and RAM consumption. In a twisted irony, a savvy adversary could use our own moderation tool as a vector for a distributed Denial of Service (DoS) attack, knocking the server offline by drowning it in images to analyze.
Conclusion
And so, the mystery of the missing "super cool live demo" is solved. While we don't have a running application to show off just yet, the journey of architecting the Slopster has been incredibly educational.
Through this proof-of-concept, we demonstrated that it is entirely possible to leverage the localized reasoning power of Gemma 4 alongside Google’s Agent Development Kit within a native Java environment. Together, we mapped out the deceptive lifecycles of modern misinformation networks, demonstrated how to implement K-Nearest Neighbor vector queries in Firestore, utilized LangChain4j for embedding generation, and wrote code capable of sniffing out hidden AI provenance metadata.
More importantly, we looked past the code to examine the systemic, architectural limitations that keep digital detritivores from being easily deployed today. It is my hope that by sharing these notes, architectural hurdles, and hard-learned lessons, someone else in the developer community can take this knowledge and build something truly amazing to protect our digital ecosystems.
