Three Failure Stories First

When indie developers first add danmaku (bullet comment) filtering to a livestream, their approach is remarkably consistent: pick the strongest model on the leaderboard, write a prompt that says "You are a content moderator," hook up the API, and ship it. Then the problems start piling up.

Failure story one: A strong model can't keep up with danmaku speed. A streamer with thousands of concurrent viewers gets peak danmaku volumes of dozens per second. The developer picked a model with strong reasoning ability—a one- or two-second latency per message doesn't sound like much, but with queuing stacked on top, by the time the filtering result comes back, the danmaku has already drifted halfway across the screen. What viewers see is: violating content displays first, then vanishes into thin air seconds later—effectively giving the violating content a "second exposure."

Failure story two: A fast model lets sophisticated tricks slip through. After switching to a responsive small model, the speed problem was solved, but misjudgments became ridiculous. Homophones, character-splitting tricks, and variant violating content mixed with emoji and pinyin slipped through en masse; even worse, normal discussions kept getting falsely killed, viewers' chats kept getting swallowed, and the danmaku section went dead. Small models can recognize literal profanity, but their judgment on context and obfuscation really is limited.

Failure story three: One model forced to handle every scenario. Others just used the same model to handle danmaku, user report appeals, stream summaries, and sensitive-word dictionary update suggestions. The result: prompts grew longer and longer, costs climbed higher and higher, and any adjustment to one task could break the others. Model selection degraded from "which one fits" to "whichever is least bad."

The common root cause of all three failures: treating "fast" and "strong" as a binary choice, and treating "danmaku filtering" as a single task.

The Right Decomposition: Danmaku Filtering Isn't One Task—It's a Pipeline

Break it down calmly: real-time processing of livestream danmaku involves at least three types of work with completely different characteristics:

1. High-frequency initial screening: dozens of messages per second, requiring a "pass / suspicious" verdict within a few hundred milliseconds. Speed matters here; some false positives are tolerable.
2. Low-frequency review: suspicious danmaku flagged by the initial screening doesn't need an instant reply—you can spend one or two seconds on fine-grained judgment with a stronger model, where accuracy takes priority.
3. Offline analysis: after each stream ends, do violation pattern analysis, dictionary iteration, and appeal reviews. Latency is completely irrelevant here; only quality matters.

See it? The answer to "fast model or strong model" is: both—but each in its proper place.

Scenario Dimension Comparison

A few practical points:

• Be stingy with the initial screening prompt. Fast models have a tight token budget—keep the system prompt within two or three hundred tokens, and require output in a fixed format label (e.g., {"flag": "pass"}). Don't ask it to "explain its reasoning." Explanation is the review layer's job.
• The review layer is where strong models shine. This layer runs at low frequency (maybe only a few percent of danmaku get in), so even with the most expensive model, total cost stays manageable—yet the accuracy gains are the highest in the entire pipeline. Let it analyze variants, context, and homophones, and output structured conclusions and reusable rules.
• The offline layer's output must flow back. New variant patterns the strong model summarizes during review should be periodically consolidated into the initial screening's rules and word dictionaries, so the fast model's judgments get more accurate over time. This is the key feedback loop that makes the whole system "run better and better."

Why You Need a Unified Gateway

At the mention of layering, many developers' first reaction is: call Vendor A's API for initial screening, Vendor B's for review, and wrap two separate clients. That's fine at the demo stage, but after a few weeks in production you run into a pile of trouble:

• Two SDKs, two authentication setups, two retry implementations—and streaming behavior differs between them;
• When a model gets rate-limited or taken offline without warning, you're editing code and redeploying in the middle of the night;
• Want to do canary testing—say, shifting 10% of traffic to a new model to compare results? Without a unified request entry point, you can't even start;
• Cost attribution becomes a mess: how much did Stream Room A versus Stream Room B spend, how much went to screening versus review—the billing is one big muddle.

This is exactly where a unified gateway delivers value: all requests go through a single entry point, and model identity becomes just a string in your configuration. Initial screening uses the fast model, review uses the strong model—they're just different routing rules. If a fast model is having a bad day, changing one line of config switches everything to a fallback without touching business code. All requests naturally carry unified structured logs, so costs, latency, and false-positive rates for screening and review can be tracked separately.

For small teams, this reduces "multi-model strategy" from a code problem to a configuration problem. All the thinking you did upfront on layering—which layer goes fast, which goes strong, how to set thresholds—can be quickly validated and adjusted through the gateway, instead of going through a full release process every time. Livestream scenarios are especially demanding on stability (when something breaks, the streamer is live), and having a channel that can switch models in seconds is itself a form of insurance.

An Actionable Path

If you're about to get started, I recommend this order:

1. Build only the initial screening layer first; get the full pipeline running with a fast model and confirm latency meets the bar;
2. Add the review layer; flagged danmaku goes to the strong model, and record where the two layers' verdicts differ;
3. Launch offline analysis, and consolidate review conclusions back into initial screening rules;
4. Use the gateway logs to view per-layer data, then decide which stream rooms and time slots need ratio adjustments.

Danmaku filtering has no "pick one model" answer—only a "build a pipeline" answer. And once you start building that pipeline, a gateway that offers unified access with on-demand model switching makes every adjustment much lighter.

If you're looking for this kind of integration approach, you can register and try it out first at https://api.thistoken.ai/register to get your layered strategy running.

---

Tired of juggling provider integrations? Register at https://api.thistoken.ai/register and call every model through one base_url.