open contract · independent implementations · live pods

Your data belongs to you

Your calendar lives in one app, your notes in another, your AI memory in whichever assistant you used last. Changing tools should not mean leaving your knowledge behind.

Put that knowledge in a pod you control. Give it meaning through linked data. Let apps and agents come to it with permission. They can change; your data keeps its own home.

try it yourself

Query a real pod

A venue in Chemnitz publishes its events from its own pod. Read three events with ordinary SPARQL, without an account, API key or SDK:

curl -X POST https://sempods.org/aaltra/_system/sparql/query \
  -H "Content-Type: application/sparql-query" \
  -H "Accept: application/sparql-results+json" \
  --data 'PREFIX schema: <https://schema.org/>
SELECT ?e ?name ?start WHERE {
  ?e a schema:Event ; schema:name ?name ; schema:startDate ?start
} ORDER BY ?start LIMIT 3'

The result contains event addresses, names and dates. Follow an event address to read its JSON-LD description.

One example, three useful properties

Shared meaning

The query uses schema.org's Event and startDate terms. The event's JSON-LD description uses them too. Another app can recognize an event without learning a private data format.

Links you can follow

An event's URI is its address. Follow it to get the resource, then follow its links. Knowledge stays connected beyond the app that created it.

A home outside the client

A venue website, calendar app and agent can read from the same pod. Each can build its own view while the venue keeps the source data.

A common way into independent data spaces

sempods brings HTTP, RDF, JSON-LD, SPARQL and authorization into one open pod contract. It defines what clients can rely on while leaving room for different stores, software stacks and deployments.

Permissions belong with the data. A public visitor can read the event title and date; a trusted app may also reach private planning notes. The pod enforces that boundary across resource reads, queries and agent tools. See how the pieces fit.

AI can use your memory without owning it

An agent is another client of your pod. It can find relevant resources, follow links and work with the knowledge you allow it to see. Its access can end while the knowledge stays in your space.

That is useful beyond personal memory. Teams, communities and publishers can build on the same idea: useful knowledge with its own address, meaning and permission boundary. Explore the cases.

Choose where you want to begin

The specification defines the contract independently of any implementation. sempods-kotlin supplies client libraries, reusable services and a reference composition. Its current release is 0.2.0.

Build an app against a pod, implement the contract in your own stack, or compose a server from the Kotlin modules. The local composition is for development and evaluation; supported upgrades belong to a concrete deployment.

The project is still young, and feedback is welcome. The specification is still in development, and a conformance suite remains unfinished. See what is available and what comes next.

Build an app Implement the contract Run a pod Discuss the model