MyJackfruit wordmark

Pre-launch website · All subject to change

Production Quality at Scale

Build your dream App · Website · Product. With AI.

Join the waiting list

Built for Real Needs

An app in ten minutes is not the app you need.

  • AI app builders: app ready at 10 min; at 1 week, not production ready; at 3 months, not production ready.

    Vibecoding

    You tell it what you want, but the AI knows little or nothing about your real needs. The architecture lets you change colors and add functions, but not scale, security, performance, access control or large amounts of data.

  • MyJackfruit

    App ready · 1 day

    Day one: we have a first version of your business values, your stakeholders and all their needs and values, the product functions and product values, including the architecture values, all quantified, measurable and prioritized. We have found the right solutions and made an evolutionary plan to build it step by step, with measurements and feedback loops. The complete setup for a commercially successful, production-ready product at scale. Agent Kai-Zen manages the process and writes the specs for you.

    Production ready · 1 week; after 1 week, Kai-Zen continuous improvement

    We build your product in learning cycles with feedback. You show the product to your stakeholders and they give feedback. As we learn more about their real needs and values, we adjust them, and the solutions, to match. Each cycle brings the product closer to what your stakeholders value. All led by Agent Kai-Zen.

MyJackfruit delivers a production-ready app that meets your stakeholder needs faster.

MyJackfruit builds what your stakeholders need

AI app builders are fast. Describe an idea, and ten minutes later you have an app. It looks right.

What they don't do is ask who the app is for, map out all the stakeholders and their needs, quantified and measurable, then architect an application with the right Security, Scalability, Uptime, Maintainability, Portability, Data Ownership, and Performance to meet those stakeholder needs. So the fast app is often the wrong app, and the real needs show up after launch.

That is MyJackfruit. Agent Kai-Zen helps you specify what your stakeholders really need, in numbers, before anything is built.

Kai-Zen means continuous improvement.

In Japanese, kaizen (改善) means change for the better, one step at a time. We build on it. First we put numbers on what your stakeholders need: how fast, how safe, how easy, how much. Then every step improves your app toward those numbers and measures how close it got. You always know where you stand, and what to improve next. Agent Kai-Zen takes your work through it.

How many bananas survive the entire journey to the customer's kitchen in the destination country? Today it's 80. Agent Kai-Zen's job is to make it 81, then 82, and keep going. Every change to the process, whether a cooler crate, a faster ship or a shop that orders better, is measured by how many more bananas reach a breakfast table.

  1. 80 of 100: Today
  2. 81 of 100: Cooler crate liner
  3. 82 of 100: Shop orders by "ripe by Friday"
Bananas reaching a kitchen, of every 100 picked.

Kai-Zen, the value decision engine.

It plans at every level: your business, your stakeholders, your product, and the solution. Each level states its values with numbers, so "fast" and "secure" mean something you can check. The Kai-Zen value decision engine is patent pending.

  1. Business Bananas reaching a kitchen: 80 to 85 of 100

  2. Stakeholders The shop: unsold bananas 4 to 3 of 100

  3. Product Any crate traced to its farm: ≤ 1 hour

  4. Solution Cooler crate liner: transit loss 3 to 2 of 100

Every stakeholder, named.

Every kind of person who uses it, pays for it or keeps it running. The laws and regulations it must meet. The competitors and the other systems it works with. Each with needs you can measure.

Your app

  • Farmer: 80 to 85 of 100 eaten
  • Pickers: ≤ 9 h a day
  • Shipper: 13 °C
  • Ripening centre: colour stage 4
  • Shop: unsold 4 to 3 of 100
  • Family: eaten in 4 days
  • Regulators: trace in ≤ 1 h
  • A competitor: 76 of 100 eaten
  • Other systems: a reading every 15 min

Decide on values, not on vibes.

For your app, every solution candidate is scored against the stakeholder values you have to deliver on. The candidate that delivers the most value for its cost wins, and you can show why.

A banana crate in Costa Rica, an arrow graded from 80 to 85, and a girl eating a banana: bananas reaching a kitchen, 80 to 85 of 100.
Learn more about deciding on values

Kai-Zen inside your own apps.

Your apps call Agent Kai-Zen through the API to help your users decide, scored against what matters to them. For example, a crew choosing a boat or a company choosing a supplier.

