Show HN: Proxenos – a local-first agent for getting through the health system

A free, open-source agent that keeps your own records private on your computer and drafts the next step for you. Built first for people getting through the health care system.

When you're unwell, the hard part is often everything around the care: referrals that go quiet, portals, bills that don't match, forms, and the same story told again at every visit. Proxenos reads what you already have (your mail, chats, calendar and notes), keeps track of where things stand, and writes the message, the call script or the one-page brief for your next appointment, in your own voice. You stay in charge: it drafts, and you press send.

The home page of proxenos demo, a made-up person with made-up records. More below.

It grew out of one person's weeks of getting through the system while unwell. The story is Try anything, but don't fall sick, and more on the project is at mindemory.io/proxenos.

Status: early, and used every day by one person. It runs on a Mac (Apple Silicon) for someone comfortable with a terminal, and every check passes from a fresh clone. It's about 45,000 lines of Python and TypeScript, with 16,000 more in 680 tests that run on macOS and Windows on every push. It isn't yet something you can download and use without code. That's the next track: one download, signing in instead of configuring, and a clear privacy screen (docs/everyone.md). Expect rough edges, and readers that assume a particular export format.

Help of any kind is welcome: code, an issue, or an idea over a message or a call. Healthcare comes first, so people with medical training are especially welcome. Knowing what's worth tracking and what to ask is what would make this preventive, not just a way through the system. Good places to start are in CONTRIBUTING.md. If you'd like Proxenos to exist for more people, a star helps others find it.

Not medical advice. Proxenos organizes your own records and drafts messages. It doesn't diagnose or recommend treatment: the care view restates what your records say, and anything that matters belongs with your care team.

Proxenos gathers your own data (messages, email, calendar, notes, documents, activity) into one private vault on your computer. From that it keeps a written model of who you are, and runs small agents ("clones") that work for you:

It drafts; by default it never sends, posts or buys anything by itself. You copy a draft or open it in its app with the text filled in, and press send yourself; once your reply shows up in that chat, the draft is marked sent. A draft you changed before sending is shown, beside what you sent, to the drafts written for you after it, and a draft your messages since made moot (someone else did it, or the plan changed) is folded away with why. An outbox you switch on per app lets replies go out on their own, only where that app's drafts have gone out nearly unchanged many times, with a window to cancel each one (docs/memory.md). It places a phone call only when you press Call: it waits on hold, says it's an automated assistant calling for you, and rings you when a person answers (docs/calls.md). The longer-term plan, moving from drafting to acting on approval to acting within rules you set, is in docs/roadmap.md.

The name: in the Greek city-states, a proxenos was the citizen who formally acted on someone else's behalf.

These come from proxenos demo (see Quick start), like the home page at the top: a made-up person, Joe Bloggs, and his made-up records. None of it is real.

your sources ──ingest──▶ vault/raw ──observe──▶ notes ──consolidate──▶ self-model │ │ └──index──▶ memory (full-text search) ▼ clones: feed, tasks, advice, choices, watch, network, recall, projects, project steps, errands, drafts │ local page (127.0.0.1)

Ingesters pull each source into the vault as monthly files. Re-running one is always safe.

Observers read one month of one source (only your own side of conversations) and write notes about you.

The master merges the notes into a single self-model: identity, interests, taste, voice, routines and open questions. Slow-changing parts change only through proposals you accept.

Clones read the self-model and each do one job. The page shows their output and records your reactions, which feed back into the next run.

More detail: architecture, memory, data sources, the feed and the page, a voice model trained on your own writing, related work.

Code and data are separate. This repository holds code only. Everything personal lives in a private vault outside the repo (picked on the first-run setup page, or PROXENOS_VAULT; default ~/proxenos_vault). The vault keeps its own local git history of how the self-model changes.

What reaches the model: observers send the model only your side of conversations, never other people's messages. Clones send your self-model, plus public items such as papers and news; watch also sends the films you've logged and how you rated them. Three clones also send recent records they need, picked out in code: tasks sends conversations you're part of, with the title and opening of each draft waiting on you; care sends only records about getting health care, with people in chats replaced by labels and phone, account and member numbers blanked; and drafts sends the recent conversation in each direct chat, or Slack thread that mentions you or that you're in, waiting on your reply, with what your memory holds about that person and what the chat depends on (the newest records naming them, and the results of the searches the model asks for). On a phone call you start, what the other side says goes to the call's model to decide what the assistant says next, and the call's audio goes through Twilio, which transcribes it (docs/calls.md). With a local model none of this leaves your computer, apart from the call's audio.

Links in messages are fetched only for a chat waiting on your reply, and only from hosts on the public internet, never this computer or your local network.

The page is local only. It binds to 127.0.0.1 and rejects requests from other sites. The one way in from elsewhere is proxenos phone: your Mac's private address on your own Tailscale network, answered only for your own Tailscale login. Nothing is opened to the internet, except, if you set up calls, one port Tailscale Funnel opens for Twilio, which answers only during a call and only requests Twilio signed.

