Smart idea but the concern can be that in the future, tokenization techniques and libraries may change. And also this looks like a very edge optimization to me. But overall, it deserve to exist. Good job.
It is being used in production at https://vostride.com/agent-qa
The issues was agent-qa have many different kinds of files tests, memory etc and there's too much FK references which LLMs need to resolve. Using id-agent worked like a charm
Nice package, not only is using words more token-efficient [saving time and money], but weaker models are also less likely to make mistakes when providing the key, at least in my tests.
That said, for `createAliasMap`, don't you think you could create a deterministic mapping from and to UUIDs <-> word chains? That way, no additional state would be needed. [Might require fairly long word chains...]
An even better solution is to present the AI with local IDs and map those to UUIDs outside of its context. So when giving a list of items for the LLM to choose from, just list them with incremental numbers (1, 2, 3...) and ask for these numbers in tool schemas.
Why do people choose the hyphen ("-") as the separator in an identifier? When double-clicking, the ID does not select completely, unlike when an underscore ("_") is used.
There is an example on GitHub with a prefix: "task_storm-delta-stone" (prefix: 'task'). Wouldn't it be more logical to have it reversed, like "task-storm_delta_stone"?
LLMs are good at predicting words, since each word in the id is ~1 BPE token.
But uuids are random hex characters, this is where LLMs struggle to output the right ids.
But shouldn't you have picked words that also have single token representations for the word with a dash in front? Or are there less than 4096 such words? That would get your token count for the 10 word variant (the most honest benchmark) from 17 tokens to 10
> Just removing the - from the example UUID takes it from 26 tokens to 18
And according to the table below, an id-agent with 120 bits of entropy (still 2 bits less than UUID) uses 17 tokens on average. So unless you purposefully want to reduce the entropy, this whole scheme is just as good as just removing the dashes from UUIDs. But that wouldn't make for a resume-worthy project (sorry, got a bit cynical there)
Can someone explain why this would even be needed? Why is there a cost to generating say an UUIDv4? E.g. Claude Code has some regex in the client side code that filters out "bad words", so why can't the agent just generate UUIDs client side, using zero tokens.
I sort of get the "problem", but the fact that this is even needed is stupid.
the machines this is designed for are stupid. this makes them less stupid. do not anthropomorphize.
I can see this being useful when feeding raw table dump csvs into models, isomorphism means it's a simple pre-post processing step which could give you a cheap decrease of tokens and increase in accuracy.
I haven't encountered this exact problem but I have had LLMs make occasional transcription errors when "copying" hex strings around (e.g. cryptographic constants). They make surprisingly human-like mistakes e.g. a transposed pair of digits, which can be annoying to track down.
But this seems orthogonal to token usage, and if I was designing an "LLM-friendly UUID" it would have some additional checksum data, to detect transcription errors.
I thought the same thing, and was wondering if this wouldn't even cause more drift and hallucination as these tokens will have stronger relations within the model as opposed to the UUIDv4 that probably gets dropped as noise (correctly so).
The problem is really more getting the agent to reliable relay a UUID. For example, we were creating files for visualizations and having the agent reference them in there response with a custom <visualization file=UUID /> and found that it would often fail to accurately return a UUID from a tool response it was previously provided (running sonnet 4.6).
For this use case, our solution was just to use a slug for the filename, but we can control the uniqueness constraint on our backend.
Except that we don't yet know what would need in all cases, this seems like something that should be provided by the environment.
It feels much like the random number generators in your operating system. The OS is responsible for providing applications with a source of entropy. In the same line of thinking maybe IDEs, agent frameworks, whatever you want to call it, should be responsible for providing some base functionality.
Not sure I understand. If you generate a random string to use as a reference for something that the LLM interacts with... and the LLM cannot reliably recall the reference, then it's a problem that needs to be solved by simplify the random string.
This might be my understanding that's wrong, but I assumed that the LLM itself actually can't produce like a UUID, but it can "predict" one, hence why it sometimes hallucinate IDs. So my thinking was, strip that bit out of the AI prompt and output and leave it to the "wrapper" e.g. Claude Code or your IDE to insert the actual ID.
So in the same way that your crypto library don't have its own randomness generator (ideally) and rely on the operating system to provide an API, the agents would rely on their "operating shell" / IDE / application to provide functionality that lies outside the score of an LLM.
It's not that there's a cost to generating them -- per say. I wouldn't want an LLM generating UUIDs anyways. I think it's the cost of consuming them in conversation context that is the issue.
Isn't this solving a subproblem of the overall issue of uncompressed tool call polluting context?
Furthermore, this could be compressed even further with a dynamic legend of every UUID in the context. So UUID@Bravo and UUID@Delta would be the actual symbols in the context but dynamically replaced when calling tools.
Neat idea! I'd argue that the collision risk is basically zero because even though the entropy is lower, because you must validate the LLM-output anyways for two reasons:
1. LLMs might lack intrinsic entropy and reuse some UUIDs much more often.
2. Referential integrity is as important as collision resistance. An LLM must be able to reuse the correct id in the correct place.
On the other hand, using a dictionary for the ids helps with readability, but depending on the models strenghts, it might also add a confounder. After all, tokens that represent real words will probably influence the attention in a different way than random numbers.
That's nice, I've had the issue where LLMs would return non-existent uids. But does this package actually help with that? Token savings are nice, but not really my main concern. If this can measurably reduce hallucinations, it would be really useful.
> Where UUIDs cost ~23 tokens and get hallucinated by LLMs, id-agent produces memorable word-based IDs at ~14 tokens with equivalent collision resistance.
My gut feeling is that the hallucinations are caused by the entropy. A UUID has unlikely character sequences. But the entropy is a core feature. Turning the UUID into words keeps the same entropy, you just have surprising words instead of surprising hex sequences.
I would be surprised if this actually helped with hallucinations. Happy to be proven wrong though, and this seems like an easy experiment to run: just take a tiny model (below 1B) and have it transcribe a couple thousand ids in both formats, then check where it made more mistakes
But within the surprising words, the adjacent tokens are common. I can see an argument for having fewer transcription errors on badger-yellow-alternate than 0B9A26F3C74D.
Your test with small models makes tons of sense. Would be interesting to graph to two approaches against model size and recency.
I had similar thoughts. The readme intro explicitly mentions hallucinations, that's why I thought I'd ask.
If you're dealing with uid in -> uid out, where you're hoping to get the same uid out, intuitively the entropy would be greatly reduced anyways. Then the question becomes, are words conducive to keeping input->output consistent, given the way LLMs work (e.g. attention mechanism)? I could see it go either way, that's why I'm supporting the idea of running your experiment.
Okay, but you can also validate uids. What I'm asking is whether the human readable uids cause fewer hallucinations, as that would be the real win imo.
nither | 10 hours ago
[OP] pranshuchittora | 2 hours ago
whazor | 10 hours ago
[OP] pranshuchittora | 10 hours ago
Falimonda | 9 hours ago
brookst | 8 hours ago
felipeyanez | 10 hours ago
[OP] pranshuchittora | 9 hours ago
Tiberium | 10 hours ago
[OP] pranshuchittora | 9 hours ago
asdfsa32 | 9 hours ago
anuramat | 2 hours ago
not that anyone should ever care; typos in random-looking ids are very real but already covered by human readable ids
besides, this is for a specific tokenizer
Falimonda | 10 hours ago
simedw | 10 hours ago
That said, for `createAliasMap`, don't you think you could create a deterministic mapping from and to UUIDs <-> word chains? That way, no additional state would be needed. [Might require fairly long word chains...]
thrance | 9 hours ago
persedes | 8 hours ago
railka | 9 hours ago
[OP] pranshuchittora | 9 hours ago
railka | 9 hours ago
[OP] pranshuchittora | 9 hours ago
brookst | 8 hours ago
railka | 9 hours ago
jy14898 | 9 hours ago
> Where UUIDs cost ~23 tokens and get hallucinated by LLMs
How does this solve the hallucination problem?
Just removing the - from the example UUID takes it from 26 tokens to 18
[OP] pranshuchittora | 9 hours ago
You can use the .from method https://github.com/vostride/id-agent/#idagentfrominput-opts
To convert uuid or any text to id-agent based id. Then do the LLM inference and then convert it back to UUID.
wongarsu | 9 hours ago
wongarsu | 9 hours ago
And according to the table below, an id-agent with 120 bits of entropy (still 2 bits less than UUID) uses 17 tokens on average. So unless you purposefully want to reduce the entropy, this whole scheme is just as good as just removing the dashes from UUIDs. But that wouldn't make for a resume-worthy project (sorry, got a bit cynical there)
mrweasel | 9 hours ago
I sort of get the "problem", but the fact that this is even needed is stupid.
tyleo | 9 hours ago
I feel like people just jam poorly specified input into LLMs and hope for the best. Then pile more tools on top when they don’t get what they want.
Slartie | 9 hours ago
People call this exact process "vibe coding".
baq | 9 hours ago
I can see this being useful when feeding raw table dump csvs into models, isomorphism means it's a simple pre-post processing step which could give you a cheap decrease of tokens and increase in accuracy.
sdevonoes | 9 hours ago
I guess you’re another bot
[OP] pranshuchittora | 9 hours ago
Retr0id | 9 hours ago
But this seems orthogonal to token usage, and if I was designing an "LLM-friendly UUID" it would have some additional checksum data, to detect transcription errors.
hmokiguess | 9 hours ago
cjonas | 8 hours ago
For this use case, our solution was just to use a slug for the filename, but we can control the uniqueness constraint on our backend.
mrweasel | 8 hours ago
It feels much like the random number generators in your operating system. The OS is responsible for providing applications with a source of entropy. In the same line of thinking maybe IDEs, agent frameworks, whatever you want to call it, should be responsible for providing some base functionality.
cjonas | 7 hours ago
mrweasel | 2 hours ago
So in the same way that your crypto library don't have its own randomness generator (ideally) and rely on the operating system to provide an API, the agents would rely on their "operating shell" / IDE / application to provide functionality that lies outside the score of an LLM.
jadar | 8 hours ago
synthos | 9 hours ago
Furthermore, this could be compressed even further with a dynamic legend of every UUID in the context. So UUID@Bravo and UUID@Delta would be the actual symbols in the context but dynamically replaced when calling tools.
nkmnz | 9 hours ago
1. LLMs might lack intrinsic entropy and reuse some UUIDs much more often.
2. Referential integrity is as important as collision resistance. An LLM must be able to reuse the correct id in the correct place.
On the other hand, using a dictionary for the ids helps with readability, but depending on the models strenghts, it might also add a confounder. After all, tokens that represent real words will probably influence the attention in a different way than random numbers.
yunusabd | 9 hours ago
> Where UUIDs cost ~23 tokens and get hallucinated by LLMs, id-agent produces memorable word-based IDs at ~14 tokens with equivalent collision resistance.
wongarsu | 9 hours ago
I would be surprised if this actually helped with hallucinations. Happy to be proven wrong though, and this seems like an easy experiment to run: just take a tiny model (below 1B) and have it transcribe a couple thousand ids in both formats, then check where it made more mistakes
brookst | 8 hours ago
Your test with small models makes tons of sense. Would be interesting to graph to two approaches against model size and recency.
yunusabd | 8 hours ago
If you're dealing with uid in -> uid out, where you're hoping to get the same uid out, intuitively the entropy would be greatly reduced anyways. Then the question becomes, are words conducive to keeping input->output consistent, given the way LLMs work (e.g. attention mechanism)? I could see it go either way, that's why I'm supporting the idea of running your experiment.
[OP] pranshuchittora | 9 hours ago
A random "-" separated words will fail the validation check.
yunusabd | 8 hours ago
diimdeep | 9 hours ago
[OP] pranshuchittora | 8 hours ago