Portable, shareable profiles for matching
A fraglet captures a single facet of characteristics as both human-readable text and a high-dimensional vector embedding: a music sensibility, a dining style, a neighbourhood's character. Interpretable by people, computable by machines.
Fraglets are not personal data stores. They are shared artefacts: anyone can associate with a fraglet, adopt it, or build on it. Hosted at fraglet.org, addressable by URI, and matchable by vector similarity, they give any service the ability to understand characteristics without building a behavioural model from scratch.
Every service that wants to match people to things faces the same structural problem: it must build its own model of what each person wants, from scratch, using only the data it can collect within its own walls. The result is redundant, opaque models that users cannot inspect or carry between services.
A music streaming service knows your listening habits but a concert discovery tool does not. A property platform knows nothing about the neighbourhood sensibility you've expressed elsewhere. Each platform starts from zero, and the person it describes has no way to help.
The fraglet proposes a different architecture: extract characteristics into small, structured, shareable units that exist independently of any single service.
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 venue, a neighbourhood, or an organisation 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 a taste profile; readers adopt it as a starting point.
A fraglet follows a domain-agnostic schema. Any service implementing the pattern can accept and match against 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 expresses your taste 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.
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.
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 match against 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 matched against a catalogue of options 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
Match collaborators, mentors, or events by working style, intellectual interests, and values rather than job title and seniority. Surface alignment that LinkedIn endorsements cannot.
Example fraglet: "Systems-Thinking Generalist" – cross-disciplinary problems, async-first, small teams shipping fast
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="gpt-4o-mini",
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;The first production implementation of fraglets powers MostMaker, a personalised live music discovery service for London.
User connects Spotify playlists or selects artists
GPT-4o-mini produces a structured music fraglet
pgvector cosine similarity ranks hundreds of upcoming gigs
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 – the same pattern as Stripe or OpenAI. The API is 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.
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.