Entropy Radar

• 

• 

Inspiration

I looked at the current landscape of AI moderation tools and realized they all suffer from the "Janitor Problem." Existing tools (like standard automods or basic AI filters) judge comments in a vacuum. If a massive argument breaks out, these bots just fill the mod queue with 20 individual "Reported" comments. The moderator still has to wake up, read 20 isolated comments, piece together the context, and manually intervene. It doesn't stop moderator burnout; it just changes the chore. I wanted to build a tool that understands thread momentum and cultural context.

What it does

Entropy Radar is a thermodynamic threat-detection system built natively into Reddit.

The Velocity Sensor: It tracks the "heat" of a thread using a rolling 10-minute window. It doesn't care about isolated incidents; it looks for rapid, toxic escalation.

The Context Shield: Powered by multiple AI models. Choose the AI model of your choice and fill out the API key, the bot reads both the Official Subreddit Rules and a moderator-provided natural language description of Unwritten Rules & Inside Jokes filled out in the Entropy Radar dashboard. It knows the difference between a hostile insult and friendly gaming banter (e.g., "git gud" or "you play like a bot").

The Ephemeral Black Box: When the Context Shield detects genuine hostility, it temporarily logs the comment in a Redis-powered "Black Box." If the thread reaches the critical threshold, it packages all the evidence into a single, clean Modmail alert.

Self-Cleaning: The exact second the Modmail is dispatched (or if the thread cools down after 10 minutes), the Black Box purges itself to save server resources and prevent database bloat.

How we built it

built Entropy Radar using a dual-paradigm architecture. Instead of relying purely on high-level wrappers, I wanted to control the absolute lowest-level mechanics of the platform, so I wired a Hono web server directly into Reddit's native Devvit event bus.

The backend relies on an ephemeral Redis engine. When a comment is posted, it acts as a thermodynamic sensor, calculating the velocity of arguments by tracking "heat" over a rolling 10-minute window. To analyze the context of these arguments, I built a Multi-AI Switchboard. Instead of locking the app to one provider, the backend dynamically routes prompts to Gemini, OpenAI, Anthropic, or DeepSeek based on the subreddit's custom configurations. The frontend is powered by Vite, serving a responsive premium control panel that caches official subreddit rules directly into Redis to bypass Reddit's API rate limits.

Challenges we ran into

The biggest hurdle was the architectural clash between standard web server routing and serverless event triggers. I initially tried to bypass the Hono server completely to hook directly into the native event bus for speed, which essentially unplugged the bot's brain and broke the UI routing.

I also fought heavy battles with Devvit's strict schema compiler and esbuild path-flattening optimizations. I had to manually restructure the root entry files and rewrite the manifest (devvit.json) from scratch to force the local Node compiler to correctly map the Hono API routes to Reddit's frontend UI components without triggering security panics.

Accomplishments that we're proud of

Contextual Superiority: Successfully feeding both structured (official rules) and unstructured (inside jokes) data into the AI simultaneously, making it fundamentally smarter than generic word-filters. It also solves the user getting angry or frustrated just for posting some inside joke but generic AIs marking it as toxic or much worse, banning a user.

The Ephemeral Black Box: I am incredibly proud of the Redis self-cleaning architecture. It logs toxic escalation evidence perfectly, packages it for Modmail, and instantly deletes itself to save server memory and prevent database bloat.

The Switchboard Pattern: Building an AI-agnostic platform. Moderators aren't forced into one ecosystem; they can plug in whatever API key they prefer.

Automated Rules Caching: Solving the "Janitor Problem." The tool silently scrapes and caches the official subreddit rules the moment the mod configures the bot, meaning the AI knows the law without making latency-heavy network calls on every comment.

What we learned

I learned that building for a serverless platform requires a massive shift in how you handle state and routing. You can't rely on global variables or long-running processes; you have to treat every event as a highly isolated, ephemeral burst. I also learned the hard way how critical the manifest file is for bridging strict frontend security with backend network requests, and how to debug compiled .cjs files when the build pipeline breaks.

What's next for Entropy Radar

The next evolution is transitioning from reactive analysis to proactive threat intelligence by building

Brigade Attack Map: Entropy Radar won't just stop arguments—it will visually map out organized harassment campaigns and bot-likelihood clusters in real-time, offering moderators one-click surgical interventions like auto-locking specific comment branches before the brigade even gains a foothold.

The Thermodynamic Metrics: Right now, the tool tracks "Heat". To get "Velocity", just measure Heat over Time \(\frac{\Delta \text{Heat}}{\Delta \text{Time}}\) . We can calculate if a thread got 3 toxic comments in 10 minutes (Low Velocity) or 3 toxic comments in 45 seconds (High Velocity).

Visual Live Metrics Dashboard

Suggestions: remove one comment, warn one user, slow mode, auto-lock branch only.

Built With

• ai-api
• css3
• devvit
• hono
• html5
• redis
• typescript
• vite