A fraglet is a short written description of one side of someone's taste: how they like to eat, what they listen to late at night, how they travel. It's stored as plain text plus a vector embedding, so a person can read it and a program can compare it with other things. Fraglets can describe places and organisations too, such as what a venue books or what a lab needs from its suppliers.
An agent or service that can read your fraglets doesn't have to start by asking you twenty questions, and you decide which ones each service sees. Fraglets aren't tied to one person. You can use ones other people have published, and group several into a jacket for a particular situation. Agents connect over MCP. You can make your own at fraglet.com.
Any service or agent that acts for you needs to know something about you first. At the moment it finds out by asking: sign-up questionnaires, preference sliders, or a long chat before it's any use. None of that carries over, so the next service asks again.
Say you're moving to a new city and an agent is helping. It's dealing with letting agents, schools, local services and neighbourhood searches, and each of them would do a better job if it knew what you're like. Businesses have the same gap. A supplier of lab equipment has little idea what a particular lab needs, and a travel site can't see the taste you've already described somewhere else.
A fraglet lets you write that down once, in a form any agent or service can read, and choose who gets to see it.
A short, structured description of one facet of a person's taste, or of a place or organisation, within a single domain. It has readable text fields and a vector embedding made from them, so people can read it and machines can compare it.
The name is fragment plus -let: a small piece, not a whole profile. Most people would have several, across domains and sometimes within one. You might have one music fraglet for working and another for Saturday night. A lab, a venue, a neighbourhood or a product range can have fraglets too.
Every fraglet uses the same schema whatever the domain, so any service that understands the format can use one without integrating with the place it was made.
Each fraglet has a title, a one- or two-sentence brief, and a longer detail. A service takes as much as it needs. When fraglets from several people are combined, the titles are usually enough to see what went in.
A language model writes the first draft from whatever you give it: a playlist, a list of favourite restaurants, a few sentences. You then fix anything it got wrong.
A fraglet has no name, email, location or history in it. It describes taste, not a person. You might have several music fraglets and share a different one depending on the occasion.
You can import what an AI assistant already knows about you, find an open fraglet that fits, or adapt someone else's. Making one from scratch goes like this.
A playlist, a list of liked items or favourites, or a few sentences in your own words. It can come from another platform's API or be typed in directly.
A language model turns the input into JSON that fits the fraglet schema: a title, a brief, a longer detail, a category, tags, and any domain-specific extras.
The text fields go through an embedding model (currently text-embedding-3-large) to produce a vector. Services use the vector to find similar items in their own catalogues.
You read what was generated, change anything that doesn't sound like you, and save. The embedding is regenerated from the edited text.
Many people can associate with the same fraglet. Who can see it depends on its visibility setting.
Adoption is what separates fraglets from a private profile. A music venue could publish a fraglet describing what it books, a food critic could publish their palate, or a community could keep a shared one. Other people can then take these on as their own. Changing an adopted fraglet creates a new one linked to the original, so you can always see where it came from.
Fraglets are small enough to combine. A service can take one from each person in a group, average the embeddings and search its catalogue with the result, for friends picking a restaurant or a team choosing somewhere for an away day. It can also show the group the titles that went in ("Late-night small-combo jazz", "Big festival stages", "Ambient and drone"), so everyone can see what the search was based on. A merged preference profile can't do that.
A jacket is a named set of fraglets for a particular mood or situation.
A date-night jacket might hold your food fraglet, a cocktail fraglet you found from someone else, and your taste in live music. A work-travel jacket might be mostly hotels and eating alone. Jackets usually span several domains, because most situations do.
You can publish a jacket for other people to try on or adapt: a critic's picks, a friend's night-out setup, an editorial "72 hours in Edinburgh". Once anyone else has associated with your jacket, its contents are fixed. To change it you adapt it, which makes a new version and leaves the original alone for everyone using it.
An agent can work through a jacket. By default it favours the jacket's fraglets but still uses others when they're relevant. In strict mode it uses only what's in the jacket, for times when you want to be careful about what gets shared.
Fraglets are available as Model Context Protocol tools, so any agent that supports MCP can read, create and manage them.
Once the server is added to a client such as Claude, Cursor or OpenClaw, the agent can use fraglets directly. You don't need an SDK or your own API client.
Most of the work is done by the picker. Given what you're trying to do, a language model chooses which of your fraglets are relevant and how much detail to send. Ask for a restaurant tonight and it sends the briefs of your food fraglets, not the full detail of your music taste. It can also work through a jacket.
Agents can also create fraglets, find open ones, associate with other people's, build jackets and change visibility.
fraglet.org is a central service that stores fraglets and serves them over a REST API. Any developer can register, get an API key and start creating and reading fraglets straight away.
Authentication works the way it does for Stripe or OpenAI. Your
key starts with frag_live_ and goes in an
Authorization: Bearer header.
Every fraglet has the same core fields. Anything specific to a domain goes in the additional field, so a music fraglet and a food fraglet look the same to a client.
Each fraglet lives at api.fraglet.org/api/v1/fraglets/{id} and can be fetched with one request, if its visibility allows.
Because every fraglet is on the same host, nobody has to work out where one lives or set up integrations between services. Any service with a key can read the fraglets it's allowed to see.
Every fraglet has the same fields, whatever the domain.
An additional field holds anything specific to a domain,
such as sub-profiles or extra metadata, without changing the core
fields.
The format isn't specific to taste. It works anywhere an agent or service would benefit from a readable description of a person, place, organisation or thing.
MostMaker generates a music fraglet from Spotify listening and matches it against embedded gig listings to find upcoming shows, then filters by venue, location and date.
Example: "Acoustic folk, small rooms": storytelling songwriters, folk with West African and Balkan influences, grassroots venues
Diet, cuisines and the kind of place you like to eat. A fraglet can say "goes looking for Sichuan mala heat" where a category filter can only say "likes spicy food". MostMaker matches food fraglets against London restaurants.
Example: "Regional Italian and ferments": regional Italian, fermented foods, neighbourhood places over fine dining
How you like to travel: busy or slow, local neighbourhoods or resorts, budget and access needs. Can be shared with booking sites or the people you're going with.
Example: "Side streets and street food": local neighbourhoods over tourist centres, eating standing up, walking rather than taxis
More than genre: hard science fiction or space opera, plot or character, short books or long series.
Example: "Near-future, unreliable narrators": near-future fiction, narrators you can't trust, prose worth re-reading
What a neighbourhood is like matters as much as floor area: walkability, nightlife, parks, how much of a community there is. A price-and-bedrooms filter can't capture that.
Example: "Leafy, independent, cyclable": leafy streets, independent shops, good coffee, cycling distance to the centre
Describes what a lab does, what it's researching and what equipment it needs, then matches that against product catalogues using the same similarity search as the music and food examples.
Example: "High-throughput materials characterisation lab": XRF and ICP-OES for elemental analysis, 200+ samples a week, ISO 17025 accredited
You need three pieces: a step that generates the fields, an embedding step, and a similarity search. Here's a minimal version.
{
"title": "string",
"brief": "string — 1-2 sentence summary",
"detail": "string — longer description",
"category": "string — primary classification",
"tags": ["string — searchable descriptors"],
"additional": {
"domain": "string — e.g. music, food, travel",
"sub_profiles": [
{ "facet": "string", "examples": ["string"] }
]
},
"embedding": "float[] — similarity vector"
}
import json
from openai import OpenAI
client = OpenAI()
def create_fraglet(user_input: str, domain: str) -> dict:
"""Generate a fraglet from user preference signals."""
# 1. Structured generation via LLM
response = client.chat.completions.create(
model="your-preferred-model",
response_format={"type": "json_object"},
messages=[{
"role": "system",
"content": f"Analyse this {domain} preference data. "
f"Return JSON with: title, brief, "
f"detail, category, tags, additional."
}, {
"role": "user",
"content": user_input
}]
)
fraglet = json.loads(response.choices[0].message.content)
# 2. Embed for similarity matching
embed = client.embeddings.create(
model="text-embedding-3-large",
input=f"{fraglet['title']} {fraglet['detail']}"
)
fraglet["embedding"] = embed.data[0].embedding
return fraglet
-- Retrieve items ranked by similarity to a fraglet
-- using pgvector cosine distance
SELECT
id, title, description,
1 - (item_embedding <=> fraglet_embedding) AS similarity
FROM items
WHERE 1 - (item_embedding <=> fraglet_embedding) > 0.3
ORDER BY item_embedding <=> fraglet_embedding
LIMIT 20;
London recommendations for restaurants, gigs, the Proms and theatre. Food fraglets are matched against restaurant descriptions and music fraglets against upcoming gigs, and it can find options that suit a whole group.
Industrial product discovery. Hundreds of fraglets describing what organisations need are matched against tens of thousands of product standards.
Where people make, find and adapt fraglets and put them into jackets. It runs the MCP server and the picker, and has a pairwise jacket builder.
A recommendation algorithm builds a hidden model of you inside one platform. A fraglet is written down where you can see it, and it isn't tied to any platform. You can read it, edit it, use it with other services, or let other people adopt it.
If a fraglet is open, anyone can associate with it as it is or make their own version. A reader who shares a food critic's taste could associate with the critic's fraglet directly, or derive a variation from it. The original doesn't change. Any modification creates a new fraglet that links back to it.
Yes. Set the visibility to private when you create a fraglet through the API, and only your service can read it. You can also share fraglets selectively or publish them openly. That's up to you and your users.
Register on the developers page to get a key. It starts with frag_live_ and goes in the Authorization header as a Bearer token. The API is at api.fraglet.org.
An embedding model turns the fraglet's text into a vector. If a catalogue's items (gigs, restaurants, books) are embedded with the same model, you can rank them by cosine similarity to the fraglet. This finds matches that keyword or category filters miss.
Yes. The schema and format spec are public, and so is a guide to building your own server. Anyone can get a fraglet.org API key, with no approval step or fee.