MyJackfruit wordmark

Pre-launch website · All subject to change

Join the list

It's all about your information.

Apps come and go. Information stays. Your data lives in your vault, your users' data lives in theirs, and every record knows what it means. Each owner decides who sees it.

Your information lives in your vault.

A vault is your own place for information. It belongs to you, not to the apps that use it. Banano Vargas Farm keeps its records in its own vault, the shipping company in its own. When the farm changes apps, its records stay where they are.

  • Yours from the first second.

    Every account comes with its own vault. There is no signing in without one.

  • As many as you need.

    One for you, one for the company, one for each project. A company vault can hold project vaults inside it. The farmer can have one vault for the farm company, and another for production.

  • Always owned by a person.

    However deep the tree goes, every vault traces back to one person who owns it. "Whose is this?" always has an answer.

  • Hand it over without breaking it.

    Sell the product, spin out the project, pass on the family archive. The vault changes owner. Its address and its links stay the same. Sell the farm, and its vault goes with it. Every crate keeps its address and its links.

  • Records and files, together.

    Notes, contacts, machines, contracts, photos. A file is a record too, with its type, its links and its history. The crate's record, its photo and its shipping papers sit together.

  • Listed, or out of sight.

    Put a vault in the public directory, or keep it private. Either way, what is inside stays behind your grants.

  • Take it all with you.

    Export a whole vault in one go: every record, every link and every file, in plain JSON any tool can open. Leave whenever you want.

Bring what you have.

Import spreadsheets and linked data. You map each sheet to a type and each column to a field, once, and every row becomes a typed record. Export gives you the original back. Banano Vargas Farm's harvest spreadsheet comes in as crates, each one linked to the farm.

Apps visit. Your information stays.

In most software the app and its data are one thing, so leaving the app means leaving your information behind. Here they are kept apart. Your information lives in your vault, and apps come to it. They read and write what you allow, and keep nothing of their own.

  • Many apps, one set of facts.

    A contact written by one app is the same contact in the next. The shipping app and the shop's app read the same crate 42. Nothing to copy, sync or import.

  • Change the app. Keep everything.

    Rebuild the app, replace it, or run two side by side. The information stays where it is, and keeps its meaning.

  • Your next app starts full.

    Whatever you build next opens on everything you already have, typed and linked, on day one. A new ripening app opens on every crate the farm already has.

  • AI agents visit too.

    An AI agent is one more visitor. It gets its own access, and only what you grant it.

    Learn more about AI agents in the platform

You decide who sees what.

Access is set on the information itself, not inside each app. So every app and every AI agent follows the same rules, and nothing is visible until you share it.

  • Who.

    A person, or a group of people. An AI agent gets its own access the same way.

  • What they may do.

    Read, or write. The right to hand out access stays with you, unless you pass it on.

  • How much.

    One record. A whole branch of records. Every record of one kind inside that branch. A whole vault. Or one vault's reach into another.

  • Until when.

    Until you take it back. Then the access is gone, in every app at once.

  • Starting from nobody.

    A new record is seen by no one but you until you share it. A new crate is seen by no one but the farm until it shares it.

  • Nine levels for people.

    On a profile, every field carries its own sharing level, from Public to Private.

    Nine levels, not a checkbox

The same people, in every app.

People sign in with the platform, not with each app. Who they are, the groups they belong to and what you have shared with them come along to every app you build.

  • Sign in once.

    Your app's users sign in with the platform, with a passkey or a one-time code by email. No user table to build. No passwords to keep. The farmer signs in once and uses both the farm app and the payment app.

  • Invite once.

    Set up the pickers, the crew, the family or the board as a group one time. Every app you build already knows them.

  • The people are already here.

    People who already use apps on the platform, like MyNet, can use your app with their consent, without signing up again.

  • Everyone owns their own.

    Each of your users has a vault of their own. Your app works with what they share with it, and they can take it back.

Every thing has its own address.

Every record gets a web address the moment it is made. The address belongs to the thing, not to a page in some app, so it never changes. A QR code on crate 42. Scan it in Rotterdam or in Oslo and anyone allowed sees where it is now and every stop it made.

  • An address for life.

    Rename the thing, change it, hand it to a new owner. The address stays the same.

  • Print it as a QR code.

    Because the address never changes, you can print it. A QR code on the machine, the door or the crate opens that thing, latest state, with its history behind it.

  • Public or private, per thing.

    Make a product page anyone can scan. Or keep it to the people you granted, and everyone else sees nothing. The family scans the sticker on their bunch and sees the farm it came from.

  • Links that keep working.

    Link to a thing from an email, a report or another app. The link keeps working, because the address never moves.

  • Bring your own URL.

    Put your own domain in front, so your customers see your name. Behind it, every thing keeps its address, so you can change the front door and nothing breaks.

  • One address, for people and for code.

    Open it in a browser and you see the thing. Ask for it from code and you get the record as structured data, under the same access.

Every record knows what it is.

