A fraglet is a structured description of characteristics, encoded as human-readable text and a vector embedding. A music sensibility. A laboratory's analytical capabilities. A neighbourhood's character. When an agent reads a fraglet, it gains the context it needs to act competently on your behalf. Composable building blocks of identity that you choose how to present.
Fraglets are shared artefacts, not personal data stores. Anyone can associate with a fraglet, adopt it, or build on it. Compose them into jackets: personas for different contexts, built from your own fraglets and ones you've discovered from others. Your agent presents different facets of you to different services, and you control which. Built on MCP. Create and manage them at fraglet.com.
Every agent and service that needs to act on your behalf faces the same problem: it doesn't know you. It has no structured understanding of who it's working with. The current fix is to spend time teaching it — repeated explanations, intake forms, twenty-question interviews. And none of it transfers. Each new service starts from zero.
You're relocating to a new city. Your agent needs to work with estate agents, schools, local services, and neighbourhood searches simultaneously. Each one needs context about you, and none of them have it. A procurement platform has no visibility into what a laboratory actually needs. A travel agent knows nothing about the sensibility you've expressed elsewhere.
A fraglet is how you make yourself legible. A structured description that any agent or service can read, reason about, and act on. You choose what to present, and in which contexts.
A small, structured unit that captures a single facet of characteristics within a given domain. Composed of human-readable descriptive fields and a vector embedding derived from those fields. People can read it; machines can compute with it.
The term combines fragment, acknowledging that any single representation captures only a facet, with the diminutive -let, suggesting a small, self-contained unit. A fraglet is deliberately focused: not a comprehensive profile, but one composable piece. A person may hold multiple fraglets across different domains, or multiple fraglets within the same domain representing different moods, contexts, or facets of character. Fraglets are not limited to people. A laboratory, a venue, a neighbourhood, or a product line can be described by fraglets too.
Fraglets are not personal data stores. They are shared artefacts that anyone can associate with, adopt, or derive from. A venue publishes a fraglet describing its character; hundreds of people associate with it. A critic publishes their palate as a fraglet; readers adopt it as a starting point.
Fraglets combine into jackets: named collections representing personas for different situations. A date-night jacket mixes food, music, and travel fraglets. A work-travel jacket focuses on hotels and solo dining. Your own fraglets alongside ones you've picked up from others, adapted to fit.
A fraglet follows a domain-agnostic schema. Any service or agent implementing the pattern can read and act on it, without requiring integration with the originating platform.
Three levels of resolution: a title, a brief, and a full detail. A service chooses how much to see. When combining fraglets from multiple people, the title level keeps the group readable at a glance.
Large language models analyse input signals and produce a structured fraglet. The user reviews and adjusts the output, ensuring the representation genuinely reflects their characteristics.
A fraglet describes characteristics but contains no personal data. No name, email, location, or behavioural history. You might have several music fraglets for different moods and choose which to share in a given situation. The selection itself is part of the expression.
Creating from scratch is one path. You can also import what your AI already knows about you, discover open fraglets that fit, or adapt someone else's fraglet into your own version.
The user provides a signal: a playlist, a set of liked items, a list of favourites, or free-text descriptions of their characteristics. The signal can come from an existing platform via API or from direct input.
A large language model analyses the input and produces a structured JSON object: a descriptive title, a brief summary, a detailed narrative, categorical tags, and domain-specific sub-profiles. The output is constrained to the fraglet schema.
The descriptive text fields are passed through an embedding model (e.g. text-embedding-3-large) to produce a high-dimensional vector. This embedding captures the semantic essence of the fraglet, enabling similarity computation against item catalogues.
The user reviews the generated fraglet, modifies any fields that don't accurately reflect their characteristics, and saves it. The embedding is regenerated to reflect edits. The fraglet is now ready to be shared or published.
A fraglet is a shared artefact, not a personal record. It can be associated with by many, adopted as a starting point, or derived into new variations, depending on its visibility.
Adoption is a distinctive feature of the model. A music venue might publish a fraglet that describes its programming sensibility. A food critic might publish their palate for readers to adopt. A community could maintain a shared fraglet that represents its collective character. In each case, the fraglet is authored by one and meaningful to many. Modification creates a new fraglet linked to the original, so provenance is preserved.
Because fraglets are small, focused units, they combine naturally. A service can collect one fraglet from each person in a group, average the embeddings, and match the result against its catalogue. A list of titles ("Nocturnal Jazz Wanderer", "Festival-Stage Rock Fan", "Ambient Explorer") is immediately legible in a way that a merged preference blob is not. Groups of friends finding a restaurant, teams choosing an offsite, households selecting an energy tariff. The unit nature of fraglets makes combination tractable.
A jacket is a named collection of fraglets that acts as a persona. Not a category. A mood, a situation, a way of presenting yourself.
A date-night jacket might combine food preferences, a cocktail fraglet you discovered from someone else, and your taste in live music. A work-travel jacket focuses on hotel preferences and solo dining. The fraglets in a jacket can be your own creations, ones you've adopted from others, or adapted versions of both.
Jackets are cross-domain by design. They cut across food, music, travel, and whatever other domains your fraglets cover. This is what makes them useful: real situations are never single-domain.
You can publish a jacket for others to try on, adapt, or make their own. A food critic's picks, a friend's going-out persona, an editorial "72 hours in Edinburgh." Once others associate with your jacket, the composition is frozen. To change it, you adapt: fork a new version with your modifications, leaving the original intact for everyone else.
When an agent acts on your behalf, it can scope its view through a jacket. The picker prioritises that jacket's fraglets while still accessing the rest when relevant. Or it can restrict entirely to the jacket's contents, for situations where you want tighter control over what gets shared.
Fraglets use the Model Context Protocol. Any MCP-compatible agent can read, create, and manage fraglets as tools.
Claude, Cursor, OpenClaw, or whatever comes next. If your agent speaks MCP, it works with fraglets. No special integration, no SDK, no API client to build.
The key tool is the picker: an LLM that selects which of your fraglets are relevant to a given intent, at the right level of detail. Ask your agent to find a restaurant for tonight and it picks your food fraglets at summary level, not your music taste at full detail. The picker can be scoped through a jacket, prioritising that persona's fraglets.
Agents can also create fraglets, discover open ones, associate with fraglets from others, build jackets, and manage visibility. The full lifecycle is available as MCP tools.
Fraglets are hosted at fraglet.org: a centralised service that stores, manages, and serves fraglets over a standard API. Any developer can register, get an API key, and start creating and consuming fraglets immediately.
The API is designed to be familiar. If you've integrated with
Stripe or OpenAI, the pattern is the same: register, get a key
prefixed frag_live_, and authenticate with
Authorization: Bearer.
Every fraglet conforms to the same structural schema. Domain-specific extensions use the additional field, preserving core compatibility across music, food, travel, and any future domain.
Register as a developer and receive an API key. Keys use the frag_live_ prefix, making them visually identifiable. Authenticate every request with a simple Bearer token.
Every fraglet has a stable, resolvable address at api.fraglet.org/api/v1/fraglets/{id}. Linkable, cacheable, and fetchable with a single HTTP request, subject to visibility controls.
A single centralised service means no discovery problem: every fraglet lives at the same host. Any service with an API key can create, read, and use fraglets immediately, without bilateral integration or server-to-server coordination.
Every fraglet conforms to a consistent schema, regardless of domain. The uniform structure is what makes them interoperable.
The schema supports an additional field for domain-specific
extensions (sub-profiles, facets, contextual metadata) without breaking
cross-domain compatibility.
The fraglet pattern works across domains. Any context where structured characteristics need to be legible to agents and services is a candidate, whether that means people, places, organisations, or things.
Generate a fraglet from Spotify listening data. Match against vector-embedded gig listings to surface upcoming shows aligned with individual taste. Filtering by venue type, location, and date range.
Example fraglet: "Eclectic Folk Adventurer": drawn to acoustic storytelling, world music influences, and grassroots venues
Encode dietary preferences, cuisine affinities, and dining context. Distinguish between "enjoys spicy food" and "specifically seeks Sichuan mala heat," a level of nuance that category filters cannot express.
Example fraglet: "Curious Omnivore": regional Italian, fermented foods, and neighbourhood spots over fine dining
Capture travel style and sensibility: adventure vs. relaxation, cultural immersion vs. resort comfort, budget constraints and accessibility needs. Share with booking platforms or travel companions.
Example fraglet: "Off-Grid Culture Seeker": local neighbourhoods over tourist centres, street food, walking over taxis
Move beyond genre labels. Capture whether a reader prefers hard science fiction or space opera, plot-driven narratives or character studies, short-form or sprawling series.
Example fraglet: "Speculative Realist": near-future fiction, unreliable narrators, and prose that rewards re-reading
Neighbourhood character matters as much as square footage. Encode whether a person prioritises walkability, nightlife, green space, or community feel. Qualities that don't fit in a price/bedroom filter.
Example fraglet: "Urban Village Dweller": leafy streets, independent shops, good coffee, cycling distance to centre
Describe a laboratory's analytical capabilities, research focus, and equipment needs. Match against product catalogues using the same vector similarity pipeline that works for music and food. The domain is different. The mechanism is identical.
Example fraglet: "High-throughput materials characterisation lab": XRF and ICP-OES for elemental analysis, sample volumes of 200+ per week, ISO 17025 accredited
The fraglet pattern requires three components: a structured generation step, an embedding step, and a similarity search layer. Below is a minimal reference implementation.
{
"title": "string",
"brief": "string — 1-2 sentence summary",
"detail": "string — rich 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"
}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;Three implementations are live, spanning entertainment, B2B product discovery, and the consumer platform itself.
Personalised London restaurant and live music discovery. Spotify data in, music fraglet generated, pgvector similarity ranks hundreds of upcoming gigs.
Industrial product discovery. Hundreds of fraglets describing organisational needs matched against tens of thousands of product standards. The same pattern, a different domain entirely.
The consumer platform. Create, discover, adapt, and compose fraglets into jackets. Includes an MCP server, the picker, and a pairwise jacket builder.
A recommendation algorithm builds an implicit model of your preferences inside a closed system. A fraglet is an explicit, structured profile that exists independently of any platform. You can inspect it, refine it, share it across services, or let others adopt it. Control sits with the people who associate with fraglets, not the platform.
When a fraglet is published openly, anyone can associate with it as-is or derive a new version from it. A food critic might publish their palate as an open fraglet; a reader who shares similar taste can associate with it directly, or derive their own variation. The original persists unchanged for everyone else. Modification always creates a new fraglet linked to the original.
Yes. When creating a fraglet via the API, a developer can set its visibility to private. Private fraglets are visible only to associated developers. The sharing model is a spectrum: a developer might keep fraglets private, share them selectively, or publish them openly. The decision sits with the developer and their users.
Register as a developer at fraglet.org and receive an API key. Keys are prefixed frag_live_ and used as Bearer tokens in the Authorization header . Same pattern as Stripe or OpenAI. API at api.fraglet.org.
Every fraglet has a stable URI at api.fraglet.org/api/v1/fraglets/{id}. Any service with a valid API key can fetch it, subject to visibility controls. Fraglets are linkable, cacheable, and fetchable with a single HTTP request.
When a fraglet is created, its descriptive text is converted into a high-dimensional vector via an embedding model. Items in a catalogue (gigs, restaurants, books) have their own embeddings derived from their descriptions. Cosine similarity between the fraglet vector and item vectors produces a ranked list of matches, picking up on relationships that keyword or category filters would miss.
A named collection of fraglets representing a persona for a mood or situation. A date-night jacket might combine food, music, and cocktail fraglets. Jackets are cross-domain. They can include your own fraglets alongside ones you've discovered or adapted from others. Publish a jacket for others to try on, or keep it private.
Via MCP (Model Context Protocol) tools. The picker selects relevant fraglets for a given intent at the right level of detail. Agents can also create fraglets, discover open ones, build jackets, and manage visibility. Any MCP-compatible agent works with fraglets without custom integration.
Yes. Open fraglets are discoverable by anyone. You can associate with one as-is, or adapt it to make your own version. You can also compose jackets from any combination of your own fraglets and ones you've picked up from others.
The schema, protocol, and pattern are open and documented. The format specification and reference implementation guide are publicly available. The fraglet.org API is accessible to any developer with an API key. No approval process, no licence fee.