Technical report card

  • Planguage (Tom Gilb's language for quantified requirements)
  • Value Decision Tables (impact estimation)
  • Patent pending: the Kai-Zen value decision engine. U.S. Patent Application No. 19/755,865, filed July 28, 2026: “System and Method for Multi-Level Value-Driven Delegation, Governance, and Improvement of Generative Artificial Intelligence Agents.” Inventors: Kai Gilb and Tom Gilb.
  • Agent Kai-Zen works with your access, nothing more, and is called through the same API as everything else.

Snappy at Scale

Fast is easy until people show up

Chart: from 10,000 things to 24 million things, drawn as banana crates piling up from one crate to huge piles and a few people growing into crowds. MyJackfruit's response time stays within milliseconds: measured, 17 ms on a store of 10,000 things and 24 ms on a store of 24 million things. The dashed line for AI app builders is an illustration, not a measurement: it rises steeply as the piles and crowds grow and stops responding before the largest size.

MyJackfruit builds Snappy at Scale

AI is very good at getting something on screen. A front end, a demo, two users, ten crates of sample bananas. Fast.

What it does not write is the architecture underneath. Nobody asks for it, so nobody builds it, and the crack shows the first time real data and real users arrive together. One crate of bananas is easy. Banano Vargas Farm ships 25,000 crates a week, and each one is scanned at the farm, in Rotterdam and in Oslo. The app answers as fast in the last week of the season as on the first day.

That is MyJackfruit. The part the AI does not write.

We measured it.

The same reads on a small store and on a huge one.

10,000 things:
17 ms.
24 million things:
24 ms.

What it is built on

The store

The read path

  • A per-principal page cache living inside Postgres as an UNLOGGED table. A warm read is one primary-key lookup of a page that was already access-filtered when it was built.
  • Access control is pushed into the query as one indexed set-membership join, not applied as a filter pass after the fact.

Secure by Structure

Authentication is not security

A whole jackfruit, closed.

MyJackfruit builds the permission model

AI will give you a login screen in a minute. Sign up, sign in, reset the password. It works.

What it does not write is who may see which fact, under what conditions, and whether that still holds after the next three features. The shop in Oslo sees when crate 42 will arrive, not what the farm was paid for it. The farm sees what the crate sold for. Each owner decides what the others may see. Permission gets added per screen, then per endpoint, and the gap opens where nobody thought to look.

That is MyJackfruit. Permission is not a layer on top of the data. It is how the data is stored.

You decide who reaches what

  • Grants are given to a person or to a group, and taken back the same way.
  • Access is granted for reading or for writing.
  • One entity. A whole branch of them. Every entity of one type inside that branch. A whole vault. Or one vault's reach into another. For a farm: one crate, a whole shipment, every crate in that shipment, the farm's whole vault, or the farm's reach into the shipper's.

Nine levels, not a checkbox

Every field on a MyNet profile carries its own sharing level. The same primitive is in the platform, not in the app.

Drawing: the nine sharing levels as nested rings, narrowest reach at the centre. From the centre out: Private, no one but you. Then three 1st Inner Circle levels: Personal 1st Inner Circle, Professional 1st Inner Circle and Pers & Pro 1st Inner Circle. Then three 1st Connection levels: Personal 1st Connection, Professional 1st Connection and Pers & Pro 1st Connection. Pers & Pro means either context, not both. Then GilbPublic, everyone signed in to the GilbPlatform. Then Public, everyone at all, signed in or not.

Stored in Germany. Backed up in Finland.

Your vaults run on Hetzner servers in Falkenstein, Germany. The backups are kept apart, on Hetzner storage in Helsinki, Finland, so a fire or a flood at one site cannot reach both. Both countries are in the EU.

Falkenstein, Germany Your vaults

Helsinki, Finland The backups

What security is built on

Deny by default

  • Anonymous requests match nothing. An empty permission set is structural, not a rule someone remembered to write.
  • Access control is pushed into the query as one indexed set-membership join, not a filter applied after the results come back.
  • Pages are built already access-filtered, per principal.

What a grant covers

  • Every entity carries its own access control. Grants are issued at five grains: one entity, a subtree, a type within a subtree, a whole vault, or one vault's reach into another.
  • Access is granted on the vault, for reading or for writing.
  • A grant can follow a hierarchy of vaults, and a subtree of entities inside one.

Sign in

The record

  • The data model only writes. Nothing is overwritten. A change is a new fact, a deletion is a retraction, and the history stays readable.
  • Every write is stamped with an actor and a transaction time.
  • Bitemporal (opens in a new tab). What was true, and when we learned it.
  • Files are content addressed by SHA-256 (opens in a new tab).

Your vault

  • Every account gets its own vault. There is no signing in without one.
  • A vault can be listed publicly or kept private in the directory.

What we do not have yet

  • SOC 2 and ISO are not done.

Why MyJackfruit.

In addition to how much we love to eat jackfruit…

A jackfruit drawn in two parts: a whole fruit covered in a spiky shell, and a cut fruit showing yellow pods arranged in a ring, a single seed, and the pale fibers between the pods.
  • The skin. Security is part of the store.
  • The rind. Agent Jackfruit, the operator of your vaults.
  • The core. Agent Kai-Zen, your project and product architect.
  • The fibers. Links that carry meaning.
  • The seed. The datom: one fact at a time.
  • The pods. Your vaults, and the ones everyone shares.

MyJackfruit and what it contains.

  • MyJackfruit: the service supporting you in building production-ready apps.

    • Your apps: what you build

    • GilbPlatform: the backend. Vaults, types, access, agents.

      • Your vaults

      • Resource vaults:

        • GilbGeo (places covering the globe)
        • AppBuilder (instructions for AI to build apps)
        • Jackfruit (instructions for AI to build your vault and database)
        • GilbVeda (ontology of types of things)
        • GilbLife (living things: taxa and biota)
      • Agents inside: Agent Jackfruit · Agent Kai-Zen · Agent.Concept

      • Kai-Zen: the value decision engine, the architect of your apps and as a service inside your apps

    • GilbApp: see and work your vaults, talk to the agents, build apps

    • App Library: MyNet · TomTwin … your apps

    • Support: standards, docs and help for you and your AI (incl. Agent.Coder)

How to build on MyJackfruit

Sign in to the GilbApp and name a vault. You're in.

The GilbApp graph view of a furniture-store vault: six records including Shop-Clerk, Store-Owner, Customer and three tables, joined by labelled relations such as reports-to, depends-on, owned-by and assigned-to, with the Customer record open in the right panel showing its stakeholder type and fields.
A vault in the GilbApp: records created against shared ontology types and the relations between them.

Try it now. No code needed.

  1. Sign in to the GilbApp with your email.
  2. Name your first vault. It's yours from that second.
  3. Add your first thing, a crate of bananas if you like, and see what it is and what it links to.

Open the GilbApp

New types minted on demand.

Learn more about the vault account

AI is a highly effective way to build here.

Build your apps with AI, done right.

You use AI for what AI is best at: building front-end apps.

We provide what AI is not good at instead: a backend architecture that's scalable, secure, fast, and flexible, purpose-built for the front-end apps you build with AI. The shop in Oslo builds its banana-shelf app with its own AI. The crates, who may see them and how people sign in come from us.

Your front end, built with your AI

For example, the shop's banana-shelf app

MyJackfruit backend

  • Vaults
  • Types
  • Access
  • Agents

You choose your favorite environment.

You're not forced into picking ours.

Use the AI you already work with: Claude Code, Codex, GitHub Copilot, Cursor, Devin, Antigravity, OpenCode, Grok Build, or any other coding agent. Pick the model too: Claude, GPT, Gemini or Grok, or an open model like Qwen or DeepSeek running on your own machine. You're in full control.

We provide everything your AI needs to do the job right.

You get standards, working processes, rules, templates, checklists and code modules, so AI (and humans) can build front-end apps on GilbPlatform the right way.

No connector, SDK, CLI or MCP server. Point your own AI at us from Terminal or Obsidian.

Technical report card

AI Agents operate inside the GilbPlatform

They can build your database, and they match and mint ontology types to the apps you build

Say hello to Agent Jackfruit, the operator of your GilbPlatform backend.

It runs your databases and vaults, and manages the connections between them. Every piece of information is typed to an ontology, so both humans and AI can see what the information actually means. A banana is typed as a banana, so the AI knows it's a fruit, a food, and more. Every entity, like that banana, links to other entities, like the tree, the farmer, and the person who eats it, through predicates (connections) that carry specific meaning. That's how AI can understand your information, what things are and how they all relate. Ask Agent Jackfruit to set up Banano Vargas Farm. It creates the vault, types every crate, and links each one to the farm, the farmer and the region.

You unlock the real power of AI inside the apps you build, as it understands all your information and how it relates.

Every AI agent gets its own account.

Agent Jackfruit (vault db management) and Agent Kai-Zen (Project Product Agent) work inside the platform as you, signed in, with exactly your access.

Any other AI agent, yours or a partner's, gets its own user account with its own rights. You grant it exactly what it needs, and take that back whenever you want. The shipping company's AI agent can read the crates bound for Oslo, and nothing else.

No shared keys.

How it works

  1. The agent signs in as itself, never as a person.
  2. It starts with its own user access vault, and no access to anything yet.
  3. You grant it what it needs, from a single record to a whole vault, to read or to write.
  4. When you take a grant back, that access is gone.

The method runs on the platform too.

  • The Kai-Zen delivery method is stored in the platform as data you can read in the app.
  • Agent Kai-Zen takes your work through the method, step by step.
  • Need a type for a ripening room? Developers and their AI propose new types to the shared ontology, and Agent.Concept reviews them.

Technical report card

Ship AI inside your own apps.

The GilbPlatform is optimized for building AI-supported apps

Your stored information explains itself to your AI.

Your users' information is stored with rich data about its meaning and relations (through what is called an ontology), ready for built-in AI to do its magic. The shop's app asks its built-in AI "Which crates will be ripe by Friday?" The answer comes from the crates' own facts: when they were picked, when they were shipped, how cold they were kept.

  1. Banana
  2. is a Fruit
  3. is a Food
  1. Banano Vargas Farm
  2. lies in Costa Rica

"How much food came in from Costa Rica this month?"

How types work

AI built into what you ship.

  • The platform's own AI agent, built into the app you ship.
  • GilbApp and TomTwin ship with it built in.
  • You call it through the API, like everything else.

Technical report card

Everything you keep starts here.

Behind every app is something worth keeping.

A grandfather and granddaughter at a kitchen table, looking at family photos.

The family.

Photos, recipes, the cabin calendar, and who has the spare key.

A crew loading gear onto a wooden sailboat on a fjord dock.

The crew.

The gear list, the boat's service log, and who is on which trip.

A machinist at a green lathe in a sunlit workshop.

The company.

Customers, machines, contracts, and the reasons behind each decision.

Green bananas in the washing tank of a farm packhouse, with stacked banana crates behind.

The farm.

Every crate, who picked it, and where it went.

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.

Learn more about your information in your vault

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.

  1. Your sheet

    crateweightblockpicked
    4218.2 kgblock 714 Sep
  2. Map it, once

    • sheet to type Crate
    • column to field
  3. A typed record

    Crate 42 Crate

    18.2 kg · block 7 · 14 Sep

Learn more about bringing what you have

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.

  • Shipping app
  • Ripening app
  • Shop app

Crate 42 in the farm's vault

  • 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
Learn more about apps visiting your information

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.

Let the distributor follow crate 42 until it is delivered.

  • 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
Learn more about deciding who sees what

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.

Learn more about the same people in every app

It knows what it means.

Every record carries its type, so people and AI read it the same way.

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.

Learn more about what every record is

Find anything.

Your app searches by type, so nothing is hard-coded. Ask for every Crate and you get every crate, whichever app made it. Search the words too, with results as you type. You only ever find what you may see. Type "crate" and the crates bound for Oslo come up before you finish the word.

Learn more about finding anything

Things link to things, with meaning.

The crate of bananas came from a farm. The farm is run by a farmer and lies in a region. Each of those is a link, and every link has a name that says what it means. Your information becomes a map of how your things relate, not a pile of rows. Follow crate 42 back to the farm, the farmer and the region. Or forward to the ship, the shop in Oslo, and the family who ate the bananas for breakfast.

  • Follow any link.

    Go from the crate to the farm to the farmer, in any app, without anyone writing code to join them.

  • Links are facts too.

    A link is kept like any other fact: dated, with its history, and behind your grants.

  • Every role named.

    When several things share one event, like the sale of crate 42, with the distributor selling, the shop buying and a truck delivering, each one's role is named.

  • Across vaults.

    Information in your app users' vaults can link to information in your vault, which links to information in a GilbPlatform system vault, like a region on the shared map. You see as far as your access reaches. Your app presents it to your users as one integrated system; they don't even have to know about vaults. The shop's record links to the farm's crate, and the crate links to Costa Rica on the shared map.

  • See it as a graph.

    The GilbApp draws your vault as a graph you can walk.

Learn more about links with 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.

Learn more about what your AI knows

Made to last.

Every thing gets a web address that never changes. Nothing gets overwritten.

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.

Crate 42

  1. Banano Vargas Farm
  2. Moín
  3. Rotterdam
  4. Oslo now
  • 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.

Learn more about an address for every thing

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.

The crate's temperature on Tuesday

  1. 31 °C What the system said
    Recorded Tuesday
  2. 13 °C What was true
    Recorded Wednesday

Both kept.

  • 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.

Learn more about history that is never overwritten

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.

Learn more about one fact at a time

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.

Join the waiting list.

Tell us a little about you and what you'd like to build. You don't need any experience. Only your email is required.

So we can tell you when it's your turn.

A sentence is plenty. Rough ideas are welcome.

Have you built apps before? (optional)
Which AI do you use? (optional)
Who's building with you? (optional)

Leave it empty if it's just you.

Only if you'd like us to call you.

We use these details only to manage your place on the waiting list and contact you about early access, including checking whether you already have an account. Privacy policy.