Musubi Release PolicyLM-1.7B, an Open-Weight Content Policy Classifier Under 100ms

Musubi has released PolicyLM-1.7B, a 1.7-billion-parameter open-weight AI model designed to moderate content against a platform’s own written policies in real time. Unlike conventional moderation classifiers that rely on fixed categories and large language models that generate text-based judgments, PolicyLM returns scores for policy categories directly, allowing platforms to make moderation decisions without generating a written response.

The model is designed for environments such as live chats, game lobbies, comments, direct messages and usernames, where moderation decisions need to happen before a conversation or interaction moves forward. Musubi says PolicyLM-1.7B can evaluate short messages in under 100 milliseconds, with its reported median latency reaching 35 milliseconds on an NVIDIA L4 GPU and 22 milliseconds on an H100 under its benchmark conditions.

Key takeaways

• Musubi has released PolicyLM-1.7B as an open-weight moderation model.
• It has 1.7 billion parameters and is licensed under Apache 2.0.
• The model reads a platform’s custom policy at inference time, rather than relying solely on fixed categories learned during training.
• Musubi reports a 35ms median latency on an NVIDIA L4 for short messages with up to six categories.
• On an H100, the model’s reported median latency is 22ms under the same six-category benchmark.
• It can return scores for multiple moderation categories in one pass.
• It was evaluated on 19 languages, although English performed strongest.
• It can run on a 24GB GPU, laptop CPU or Apple silicon, according to Musubi’s model card.
• The company says a custom fine-tuned version is already running on a platform handling more than 1 million messages per day.
• The model has important limitations: it is text-only, does not use conversation history and has not yet been tested on live traffic in Musubi’s published benchmark.

What is PolicyLM-1.7B?

PolicyLM-1.7B is a specialized content moderation model from Musubi, a trust and safety company focused on content, account and AI moderation.

Its core idea is different from the traditional approach to moderation.

A conventional classifier is usually trained to recognize a predefined set of categories. For example, a platform might train a system to detect harassment, violence, spam or sexual content.

That approach can be extremely fast, but it creates a problem when the platform changes its rules.

If a company introduces a new definition of harassment or creates a specialized category for its own community, it may need new training data and another model-training cycle.

PolicyLM is designed to make the policy itself part of the model’s input.

A platform can describe its moderation categories and rules in plain language and provide that policy alongside the message being evaluated. The model then produces a score between 0 and 1 for each category.

This means the policy can change without requiring the underlying model to be retrained.

The problem Musubi is trying to solve

Content moderation has traditionally involved a trade-off between speed and flexibility.

Fast classifiers can process huge amounts of content, but they tend to be tied to the categories they were trained on.

Large language models have much greater flexibility. They can read detailed rules and make judgments based on a company’s specific policy.

The problem is latency and cost.

Using a large general-purpose model to inspect every message in a busy social network or gaming platform could be unnecessarily expensive and slow.

Musubi’s approach is to build a smaller decision model specifically for this type of task.

Instead of asking the model to explain its decision, the system produces structured scores.

That distinction is important.

A chatbot might respond:

“This message appears to violate the platform’s harassment policy because…”

PolicyLM does not need to generate that explanation.

It can instead provide a numerical score indicating how strongly the message matches the specified category.

A separate threshold can then determine whether the message should be allowed, flagged, blocked or escalated.

Why the model can be so fast

PolicyLM-1.7B is designed as a decision model rather than a text-generation model.

It does not need to generate a paragraph explaining its reasoning.

Musubi says the model evaluates the policy and message together and returns scores for the requested categories in a single pass.

That makes the architecture particularly suitable for high-volume moderation.

For example, a gaming platform could define categories such as:

• Harassment
• Threats
• Off-platform trading
• Fraud
• Profanity
• Manipulation

A single message could then receive a score for each category.

The platform’s moderation system can apply different thresholds to each category depending on how serious a violation is.

Musubi provides “precision” and “balanced” cutoff presets, while allowing teams to calibrate thresholds against their own labeled data.

Reported performance

Musubi’s published model card provides more specific performance numbers than the broad “under 100ms” description.

Hardware	Median latency	Benchmark condition
NVIDIA L4	35 ms	Short message, up to 6 categories
NVIDIA L40S	34 ms	Short message, up to 6 categories
NVIDIA H100 PCIe	22 ms	Short message, up to 6 categories

The company also reports that one L40S processed about 127 messages per second in a batched benchmark, while an L4 processed about 39 messages per second. Musubi calculates estimated inference costs of roughly $4.90 to $6.91 per million messages under those particular hardware and pricing assumptions.

These numbers should be treated as vendor-reported benchmark results rather than independent production measurements.

The benchmark was conducted under specific conditions, and the model card notes that PolicyLM has not yet been tested on live traffic.

How accurate is PolicyLM-1.7B?

Musubi reports an accuracy score of 0.842 on its custom-policy benchmark.

In the same benchmark, the company compared PolicyLM with several larger models.

For example, Musubi reports:

Model	Parameters	Accuracy	Median latency
PolicyLM-1.7B	1.7B	84.2%	22 ms
gpt-oss-safeguard-20B	21.5B	90.9%	349 ms
CoPE-B-A4B	25.2B	82.9%	53 ms
Granite Guardian 4.1-8B	8.4B	72.2%	186 ms
Nemotron-3.5-Content-Safety	4.3B	66.8%	50 ms

Musubi’s benchmark therefore shows a clear trade-off.

The larger gpt-oss-safeguard-20B model performed better on accuracy in this particular test, while PolicyLM was substantially faster.