In a spreadsheet, a column called Status means whatever its author had in mind. Ripe? Shipped? Paid? Here every record has a type, and the type says what the thing is. A banana is typed as a Banana, and the shared vocabulary knows a banana is a fruit, and a fruit is a food. Crate, ship and shop are types too, so every app reads them the same way. A shared vocabulary like this is called an ontology. The platform's ontology is called GilbVeda.

  • Typed from the first second.

    You say what a thing is when you make it. It is never a blank row waiting for someone to explain it.

  • One word for one thing, in every app.

    A Person is a Person in every vault and every app. Five apps don't invent five words for Person, so all apps agree without integration work.

  • Open for anyone to read.

    Every type has its own public address. Open Banana and read what it means. Where a clear match exists, a type is matched to public vocabularies such as Wikidata and schema.org.

  • What it is, what it does, how well.

    The vocabulary has three kinds of entry: types, functions and values. A cold container is a type. Keeping bananas cool is its function. Temperature is a value: how well it does it, measured with a number, like 13 °C.

  • It grows with you.

    Need a kind of thing that doesn't yet exist in our ontology? You propose it, or more commonly, your AI proposes it automagically when it needs it. Agent.Concept, which looks after the ontology, checks it, approves it, mints it, and gives it back to your Agent.Coder. Once approved, every app can use it, and records made years ago keep their meaning.

Your AI knows more than the record says.

A record says: Banana. 18 kg. From Banano Vargas Farm. That is all it says. The type adds that a banana is a fruit, and a fruit is a food. The links add that Banano Vargas Farm lies in Costa Rica. So ask your AI "How much food came in from Costa Rica this month?" and it can answer, even though no record contains the words food or Costa Rica.

  • No guessing what a column means.

    The type tells the AI what each thing is and what each field means. You stop explaining your data in every prompt.

  • It climbs the types.

    What is true of every food is true of a banana. The AI follows Banana to Fruit to Food and brings the meaning back.

  • It follows the links.

    From the crate to the farm to the region, through links that say what they mean.

  • It knows when.

    Every fact carries its dates, so the AI can answer what was true last Tuesday, not only what is true today.

  • It knows where.

    Places are data too. "In Costa Rica" or "near the harbor" is something it checks, not guesses.

  • It stays inside your grants.

    The AI works with your access and nothing more. What it cannot see, it cannot reason about.

  • You can check its work.

    Every fact it used has its own address. Open it and see for yourself.

The meaning is in the data, so your AI does not have to guess it.

Nothing gets overwritten.

Change a record and the old value is still there. Every change is a new fact, stamped with who made it and when. Even a deletion is recorded, so the record leaves today's view while its history stays readable.

  • Two clocks on every fact.

    One says when it was true. The other says when it was recorded. So you can answer both "What was crate 42's price on Tuesday?" and "What did the system say on Tuesday?"

  • Who and when, on every change.

    Every fact is stamped with who wrote it and when.

  • Fix the past without losing it.

    Correct a wrong date from last month. The correction is kept, and so is what the record said before. On Tuesday the crate's temperature was logged as 31 °C. On Wednesday it was fixed to 13 °C. Both are kept: what was true, and what the system said on Tuesday.

  • Open any day.

    See a record as it was on any date, without a backup tape.

Under the hood, one fact at a time.

Everything in a vault is stored as small, single facts. Each one is called a datom. A datom says one thing about one thing. A change adds a new datom instead of editing the old one.

The thing
crate 42
Which thing this is about, by its address
The attribute
weight
What is being said. A word from the ontology, with an address of its own
The value
18 kg
A number, a text, a date, a place, or a link to another thing
True from
Tuesday, 06:00
When it became true in the world
Recorded
Tuesday, 09:14
When the system learned it
Written by
Lisa
Who wrote it

  • Why facts, not tables.

    A table fixes the shape of your information up front. Facts don't. Add a new kind of fact tomorrow, and nothing needs rebuilding.

  • Records are assembled when you ask.

    The record you see is put together from its facts at the moment you ask, as of any date you choose.

  • Fingerprinted.

    Every value and every file is stored under its fingerprint, a SHA-256 hash. The same value is kept once, and any change shows.

  • Access checked inside the store.

    Permissions are part of the query itself. A record you may not see is never fetched, rather than fetched and then hidden.

  • Open standards.

    Records travel as JSON-LD, the web's standard format for linked data, over Linked Web Storage. Tools that speak these standards can read your information directly.

Technical report card

  • A bitemporal, append-only fact log. Every datom carries valid time and transaction time.
  • A deletion is a retraction, written as a new datom.
  • Content-addressed values: SHA-256 over RFC 8785 JCS. Files are stored by SHA-256.
  • Compute on read. There is no materialized entity table.
  • Entities, attributes and types each have their own URI. Links are JSON-LD @id references. Relations carry typed roles.
  • A single-parent type hierarchy, published at veda.gilb.com.
  • Types are aligned to public vocabularies with skos:exactMatch and skos:closeMatch.
  • JSON-LD over W3C Linked Web Storage, with DPoP sender-constrained tokens.
  • Access control is one predicate inside every read. The default is deny.
  • A PostGIS spatial index, and the GilbGeo vault.
  • A whole vault exports as JSON, or as an archive of its datoms and files.
  • Hosted on Hetzner in Falkenstein, Germany. Backups on a separate Hetzner Storage Box in Helsinki, Finland.