An open interoperability protocol
A common way to coordinate help.
So aid can flow across systems.
An open format for the places aid runs on — shelters, collection centres and service points — published at a public URL any app can read. Conformance is measured by a public validator, never declared; the registry shows what it found.
The thesis
We grow together: we don’t compete, we feed each other.
Cabuya is the fibre you tie things with. A single thread holds nothing; twisted together, they carry what no one of them could. That is not a metaphor about collaboration in general — it is a description of what happens when two applications can read each other’s data.
Every app that joins keeps its own product, its own users and its own decisions. What it gains is that its records stop being trapped inside it, and that it can read everyone else’s without asking.
That is what the protocol is for. Whether it happens depends on the teams who adopt it, and none of it is achieved yet.
How it works
Four steps, and none of them need us
Nothing here requires an account, an approval, or a conversation with anyone. The protocol is a document; the validator is a program you can run yourself.
- 01
Publish a manifest
One JSON file at a known path that says who you are, what you publish, and under which licence.
- 02
Export a feed
Your places, in the shared schema. A static file at a stable URL is enough — no API required.
- 03
Run the validator
It fetches what you published and reports what it found. Every finding locates the problem and states the correction.
- 04
Open a registry entry
A pull request. The measurement happens on our side and is visible to anyone who looks.
What joining means
Your data stays yours. A copy travels.
The protocol rests on two facts, and everything else follows from them.
Many apps will exist — and that is fine
In every emergency, teams build their own boards, maps and directories, often for the same city. The protocol does not replace any of them; it connects them, and each keeps its own product, its own users and its own database.
The data is sensitive
So the shared layer carries places and facts, never people: no names, no phone numbers, no personal contact. That is excluded by design, not by good intentions.
You publish a copy
Your app keeps its own database exactly as it is. What you add is a public copy of your records in the shared format, at a web address you choose — a plain file or an endpoint, both count as the same feed.
Other apps show your records
Any app can read that address and display what you published, always saying which app it came from and where it is — each record travels with its own town and neighborhood.
Every button leads back to you
When someone wants to act on a record, the button takes them to the app that published it. Contact details never travel in the feed, so the origin is where help gets resolved.
What you end up publishing
example.org/.well-known/cabuya.json ← the manifest — who you are and where your feed lives
example.org/cabuya/places.json ← the feed — your records, in the shared format
One record, trimmed:
{
"name": "Coliseo Municipal",
"place_kind": "shelter",
"municipality_text": "Pereira",
"neighborhood_text": "Centro",
"lifecycle_status": "active",
"public_url": "https://example.org/places/coliseo"
}A public validator measures whether what you publish conforms, and the registry shows the result. None of it needs an account or our permission.
The network
Who is in the registry
The registry lists applications, records what was measured, and does nothing else. It is not a directory of partners and it does not rank anyone.
| Application | Publishes | Entry state |
|---|---|---|
| ayuda.corag.app | place | Proposed |
| emergenciacolombia.org | place | Proposed |
| pereiraayuda.com | place | Proposed |
| pereiraresponde.co | place | Proposed |
| co.crafter.run | place | Proposed |
Most of these entries were opened on each team’s behalf from the public analysis, and are waiting for that team to confirm them; the rest were filed by the teams themselves. Nobody here has claimed conformance, and none of these are endorsements.
Measured conformance states appear here when the validator starts running against live feeds on a schedule.
The long horizon
Ambition, not roadmapWhere this could go
- 1
An emergency network
Apps built during one emergency can read each other, so the next one starts with infrastructure instead of a spreadsheet.
- 2
An interoperability standard
The schema outlives the emergency that produced it, and becomes the ordinary way aid data is published.
- 3
A regional ecosystem
Another city, another country, adopts the same document without asking anyone — because it is CC0 and there is nobody to ask.
The specification is public. So is everything behind it.
The normative text, the schemas, the validator and the decisions that produced them are all in the repository, under an open licence, today.