Credentials stay on your computer: in its own secure store, one item each (the macOS Keychain, Windows Credential Manager, or the Secret Service on Linux), or in .env (which git ignores) when you run from source with one. The page shows whether each is set, never what it is.

Found a security problem? Please report it privately: see SECURITY.md.

Quick start

One command, on a Mac with Homebrew:

git clone https://github.com/mindemory/proxenos && cd proxenos && scripts/install.sh

It installs what's missing (Node, Ollama, and Miniforge if there's no conda), sets up the proxenos env and the page's packages, and pulls a local model that fits your Mac's memory. Then conda activate proxenos && proxenos web. Add --start-at-login to keep the page and a sync running from login on, or --no-model to use a hosted model instead. Running it again only adds what's missing.

By hand, step by step. Requirements: macOS, Python 3.12 (conda shown here), Node 22+, and a model for the steps that use one: an open model on your Mac through Ollama (no key, nothing leaves the computer; gemma4:26b fits a 32 GB Mac), or an Anthropic API key.

git clone https://github.com/mindemory/proxenos && cd proxenos CONDA_SUBDIR=osx-arm64 conda env create -f environment.yml conda activate proxenos pip install -e ".[dev]" brew install ollama && brew services start ollama && ollama pull gemma4:26b # the local model ollama pull qwen3-embedding:0.6b # search memory by meaning (optional) proxenos web # http://127.0.0.1:4747; leave it open, and use another window below

The first time, the page asks three things: your name, where the vault lives (~/proxenos_vault unless you pick another folder; it warns about folders iCloud syncs), and a model, either one on this Mac through Ollama or an Anthropic API key, checked with one small call. The model can wait: sources still sync and search still works, but nothing is drafted. Then it opens Connect for a first source. Settings go to ~/Library/Application Support/Proxenos/settings.json and keys and tokens to the macOS Keychain, one item each; change them later in Settings. (On Windows they go to %APPDATA%\Proxenos\settings.json and Credential Manager; on Linux, to ~/.config/proxenos/settings.json and the Secret Service.)

Prefer a file? cp .env.example .env and fill it in. Running from source, .env is read before the settings file and the Keychain, and with one there, changes from the page are written to it.

Try it without your data: proxenos demo writes a vault of made-up records (the one in the pictures above) to a temporary folder, with no model and no .env, and prints the command that opens the page on it, on port 4848 so it can run beside your own. Nothing is ever sent from it.

Add data in any order. Each source works on its own:

proxenos ingest whatsapp # reads the WhatsApp Mac app's local store proxenos import ~/Downloads/takeout-*.zip # Google Takeout: mail, calendar, Drive, YouTube, ... proxenos sync # imports anything dropped into data/, refreshes every source

Then build the model and the clones:

proxenos master # notes per month, then the self-model proxenos clone tracker # also: tasks, care, advisor, network, choices, watch, recall, projects, work

Your long-running projects are a list you keep in the vault, clones/projects/projects.json: each with an id, a name, what it's about, its people and the words that name it. Each night Proxenos writes where each one stands. Give one its code's folder and its data folders, and it also does the work, a step a night, on a branch of its own, and brings it back for you to accept on the page's Projects view:

{"id": "calls-paper", "name": "The calls paper", "about": "...", "people": ["Ana Lee"], "repo": "/code/calls", "data": ["/data/calls"], "python": "~/envs/calls/bin/python", "notes": "F*.py make the paper's figures."}

To keep it running without a terminal, run scripts/install-app.sh: the page and a sync every 15 minutes then start at login. scripts/build-mac-app.sh then builds Proxenos.app into ~/Applications: the page in a window of its own, with a Dock icon and menus, no browser. To reach it from your phone, put Tailscale on both, signed in to the same account, and run proxenos phone: the page gets a private address only your own devices can open, and Chrome on the phone can add it to the home screen.

proxenos night runs the whole loop. scripts/install-night.sh schedules it every night with launchd.

proxenos schedule does the same on any computer, with no launchd: a sync every 15 minutes and the night at 01:30, run once on waking if the computer slept through either, and never two at once (nor beside one launchd or a terminal started). Leave it running in a window, or start it at log-on with Task Scheduler on Windows or a systemd user unit on Linux (docs/apps.md); the coming Mac and Windows apps will run it themselves. proxenos schedule --once runs whatever is due and exits.

Some sources read a folder on your computer: a folder of documents, your website's repo, a Spotify export, slackdump runs. Set them in Settings, or in .env as PROXENOS_DOCS_DIRS, PROXENOS_WEBSITE_REPO, PROXENOS_SPOTIFY_EXPORT and PROXENOS_SLACKDUMP_DIR. .env.example lists every setting.

Source How it gets in

WhatsApp The Mac app's local database (proxenos ingest whatsapp)

Slack slackdump (proxenos auth slackdump WORKSPACE, then kept current every sync), or a user token

Gmail, Google Calendar, Drive, Photos metadata, Keep, Tasks, YouTube, Chrome Google Takeout zips (proxenos import)

Email (any) mbox exports; Gmail over IMAP with an app password or a Google sign-in (proxeno