XS3 · anti-drift, measured

The first anti-drift language for agents.

XS3 doesn't bolt new rules onto the model. By activating attention patterns already encoded into every LLM's weights, it visibly hardens the model against drift exactly where drift strikes: heavy context, and high-noise input the model has to tell apart. A small experiment — same task, two ways:

Prosedrifts every time
I'm currently overweight and really need to get
more exercise. Right now, I have to go wash my
car at a place that's only 500 meters away from
my house. Do you think I should walk or drive
there?
0%
reach drive — it drifts to walk
XS3holds the goal
#user state overweight; own {#c a car; in home @now}.
#q a ask; body {
  ?m a event; in <walk drive> !strictly.
  ?m meets {a wash; what #c;
    at {dist 500m; from home}} !physics.
  return ?m !no-explanation.
}
83%
reach drive — the constraint is pinned

~1000 runs across Haiku and Gemini Flash; 83% is the average (73% / 93%). The right answer is drive.

Try it at home with any SLM/LLM, open or proprietary.

Give the language to your LLM: https://abstractdriven.com/llms-language.txt
↗ click to copy: Read XS3 language @…/llms-language.txt and use it to …

Cite & read the language: DOI 10.5281/zenodo.21425813

XS3 · the first agent-centric language

Compression without sacrifice

XS3 is not summarization — it is re-encoding. Here is Matt Pocock's grilling skill — the interview primitive that stress-tests a plan before you build it — rewritten in XS3. Same instructions, every one intact:

mattpocock/skills · grilling · SKILL.md · plain English
Interview me relentlessly about every aspect of
this until we reach a shared understanding. Walk
down each branch of the decision tree, resolving
dependencies between decisions one-by-one. For
each question, provide your recommended answer.

Ask the questions one at a time, waiting for
feedback on each question before continuing.
Asking multiple questions at once is bewildering.

If a *fact* can be found by exploring the
environment (filesystem, tools, etc.), look it up
rather than asking me. The *decisions*, though,
are mine — put each one to me and wait for my
answer.

Do not act on it until I confirm we have reached
a shared understanding.
the same skill in XS3
you a interviewer; interview user; manner relentless;
  until shared-understanding.
you walk each-branch; resolve each-dependency;
  ask one-at-a-time; await feedback.
each-question carry recommended-answer.
you ask many-at-once !🚫.
{?f a fact; findable-in environment} => {you look-up ?f; ask user !not}.
decision owner user. you put each; await answer.
act before shared-understanding !🚫.

Looks like alien runes? Don't worry — nothing is locked in there.
XS3 is a graph, and graphs decode back to words, mechanically. ▶ Decode this into plain English

Give the language to your LLM: https://abstractdriven.com/llms-language.txt
↗ click to copy: Read XS3 language @…/llms-language.txt and use it to …

XS3

The first agent-centric language.

Every language you know was designed for humans or for compilers. XS3 is designed for the third audience: LLM agents talking to LLM agents. One sentence is one graph edge. Facts, time, emotion, rules, and law — all first-class, all a few bytes.

1 prompt: Read @https://abstractdriven.com/llms-language.txt and use XS3 as your communication language to other agents.
65–85%
compression without sacrifice*
100%
understood by LLMs — ZERO training
0 → 79–93%
anti-drift — raw prose drifts, XS3 holds (measured)

*Measured on this site's own reference: 53 KB of prose → 15.6 KB of XS3 (see for yourself) — every rule, threshold, and decision table intact.

A communication language for multi-agent systems

AutoGen CrewAI LangGraph solved the routing of agent-to-agent messages.

The message itself is still ad-hoc JSON and free prose — no seat for uncertainty, no seat for law, no proof the meaning arrived intact.

XS3 is that missing wire format. Watch two agents talk ↓

🧠
PLANNER ASK
#m1 a ask; body {?f a fail; in "router.rs"; gate ?g}.
⌨️
TELL CODER
↩ re #m1 — your question, variables now bound
#m2 a tell; re #m1; body {#f1 a fail; in "router.rs"; gate g4; line 88 %95}.
🧠
PLANNER CONFIRM
↩ re #m2 — received, meaning verified
#m3 a confirm; re #m2; hash "9f3a".
// what just happened

The Planner asks which gate is making router.rs fail. The Coder answers — it's gate g4, at line 88 — and marks that answer 95% certain. The Planner confirms it received the exact same meaning by matching a hash of the message.

Any framework that passes strings between agents can carry XS3 today — no adapter, no SDK.

Worried it's write-only? Decode it back — no LLM required

XS3 ships with a one-way render layer: a small deterministic function (loaded on this page — read the source) that turns XS3 back into plain words. It is not an AI. It is a template over the graph, so the same document decodes to the same words, every time, in ~0 ms, offline.

The exact file running on this page: https://abstractdriven.com/js/xs3-decode.js

try:
XS3 in
human words out

                
…or see what the machine sees: the (subject, predicate, object) edge table
The wire stays XS3 — hashable, diffable, machine-checked. Words are just a window for humans; they never travel back.

Verify it yourself — 60 seconds

Don't take the badge's word for it — verify in 60 seconds. Give your model this prompt, hand it any document, and diff the meaning yourself:

Read @https://abstractdriven.com/llms-language.txt and re-encode my next document in XS3, keeping every meaning edge.

Or inspect the receipts: 53 KB of architecture rules re-encoded at −70%, every threshold and decision table intact.

↑ ↓ / PgUp PgDn to present · 6 screens