Acronym quick index →
New to Web4?This page tours real, runnable software, so it assumes the vocabulary (LCT, trust tensors, witness chain). If those terms are new, start with the 2-minute TL;DR, then come back - what's here is real, open-source software you can run yourself, the proof Web4 works in practice and not just on paper. Every term is spelled out in the TL;DR; definitions also live in the glossary (Aa, bottom-left).
Running Now
Running

Hestia

Hestia is the local-first, open-source presence layer of Web4. It gives any entity (a person, an AI agent, or a service) a real cryptographic presence on its own machine: a cryptographic identity (LCT), an encrypted credential vault, scoped revocable delegation authority, and a witnessed trust record. No account on someone's server, no profile in a database, no cloud. A sovereign presence you hold the keys to.

This is the universal presence primitive for humans and AI alike, not an agent-tracking add-on. Everything the rest of this site teaches as a concept (identity, the witness chain, trust that moves with outcomes, a policy gate) is what Hestia actually runs. It is the deployed answer to “okay, but does any of this exist?”

Where Hestia sits: the personal scale

Web4 has one substrate (the core standard) and three ways to run it, at three scales of the same posture. Hestia is the personal / per-agent scale: one person or one agent. The hub is the same shape for a community, and hardbound is the same shape for an enterprise. See how the four pieces compose on the Web4 onramp.

Hestia is the Greek goddess of the hearth. Your local society is the hearth, your agents are guests under your laws of hospitality, and connecting to a hub means carrying embers from your fire to a shared one.

One presence layer, many faces

For humans

A cross-platform Tauri app. Your keys, vault, and history live on your device, passphrase-first.

For AI agents

A Claude Code plugin plus an MCP server (8 tools), so an agent wires every action it takes into its own witnessed record.

For services and the terminal

A CLI/TUI and a plugin SDK for scripting and headless services: the same presence layer, no GUI required.

What it actually does

Cryptographic identity (LCT)

Every entity gets a Linked Context Token: a real keypair with a birth certificate, generated and held locally. This is the LCT the explainer describes, made concrete.

An encrypted credential vault

Your keys and secrets sit in an encrypted store on your hardware. ChaCha20-Poly1305 with Argon2id key derivation, SQLCipher at rest. No cloud custody, no shared honeypot.

A witness chain

A hash-linked, tamper-evident record of what you did: the deployed version of the chains this site describes. You can't quietly rewrite your own history.

Trust that evolves

T3/V3 tensors that move with the outcomes of your actions, recorded as you go, not a static reputation number handed down from above.

A policy gate

Before a consequential act, Hestia checks what you're allowed to do. The rules are explicit and evaluated up front, not bolted on after.

Scoped, revocable delegation

Grant signed, scoped, time-boxed authority to another entity, and take it back. Authority is a thing you hand over deliberately, with a record.

Verifiable credentials

OID4VCI credential issuance, so the presence you hold can carry portable, verifiable claims into any Web4 society.

A plugin SDK

The same interface in Rust, TypeScript, and Python, so any program can participate in the presence layer instead of reimplementing it. See how devices and agents compose into a single identity constellation.

A day with Hestia

Those are the parts. Here is what they look like put together, not as a feature list but as an ordinary Tuesday. Say you run an AI coding agent and you want it to act for you without handing it the keys to everything.

  1. 1

    You open the Hestia app. It is a normal desktop app (the front door), with a dashboard, your vault, your witness chain, and your delegations. The first time you ran it, hestia init created an encrypted vault and your LCT (your local cryptographic identity) on this machine. Nothing was uploaded anywhere.

  2. 2

    You stash the secrets your agent will need (an API key, a repo token) in the vault. They sit encrypted on your disk, not pasted into a config file the agent can read wholesale. The agent reaches them only through a controlled interface, one secret at a time.

  3. 3

    You grant the agent scoped, time-boxed authority: hestia delegate grant my-agent --role administrator --expires 24. For the next 24 hours it can act within that role, and the grant is cryptographically signed and revocable. Not a shared password you can never take back: a delegation you hand over on purpose.

  4. 4

    The agent works. Before each consequential step it asks Hestia queryPolicy() (“am I allowed to do this?”), and every tool call is wrapped in beginAction() / recordOutcome(), so what it did lands in your witness chain as it happens. Open the witness view and you see the record: what was done, under whose authority, against which rules.

  5. 5

    Something looks off, so you revoke: hestia delegate revoke. The authority is gone immediately, and the tamper-evident record of what already happened stays.

  6. 6

    You link your laptop and phone into a constellation, so proving it is really you takes more than one device. That multi-device proof is your MFA, held by you, not a login screen on someone's server. When you want company, hestia connect-hub <url> carries this same presence into a shared hub.

All of this runs today at version 0.0.3 (Phase 2). One honest caveat: the identity in this walkthrough is a software LCT held on your machine. Binding it to a physical security chip is the job of hardbound, the enterprise tier, and that hardware binding is not yet validated on real devices.

Why local-first matters

Most “identity” on today's internet is an entry in a company's table: they hold the keys, they can revoke you, and a breach of their database is a breach of you. Hestia inverts that. The identity, the vault, and the history are yours, on your hardware. There is no central server to ask permission from, and no cloud account to lose.

That's also what makes the trust honest: because the witness chain is tamper-evident and the policy gate runs before each act, what your record claims and what actually happened can't silently diverge.

How to touch it

Hestia is a source-built binary (it lands at ~/.local/bin/hestia). A first run looks like this:

# create an encrypted vault and your LCT
hestia init
# stash a secret in the vault
hestia vault add
# grant an agent scoped, time-boxed authority
hestia delegate grant <agent> --role administrator --expires 24
# join a community society
hestia connect-hub <url>
# run the daemon on loopback (fail-closed off-loopback)
hestia serve # 127.0.0.1:7711

The daemon binds loopback only (127.0.0.1:7711) and fails closed if asked to serve off-loopback. Connecting to a hub over hestia connect-hub is how a member carries embers to a shared hub.

Honest status: Phase 2, version 0.0.3

Hestia is Running in active development, at Phase 2 (connected presence). The core (vault, policy engine, witness chain, delegation, plugin SDK) and the cross-platform app are built and working, and hub integration works end to end.

What ships today at version 0.0.3: an MCP server (8 tools), a plugin SDK (Rust, TypeScript, Python), a Claude Code plugin, a CLI, a TUI, and a Tauri app, plus OID4VCI credential issuance.

Hardware binding is trait contracts only for now, deferred to the hardbound enterprise tier, where a soft LCT becomes a TPM-bound one. Multi-society federation (entities and societies trading trust across boundaries) is Spec still: specified, on the roadmap, not yet running. See the full maturity map.

It's open source (AGPL-3.0) and runs on your own machine. You don't have to take any of this on faith: read the code and run it.

Glossary