Two sentences in a design review can save a telecom AI project a lot of pain: the model never calculates a charge, and the model never sees raw telemetry. Many telecom software companies now pitch language models for almost every layer of the stack, so it helps to be precise about why these two boundaries exist and what you build instead.

Boundary 1: Rating and charging stay deterministic
A rating engine has properties that a language model cannot offer:
-
The same input gives the same output, every time.
-
Each result traces back to a tariff rule and a usage record.
-
A decision arrives within milliseconds, for every session and event.
-
An auditor or regulator can follow the calculation.
Run the same prompt twice and you may get two answers. Even a model that is right nearly always is unacceptable when small errors repeat across millions of subscribers, and each wrong amount is either a customer complaint or lost revenue.
So keep the LLM on the explanation side of the line. Customers ask a lot of billing questions, and a model explains well when it is given facts. The rating engine stays the source of truth, and the model only narrates its output.
const facts = await billing.getRatedLines(accountId, cycle); // deterministic
const reply = await llm.explain({ question, facts });
// Every amount in the reply must appear in the rated data
const allowed = new Set(facts.lines.map((l) => l.amountFormatted));
const mentioned = extractAmounts(reply.text);
if (!mentioned.every((a) => allowed.has(a))) {
return fallbackToTemplate(facts); // never show an invented figure
}
return reply.text;
That last check is simple and valuable. It will not prove the explanation is right, but it does stop the worst failure, a confident figure that appears nowhere on the bill. The same rule applies to any other amount: credits and proration are computed by deterministic code first, and the model may only talk about the results.
Boundary 2: No model writes to a live network
Configuration has a similar problem with higher stakes. A malformed or merely unwise change can affect emergency calling or enterprise connectivity, and the output of a model varies between runs. Language models are still useful here, as long as they stop short of production:
-
The model proposes a change, ideally by choosing a pre-approved template and filling in parameters.
-
Deterministic code validates the parameters against policy and the current state of the network.
-
A dry run produces a diff.
-
A person or policy engine approves.
-
The pipeline applies it, verifies health and rolls back on failure.
Each step after the first is testable without a model. Moving to more automation then means widening what the policy engine may approve for specific, narrow templates, which is a far smaller and more auditable decision than handing a model production credentials.

Boundary 3: Filter before you infer
Now the economics. Networks generate enormous volumes of structured events, and the bill for LLM inference scales with tokens. Your first-order monthly cost looks like this:
cost = events_sent_to_llm x avg_tokens_per_event x price_per_token
You have some influence over price by choosing models, and some over tokens through prompt design. The largest lever by far is the first term. Running inference across raw telemetry would be ruinously expensive and would also perform worse, since most events carry no information a model needs to interpret.
So treat inference as the final stage of a funnel:
def triage_pipeline(events):
# Stage 1: cheap rules
events = drop_known_noise(events)
events = suppress_maintenance_windows(events)
# Stage 2: statistics and classical ML
anomalies = [e for e in events if anomaly_score(e) > THRESHOLD]
clusters = correlate_by_topology_and_time(anomalies)
# Stage 3: deterministic knowledge
unresolved = []
for cluster in clusters:
runbook = match_runbook(cluster)
if runbook:
open_ticket(cluster, runbook)
else:
unresolved.append(cluster)
# Stage 4: LLM on the small remainder, with a compact summary
return [summarise_with_llm(compress(c)) for c in unresolved]
A few practical notes:
-
Send summaries, not logs.
compress()should produce counts, top affected elements, time span and a few representative samples. A cluster of thousands of alarms rarely needs thousands of lines of context. -
Cache by signature. Recurring cluster shapes can reuse an earlier explanation until the underlying situation changes.
-
Route by difficulty. A small, cheap model can handle simple summarisation, leaving a larger model for the ambiguous remainder.
-
Set a budget and alert on it. Alarm storms arrive exactly when your system is busiest. Cap per-incident inference and degrade gracefully to the deterministic output.
-
Measure each stage. Log how many events enter and leave. If the filter drops something an engineer later needed, you want that visible, because a cheap pipeline that hides faults is no bargain.
Sensitive data changes the architecture
Call transcripts, location data and traffic records are among the most sensitive data a company can hold. Masking before inference and regional or private hosting are often requirements, depending on the market, and they can reshape the design. Pre-filtering helps here too, since less data leaves your boundary. Our LLM integration projects settle these constraints with legal and compliance reviewers before any architecture gets drawn.
The short version
-
Deterministic systems produce numbers and apply changes.
-
Models explain, summarise and propose.
-
Cheap filters run first, and inference only pays for what survives.
If you are comparing vendors on these questions, ask what data the model sees, who pays for inference, and what happens when it is wrong. Our longer guide to telecom software companies covers how to evaluate them.
Frequently Asked Questions
Can an LLM validate a bill even if it cannot calculate one?
It can flag bills for review and help classify discrepancies, but a deterministic comparison should make the final call on any amount.
Is a very accurate model safe enough for rating?
No. Rating needs repeatable, traceable results at high volume. A small error rate across millions of events is still a real financial and audit problem.
What should go in the compressed prompt for an alarm cluster?
Counts, time span, top affected elements, recent changes, affected services and a few representative raw samples. Leave out the full event stream.
How do you stop filtering from hiding real faults?
Measure each funnel stage, sample dropped events for review, and compare against incidents engineers later confirmed. Adjust thresholds based on those misses.
What happens during an alarm storm if the inference budget runs out?
The system should fall back to deterministic correlation output, so engineers still see clusters and impact, just without the generated narrative.
Can LLMs ever touch configuration at all?
They can draft or propose changes and explain diffs. Validation, approval and application should remain in a deterministic, reversible pipeline.