A portable unit
of character

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.

Starting from zero

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.

What is a fraglet

fraglet /ˈfraɡ.lɪt/ noun

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.

Portable

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.

Three levels of detail

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.

Drafted by a model, edited by you

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.

No personal data

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.

How a fraglet is made

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.

1

Start with some input

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.

2

Generate the fields

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.

3

Embed

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.

4

Review

You read what was generated, change anything that doesn't sound like you, and save. The embedding is regenerated from the edited text.

Visibility and adoption

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.

Group matching

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.

Jackets

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.

Built on MCP

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.

The fraglet.org API

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.

One schema

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.

Stable addresses

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.

Structure of a fraglet

Every fraglet has the same fields, whatever the domain.

title string A short, readable name "Late-night small-combo jazz"
brief string One or two sentences "Post-bop and modal jazz in small rooms, ideally after 10pm, played by people who stretch a standard rather than play it straight."
detail string A paragraph with the specifics "Ahmad Jamal and Shabaka Hutchings at the centre, with detours into ECM and spiritual jazz. Seated venues under 200 capacity..."
category string Main classification within the domain "Contemporary Jazz & Fusion"
tags string[] Keywords for filtering and search ["jazz", "post-bop", "modal", "small-venues"]
embedding float[] Vector used for similarity search (1536 dimensions) [0.0234, -0.0891, 0.0412, ...]

An additional field holds anything specific to a domain, such as sub-profiles or extra metadata, without changing the core fields.

Application domains

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.

Live music

In use

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

Food & dining

In use

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

Travel

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

Books & media

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

Property

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

Scientific equipment

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

Implementation

You need three pieces: a step that generates the fields, an embedding step, and a similarity search. Here's a minimal version.

fraglet_schema.json
{
  "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"
}
generate_fraglet.py
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
match_items.sql
-- 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;

Where it's running

MostMaker

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.

B2B pilot

Industrial product discovery. Hundreds of fraglets describing what organisations need are matched against tens of thousands of product standards.

fraglet.com

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.

Questions

How is this different from a recommendation algorithm?

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.

What does it mean to adopt a fraglet?

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.

Can a service keep its users' fraglets private?

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.

How do I get API access?

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.

How does the similarity matching work?

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.

Is the format open?

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.