This test checked whether the Tieroute spec is complete enough to build a working client from. GPT 6.1 Sol, unmodified and at medium reasoning effort, received the spec documents and nothing else: no Reroute or rerouted source, and no other guidance. It had three attempts to build a client, join a community, and collect everything an ordinary member can fetch.
This post describes what that client could and couldn't read, the gap it found in the spec, and the protocol behavior behind each result. Most results are the protocol working as specified.
Method
The client, tiebright, joined a small community on a community server run by Reroute Holdings LLC. It used a public invite code and held no roles. It made 135 HTTP requests over 7.7 minutes, 3 s apart, and received 3.89 MB. It then
tried to decrypt and verify everything it received, and recorded each failure with its reason.
What the client couldn't read
The community server delivered 29 messages sent before the client joined. The client decrypted none of them. Each channel is an MLS group (Messaging Layer Security, RFC 9420), and MLS derives new secrets for each epoch. A new epoch starts with each membership change. A joining device receives the secrets for the epoch its join creates and later epochs, never earlier ones (§16.6).
The community server refused all four restricted channels, for both history and messages. It checks a member's roles against the channel's see list before it serves either. The names of those channels stayed
encrypted, because each restricted channel's name is sealed under a metadata key that only its group holds. The member list was also refused, because it requires the administrate permission.
Every signed object the client fetched verified. Identity chains passed their signature and hash-link checks, profiles verified, and all 14 avatars matched their SHA-256 hashes. Public keys were 1,984 B and signatures 3,373 B, the sizes of composite ML-DSA-65 and Ed25519.
What members can read by design
In a community anyone can join with a public code, end-to-end encryption protects against the community server and against anyone who obtains its storage. It doesn't protect against other members. The model's report listed the following as findings. Each is specified behavior:
- Channel history from before joining. The member who admits a newcomer sends them the channel's history keys (§16.6). A channel with history on is readable by every member who can see it.
- Earlier channel and role names. The community chain is append-only. A rename adds a new entry, and the earlier entry still holds the old name. Members hold the metadata key, so both decrypt.
- Role assignments. The community server enforces permissions, including the refusals above. To do that it needs to know who holds each role, so assignments are plaintext. Role names stay encrypted.
- Moderation actions. A timeout, kick, or ban is a chain entry. Every current and future member can read it.
- Invite codes on profiles. Publishing a code on your profile is optional (§9.1). Removing and revoking it closes that route.
| What | Community server | Any member | Anyone at all |
|---|---|---|---|
| Message text, files, and voice MLS, end to end | Can’t | Can read | Can’t |
| How big each message is Ciphertext isn’t padded | Size only | Size only | Can’t |
| Channel history from before you joined Where history is on | Can’t | Can read | Can’t |
| Every edit to a message Edits are messages too | Can’t | Can read | Can’t |
| Channel and role names Older names too | Can’t | Can read | Can’t |
| A restricted channel’s name and messages Only people who can see it | Can’t | Can’t | Can’t |
| Who holds which role The server enforces roles | Can read | Can read | Can’t |
| Who’s a member Every member’s device is in the MLS tree | Can read | Can read | Can’t |
| Device names in an identity chain Chains are public | Can read | Can read | Can read |
| An invite code you put on your profile Profiles are public | Can read | Can read | Can read |
Most of the chain's 77 entries assign roles, edit roles, or create invite codes.
- assign-roles 22
- edit-role 19
- add-code 14
- add-channel 7
- add-role 5
- set-name 5
- order-channels 5
- edit-channel 3
- create 1
- remove-role 1
- timeout 1
History segments
The client received the history keys and downloaded all 12 history segments, then failed to decrypt any of them. The spec defined a segment as a 12-byte nonce followed by AES-128-GCM output. It didn't define how a history key becomes the AES key, or the associated data each segment is bound to. Without both values, a client can't read history without the Reroute source.
For the retry, the model was allowed to read Reroute's history encryption and decryption functions, and no other source. It retried the cached segments offline, without contacting a server. All 12 segments decrypted, 29
messages in total, and every message signature verified. The construction was then added to §16.5 of the spec, with test vectors in spec/vectors/v2/community-history.json.
The key
- History key · 32 random bytes, from
community-keys - HKDF-Expand, SHA-256, no Extract step
- info
"tieroute community history", 16 bytes out - AES-128-GCM key · equivalent to one HMAC call
The associated data
A five-item array, written as canonical JSON (JCS, RFC 8785). None of it is secret. It binds the segment to its location:
A segment served for another community, channel, or range fails to decrypt.
What's stored
- Nonce
- 12 B, random, new every time
- Ciphertext
- same length as the plaintext, AES-128-GCM
- Tag
- 16 B, fails if any input differs
Reroute differs from the new text in two places. Neither affects decryption:
- Reroute encrypts with the history key it learned most recently. The spec says to use the newest key. These are usually the same key.
- A segment that isn't valid UTF-8 stops Reroute's whole history fetch. The spec says only that segment's range becomes a gap.
Edits in history
The decrypted history includes every edit, not only the final text. In Tieroute, an edit is a separate signed message that names the message it changes, and clients apply edits in order (§7.3). A history segment holds each message as it was received, so a newcomer receives the original and every later version.
- #1 Post first
- #2 Edit +13 s
- #3 Edit +25 s
- #4 Edit +31 s
- #5 Edit +43 s
- #6 Edit +3 min
- #7 Edit +12 h
- #8 Edit +17 h
- #9 Edit +17 h
- #10 Reaction +36 h
Editing a message doesn't remove earlier versions from history. They stay readable to every member who joins later.
Message sizes
MLS supports padding, but the Tieroute profile doesn't require it, and Reroute doesn't pad. The community server stores each message, so it knows each one's exact size. The client couldn't decrypt the 19 messages in the intros channel, so it classified them by size. Five were exactly 594 B, and each arrived in the same epoch as another member's post. It labeled them reactions. The decrypted history confirms all five, with no false positives.
Show the numbers
| Message | Size (B) | Type |
|---|---|---|
| 1 | 596 | Text post |
| 2 | 556 | Text post |
| 3 | 600 | Text post |
| 4 | 596 | Text post |
| 5 | 855 | Text post with a file |
| 6 | 594 | Reaction |
| 7 | 594 | Reaction |
| 8 | 633 | Text post |
| 9 | 554 | Text post |
| 10 | 561 | Text post |
| 11 | 555 | Text post |
| 12 | 787 | Text post |
| 13 | 594 | Reaction |
| 14 | 555 | Text post |
| 15 | 556 | Text post |
| 16 | 627 | Text post |
| 17 | 594 | Reaction |
| 18 | 578 | Text post |
| 19 | 594 | Reaction |
Its other estimates were less accurate. It classified the largest message as a long post. That message was short, and its size came from a file reference. It overestimated the length of the shortest posts by about 10 characters, and estimated the one long post to within about 20. Size reveals the byte length of the whole message, including fields other than the text. Padding to fixed sizes would hide it, at a bandwidth cost on every message. Whether the spec will require it is undecided.
Segment sizes
A segment that holds one message is about 5.3 KB. Most of that is the sender's msg-key, the certificate that binds their message key to a device in their identity chain. It carries a 3,373 B composite signature.
Each segment includes each sender's certificate once, so it can be verified on its own. Messages from one sender share a certificate. So the first segment of the rules channel, with six messages and one certificate, is
smaller than two single-message segments.
Show the numbers
| Channel | Messages | Size (B) | Certificates |
|---|---|---|---|
| Rules | 1–6 | 10,176 | 1 |
| Rules | 7–7 | 5,598 | 1 |
| Rules | 8–9 | 6,455 | 1 |
| Rules | 10–10 | 5,348 | 1 |
| Intros | 1–7 | 23,226 | 4 |
| Intros | 8–9 | 10,665 | 2 |
| Intros | 10–10 | 5,315 | 1 |
| Intros | 11–11 | 5,309 | 1 |
| Intros | 12–13 | 10,861 | 2 |
| Intros | 14–14 | 5,309 | 1 |
| Intros | 15–15 | 5,310 | 1 |
| Intros | 16–19 | 21,325 | 4 |
Inbox cursors in rerouted
One result concerns rerouted, the reference community server, not the protocol. Each inbox item has a cursor, which a device returns to acknowledge what it has processed. The client received 77 items, and the last cursor was 1,459. rerouted assigns cursors from a single counter for everything the server accepts. The difference between consecutive cursors therefore counts traffic in channels the member can't see.
The API conventions define cursors as opaque strings, and clients aren't allowed to parse them. rerouted can change how it assigns them without a protocol change, for example with a cursor per device.
Changes for Reroute
Some results concern the Reroute app, not Tieroute:
- Avatars are stored as uploaded, including metadata such as the software that made a screenshot. Reroute should strip metadata before upload.
- One member's display name and avatar imitated an add button. Both are free-form, so no client can reliably detect imitation. Handles are unique, though. Reroute can show the handle whenever two members' display names match.
- A device name is published in the identity chain. The protocol makes it optional, so Reroute can omit it by default.
Next steps
- An implementer outside Reroute Holdings LLC runs their client against the history test vectors. So far, only Reroute Holdings LLC has checked them.
- Reroute encrypts with the newest history key, and treats a segment that fails to parse as a gap.
- rerouted assigns cursors that don't reveal activity in other channels.
- A decision on whether the spec requires padding, with what the community server can see documented either way.
Report errors or questions on the issue tracker. The full history segment construction is in §16.5 of the specification.