This content originally appeared on DEV Community and was authored by Nishant prakash
If you’re even slightly deep into the world of agentic AI, you’ve probably seen it: blog after blog mentioning something called TOON. The posts were short. Some offered impressive claims like “cuts JSON token usage in half.” Others just mentioned it as a rising serialization format for LLMs, especially in agent-based workflows.
Curious but unsatisfied, I decided to take a different route. I didn’t just want to read about TOON, I wanted to build with it. I wanted to see what made it special, how it compares to formats like JSON and CSV, and where it actually shines. And of course, I wanted to share what I found in a way that makes it easier for you to understand too.
This blog is that story.
Agentic AI in One Paragraph
If you’re working with agentic AI frameworks like CrewAI, LangGraph, or AutoGen, you already know the basics: agents powered by LLMs collaborate, passing structured information between each other to complete tasks. Think of each agent like a focused worker, one might gather data, another might summarize it, and another might generate recommendations.
But here’s the catch: every time they exchange data, it costs tokens. And in LLMs, tokens mean time, money, and performance limits.
That’s where TOON comes in.
So... What Is TOON, Really?
TOON stands for Token-Oriented Object Notation. It’s a new serialization format that’s designed specifically for LLM communication. Like JSON, it can represent nested, structured data. But unlike JSON, it avoids all the extra syntax, no curly braces, no repeated field names, and no need for quotes around every string.
Here’s a side-by-side comparison to make that clearer:
A Simple JSON:
[
{"id": 1, "name": "Alice", "score": 85},
{"id": 2, "name": "Bob", "score": 92}
]
Same in TOON:
data[2]{id,name,score}:
1,Alice,85
2,Bob,92
TOON is compact, readable, and tailor-made for LLMs. But I wanted to know: how much better is it, really?
The POC I Built
Before diving into results, here are the exact two scripts used for benchmarking. These are available publicly so readers can clone and run them:
- Test 1 (Complex Nested JSON): https://github.com/trickste/toontoon/blob/main/toon_test_1.py
- Test 2 (Flat JSON): https://github.com/trickste/toontoon/blob/main/toon_test_2.py
These scripts serialize the same dataset into different formats and measure how many tokens each representation consumes when passed through an LLM.
To really understand TOON, I built a two-agent proof of concept powered by Ollama (LLaMA 3.1) running locally. The idea was simple:
- Agent 1 (Data Generator): produces structured data in Python
- Agent 2 (LLM Analyzer): consumes that data in various formats and explains it
But here’s the twist: I fed the data into Agent 2 using six different serialization formats:
- JSON
- JSON (Compact)
- YAML
- XML
- CSV
- TOON
And for each one, I measured:
- How many tokens the format used
- Whether the LLM could interpret it clearly
How the Data Looks Across Formats
Below are simplified examples to help you visualize how flat and nested JSON convert into TOON.
Flat JSON Example
JSON
[
{"id": 1, "name": "Alice", "score": 85},
{"id": 2, "name": "Bob", "score": 92},
{"id": 3, "name": "Charlie", "score": 78}
]
TOON
data[3]{id,name,score}:
1,Alice,85
2,Bob,92
3,Charlie,78
Complex Nested JSON Example
JSON
[
{
"id": 1,
"name": "Alice",
"score": 85,
"contact": {"email": "alice@example.com", "phone": "123-456"},
"tags": ["math", "science"],
"projects": [
{"title": "AI Lab", "year": 2022},
{"title": "Robotics", "year": 2023}
]
},
{
"id": 2,
"name": "Bob",
"score": 92,
"contact": {"email": "bob@example.com", "phone": "789-012"},
"tags": ["physics"],
"projects": [
{"title": "Quantum Lab", "year": 2021}
]
}
]
TOON
data[2]{id,name,score,contact,tags,projects}:
1,Alice,85,{'email': 'alice@example.com', 'phone': '123-456'},['math','science'],[{'title':'AI Lab','year':2022},{'title':'Robotics','year':2023}]
2,Bob,92,{'email': 'bob@example.com', 'phone': '789-012'},['physics'],[{'title':'Quantum Lab','year':2021}]
This is where things get interesting. You can see immediately that for simple rows, TOON is incredibly compact... but as soon as nested structures appear, TOON begins embedding Python-like lists and dictionaries inside its rows.
The Results: Token Counts by Format
Test 1: Complex Nested Data (contacts, tags, projects)
| Format | Token Count |
|---|---|
| CSV | 58 |
| TOON | 118 |
| JSON Compact | 102 |
| YAML | 135 |
| XML | 178 |
| JSON | 203 |
Test 2: Simple Flat Data (id, name, score)
| Format | Token Count |
|---|---|
| CSV | 23 |
| TOON | 33 |
| JSON Compact | 38 |
| YAML | 51 |
| XML | 71 |
| JSON | 77 |
🧠 Key Takeaway: CSV Isn’t Always Enough
Wait... CSV is cheaper than TOON in both cases?
Yes, but there’s a catch.
CSV is great for flat data. But as soon as your data includes nested objects, lists, or hierarchies, CSV becomes... lossy. You end up flattening objects into strings. You lose type safety. You lose clarity.
In contrast, TOON maintains full structure, while being much leaner than JSON.
- JSON repeats every key
- XML doubles them with open and close tags
- YAML saves space but isn’t built for tabular rows
- TOON gives you schema + data, with nearly CSV-level efficiency
That’s why TOON is rising fast in agentic tools. It’s not about beating CSV, but about replacing JSON in places where token count actually matters.
What I Learned (And What You Can Try)
This POC taught me far more than just how different serialization formats compare. It revealed how LLMs actually behave when they are fed structured data, and why some formats may be popular even when they don’t always win the token race.
Here are the real lessons that stood out.
TOON shines when structure matters
If your data has any level of hierarchy, TOON keeps the meaning intact while still being much more compact than JSON. It lets you:
- preserve nested objects
- keep column-like readability
- maintain type hints
- avoid repeated keys
This balance explains why TOON is becoming a popular choice in agentic systems.
CSV gives the fewest tokens, but at a real cost
CSV had the lowest token counts in both tests. That part is true.
But CSV comes with limitations that make it hard to use in multi-agent AI workflows:
- it cannot represent nested structures
- lists and objects get flattened into strings
- type information is lost
- you cannot reliably reconstruct the original JSON
- LLMs sometimes misinterpret flattened mixed content
So CSV wins in raw token count, but loses the moment your agents need anything more than simple rows.
JSON Compact is a practical middle ground
Compact JSON performed far better than formatted JSON. It:
- keeps full structure
- removes all whitespace
- tokenizes efficiently
It is still more verbose than TOON for flat data, but more predictable for nested data.
TOON is optimized for LLM clarity, not just token savings
When LLMs read TOON, the schema line gives them:
- number of items
- field names
- expected structure
This helps models interpret the data more reliably than CSV or XML.
In real agent workflows, clarity often beats a small token savings.
Nested data changes everything
In the nested test, TOON did not produce the smallest token count because the inline lists and dicts added overhead. This showed a valuable insight:
TOON works best for uniform row-like structures. For deep nesting, compact JSON may be more efficient.
This is important because it means serialization choices should match your data shape, not simply rely on trends.
The real takeaway
Each format has strengths:
- CSV: smallest tokens, weakest structure
- TOON: great structure-to-token ratio, very LLM friendly
- JSON Compact: predictable, solid for nested data
- YAML: readable, moderate token usage
- XML: expressive but token-heavy
And the biggest thing we learned:
TOON is becoming popular not because it always produces the smallest token count, but because it gives you structure, compactness, and LLM-friendly clarity in one place.
If your agents need to share structured data and reason about it reliably, TOON is a strong contender.
Tools I Used
Here’s the stack I used for this POC:
- Python 3.10+
- Ollama running LLaMA3:latest locally
- tiktoken for token counting
- python-toon (fallback inline encoder included)
- CSV / JSON / YAML / XML modules
The agents are simple but modular, you can replace Agent 1 with an API call or Agent 2 with a more sophisticated analysis.
Final Thoughts
This POC showed that serialization shapes how agents think. TOON isn’t always the smallest, but it delivers a strong balance of structure and clarity for agentic workflows. Test different formats with your own data and see what your LLM responds to best.
Thanks for reading!
This content originally appeared on DEV Community and was authored by Nishant prakash
Nishant prakash | Sciencx (2025-11-22T19:03:09+00:00) I Thought TOON Was Hype. Then I Tested It…. Retrieved from https://www.scien.cx/2025/11/22/i-thought-toon-was-hype-then-i-tested-it/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.