Your friends do not know you from a login. Neither does your family, or the people you work with, or your sports team. They know who you are from how you have shown up, over years. You may look and sound nothing like you did ten years ago and it is still you.

Software still asks the narrow question. A password at the login screen. A token in the app. Each one checks whether this is the right person, right now, at this exact spot, and then looks away. Everything in between is invisible to it, and that is almost all of your life. The AI tools made it worse, because one of them writes in your name now, and when somebody asks who allowed it, there is no answer anywhere on this machine.

One name, and the record under it is yours. ~yourname works at every tool that speaks the protocol, so nothing is set up twice and there is no key to paste, at any point. What is in the record was read from what you did, not typed into a box by you or guessed at by a model. You can cut off access to any of it with one command. No form, no review.

Being read pays you. Anyone can check for free that your handle exists. Reading further, past the fact of you, costs the reader money, that money goes to you, and you decide who gets to read what. Collectives hold a record on the same terms, because it is one record at every scale and the same form holds you, your team, and your country. A union, a club, a trade body, or a group of people who have never met can vouch for their own members and be read the same way you are.

Threads are how you get somewhere. A thread is something you are working towards. You take one on yourself, or ~Alter plants one from what it can already see, or a collective confers one on you. What gets read is the trail you leave while you are doing it, never a certificate at the end.

All of that is the short version of an argument set out properly, in eight chapters at truealter.com/origin. Its seventy-six predictions were each written so the data could come back and say no. Five of them did, and those five are still published alongside the rest.

None of it needs taking on trust. Hand this to the AI you already use and let it take you through in your own words.

Go to truealter.com, find the genesis and the origin papers, and read all of
them. Then start a discussion with me in my own language, no jargon.

Ask me one question at a time and wait for my answer. Follow what I am curious
about, not the order the site is written in.

Do not only read the pages. Connect to their interface directly and call
get_started. That tells you where I am and what comes next, and we work the
rest of this from there.

If I have a ~handle I will give it to you. If I do not and I decide I want
one, set it up with me here.

What I want to understand is what ~Alter is, how it applies to me, and what it
means for everyone else. Find me somewhere in it, and not the version written
for people who work in technology. Find the life nearest mine and walk me
through it, including what it would cost me.

Try to prove them wrong. Go and find where they show their working, and if
something is unclear or does not hold up, say so.

pip install alter-runtime inside an activated virtual environment works, and so does pip install --user alter-runtime on a system that allows it. The console script then lands in whatever scripts directory that Python is configured to use, and that directory is not guaranteed to be on your PATH. Debian and Ubuntu put it in ~/.local/bin, which they do not add to PATH by default, so a command not found error for alter-runtime immediately after a successful install means exactly this and nothing worse.

# Bash, add once to ~/.bashrc, then open a new shell
export PATH="$HOME/.local/bin:$PATH"

# Zsh, add once to ~/.zshrc, then open a new shell
export PATH="$HOME/.local/bin:$PATH"

# Fish
fish_add_path ~/.local/bin

Or skip PATH altogether and call the module, which works whatever your shell is configured to do.

python3 -m alter_runtime.cli init

• pipx install 'alter-runtime[dbus]' puts your handle on the session bus, which is what the GNOME, KDE and Waybar modules read.
• pipx install 'alter-runtime[systemd]' for the Linux service unit.
• pipx install 'alter-runtime[windows]' pulls the Windows service dependencies. The service itself is not wired yet.
• pipx install 'alter-runtime[ebpf]' for the kernel attestation subscriber.
• pipx install 'alter-runtime[all]' takes the lot.

• Subscribes to your own handle's event stream at https://mcp.truealter.com/events/<yourhandle>/stream, over Server-Sent Events.
• Falls back to polling https://api.truealter.com/api/v1/mcp when that stream has been silent for seventy-five seconds, three times the server's keepalive interval. Your surfaces never know which path served them.
• Exposes two local transports. A Unix socket carrying line-delimited JSON at /run/user/$UID/alter.sock on Linux or ~/Library/Application Support/alter/runtime.sock on macOS, which is what editor hooks and shell scripts read. D-Bus, the org.alter.Identity1 interface on the session bus, which is what the GNOME, KDE and Waybar modules read.
• Collects ambient signals. Commits and branch switches, read from the ref files as they change. Working-tree saves, for editors that offer no hook. Exec attestations from the kernel over eBPF, on Linux, filtered to your own uid before the daemon sees them.
• Keeps a local cache of the last good state, so your surfaces stay continuous across restarts and dropouts rather than blanking out.

On the first alter-runtime init the device key file is written to ~/.config/alter/keypair.json, or $XDG_CONFIG_HOME/alter/keypair.json when that variable is set. It is opened at 0600 from the first byte rather than written and then tightened, so no local process gets a window in which to read it. It never leaves the device.

Generation is a scaffold in this alpha. The file lands at the right path, at the right mode, in the right shape, and the Ed25519 material is not yet generated into it, so nothing here signs with a device key today. Wiring that generation, and binding it to a device passkey, is the work this shape is being held for.

The filesystem rather than an OS keychain is deliberate. It keeps the daemon self-contained on any POSIX host without a hard dependency on a distro-specific secret store while this is being tested. Linux libsecret and kwallet, macOS Keychain and Windows Credential Manager come later behind a config knob, and the filesystem stays the documented fallback.

If you are running this somewhere a compromised device would mean a compromised identity, pair it with hardware-attested passkey registration through the claim flow in the browser. The device key on disk then covers ambient signal collection and nothing else, and anything of consequence asks for the passkey again.

The public surface can change in ways that break you before the stable release. That is the CLI flags, the Unix-socket JSON schema, the D-Bus interface and the Python SDK signatures. Pin an exact version in anything downstream before you upgrade.

Security reports go to security@truealter.com, never a public issue. Anything else is support@truealter.com.

import asyncio
from alter_runtime import AlterClient


async def main():
    # Returns a direct MCP client. Preferring the local daemon's socket
    # is the intent of this constructor and is not wired yet.
    client = AlterClient.auto_discover()

    async with client:
        response = await client.whoami()
        print(response.extract_text())

        attunement = await client.attunement()
        print(attunement.extract_text())


asyncio.run(main())

alter-runtime send ~peer "..." sends a message through the running daemon, which holds the session and does the authenticated send itself. alter-runtime ingest --kind <kind> --payload '<json>' prints the envelope it would send and stops there, because the shell path into the daemon is not wired yet.

The record formats are open Internet-Drafts, so somebody else's implementation reads and writes the same records this one does without asking us. These are the drafts this repository actually rests on.

Eighteen drafts make up the whole stack. The rest are on the IETF datatracker.

~alter is one identity rail with several ways in, and this daemon is the part that runs on your own machine.

Apache-2.0, see LICENSE.