PolicyLM’s advantage is not that it beats every larger model at every moderation task. Its proposition is that it can provide a useful policy-conditioned decision at much lower latency and resource requirements.

The model can use a platform’s own rules

One of the most important features is policy customization.

A platform does not have to accept a vendor’s fixed definition of what constitutes a violation.

Instead, the platform can define categories in its own language.

For example, a game could define an “Off-platform trading” category specifically around attempts to move transactions outside the game’s approved marketplace.

It could also specify exceptions, such as warnings about scams or legitimate discussions of the game’s trading rules.

Musubi says policy teams can modify these rules without retraining the model.

That could significantly reduce the operational delay between a policy decision and its implementation.

Policy changes without model retraining

This is potentially the biggest business advantage of PolicyLM.

Consider a social platform that changes its harassment policy.

With a conventional fixed classifier, the company may need to:

1. Define the new policy.
2. Collect examples.
3. Label the examples.
4. Retrain or fine-tune the classifier.
5. Test the updated model.
6. Deploy the new version.

PolicyLM is designed to shorten that loop.

The policy can be edited and supplied to the model at inference time.

That does not mean every policy change will automatically produce a perfect moderation system. Musubi itself recommends calibrating thresholds using a sample of the platform’s own content before deployment.

But the model changes where the iteration happens: from retraining the model toward editing and evaluating the policy.

Open weights make the model more interesting

Musubi is releasing PolicyLM-1.7B with Apache 2.0 licensing.

That means organizations can download the weights and operate the model themselves rather than sending every moderation decision to a third-party hosted API.

The model card says it can operate offline and can run on a 24GB GPU, laptop CPU or Apple silicon.

For companies handling sensitive user content, self-hosting can have advantages around infrastructure control, privacy and predictable deployment.

It also allows developers to experiment with the model and potentially fine-tune it for their own communities.

The model’s weights are publicly available through Hugging Face.

PolicyLM is not a general-purpose moderation replacement

Despite its flexibility, PolicyLM has significant boundaries.

It is currently text-only and evaluates one message at a time.

It does not use conversation history.

That means a message that appears harmless by itself could require surrounding context to understand correctly.

It also does not provide a written explanation for its decision.

That makes it less suitable for situations where a platform needs a detailed rationale for a ban, appeal or takedown.

Musubi recommends using larger models or other systems for those more nuanced workflows.

The company also explicitly lists child-safety enforcement and use as the only self-harm safeguard among the situations for which PolicyLM should not be treated as a standalone solution.

Multilingual performance is still uneven

Musubi evaluated PolicyLM on 19 languages.

However, the company says English is its strongest language and identifies Tamil as the weakest among the languages it evaluated.

The model can also struggle with code-mixed slang and disguised text such as leetspeak.

That matters because real-world online communities rarely communicate in clean, standardized English.

Users routinely mix languages, intentionally alter spellings and use slang to evade moderation systems.

Musubi says its preprocessing can undo some forms of obfuscation, including look-alike characters, spaced-out letters and some base64 encoding, but leetspeak remains a weakness.

A model built for the decision-model trend

PolicyLM arrives during a broader shift toward AI systems designed to make narrow decisions rather than generate long answers.

TypeSafe AI’s Jev helped draw attention to this category, while OpenAI has also introduced its Decisions API for structured classification and routing.

Musubi is applying the same general concept to content moderation.

The distinction is important.

The model does not need to be the smartest possible AI system.

It needs to be fast enough to evaluate huge numbers of messages and consistent enough for a platform to set usable thresholds.

TechCrunch described PolicyLM as an attempt to bring the decision-model approach into real-time content moderation, where traditional classifiers are fast but less adaptable to changing policies.

The production claim needs context

Musubi says a custom fine-tuned version of PolicyLM is already running on a platform processing more than one million messages per day.

That is notable because it suggests the underlying approach is being used beyond a laboratory demonstration.

However, it does not establish that the publicly released PolicyLM-1.7B will achieve the same performance on every platform.

The model card explicitly says the published evaluation has not yet been conducted on live traffic.

That distinction matters when assessing a new open model.

What this means for content moderation

The broader significance of PolicyLM is the possibility of separating policy creation from model retraining.

Platforms constantly change their rules.

New forms of spam appear. New scams emerge. Communities develop their own definitions of acceptable behavior. Governments introduce new requirements. Product teams also change policies as they learn more about user behavior.

A moderation system that can consume those changes directly has an operational advantage.

Instead of treating the model as the permanent definition of what is harmful, the model becomes an engine for applying the platform’s current policy.

That is a meaningful architectural shift.

The bigger picture

PolicyLM-1.7B does not eliminate the difficult parts of content moderation. False positives, false negatives, adversarial users, multilingual slang, contextual interpretation and policy ambiguity will remain difficult problems.

Its more specific contribution is combining the flexibility of policy-conditioned AI with the latency and deployment characteristics of a small classifier.

If Musubi’s reported performance holds up under independent testing and real-world traffic, smaller decision models could become an important layer between fixed moderation classifiers and large general-purpose LLMs.

Looking Ahead

The next test for PolicyLM will be real-world deployment. Its published benchmarks are promising for latency and show competitive accuracy for a model of its size, but independent testing and live-traffic results will be important for determining whether the approach can reliably handle the messy, adversarial and multilingual nature of online communities.

The larger trend may extend beyond moderation. As more AI systems are built to make narrow decisions rather than generate text, platforms could increasingly use small specialized models for high-volume decisions and reserve larger models for ambiguous cases, appeals and complex reasoning. PolicyLM-1.7B is an early example of that architecture being applied to human-generated content.