What We Built and How It Works

Jon here, founder of 1Presence. We launched today. This is the long version of the launch note: where the product came from, what it does, and how it is built.

Where this came from

I worked with a brilliant team at MIT on the AI chat interfaces for its online learning platform. I built the agentic backend for Senis AI, an intelligence platform for membership associations, end to end. And at Cloud9Trader, a trading platform I founded, I was adding AI capabilities and wanted a real backend under them.

The missing piece was identical every time: an assistant that carries context forward instead of resetting it. And every time I ended up building some version of it myself, which is why what I actually wanted was one system good enough to sit under all of them, where every advance and every optimisation lands once and reaches everything else I build. A thinking partner is only worth the name if it still knows you tomorrow, and that turned out to be an engineering problem rather than a prompting one.

Then OpenClaw proved the demand: thousands of people spending a weekend standing up a terminal agent themselves, for the sake of memory that persists. That is a lot of effort volunteered for one property. So we built the hosted answer.

I have run that route myself. Between a VPS, an API key and the evenings spent on config, it gets expensive quickly, and that is before you have persistence you would actually rely on. Token cost is the sharper edge, and it has two faces. One is context: an agent that re-injects your entire conversation history on every single turn scales its bill with the size of your life. The other is autonomy: an agent left to act on its own, chaining tool calls with nothing bounding the run, can spend a great deal before anyone is watching. People have posted $200 days.

What we built

1Presence is a fully managed personal AI agent. You sign in, tell it your name, and it starts learning you — your context, preferences, ongoing projects, things you want to track. That knowledge persists across every conversation, forever.

The engineering behind that has two parts.

Layered recall

Persistence sounds simple — "just remember what happened yesterday." In practice it isn't, because the naive way to fake memory is to re-inject the whole history on every turn, and that cost grows with everything you have ever told it.

1Presence addresses your history rather than reloading it. A cheap orientation pass narrows the search space, a vector pass finds semantically related material, and only when a query genuinely needs entity-and-time reasoning does it hit the knowledge graph. Most turns never touch the expensive layers. That's what makes running an agent with real memory economically ordinary rather than exceptional.

The same discipline bounds what runs unattended: every turn has a budget ceiling, and a scheduled run is balance-checked before it starts and skipped rather than overdrawn, so an agent acting on its own cannot quietly spend past what you have.

Underneath the recall discipline, memory is addressed rather than flat. It is filed by project and subject, so the cheap passes can narrow to a region before anything expensive runs, and a typed knowledge graph sits on top for questions where time and identity matter ("when did the ABC deal move to Proposal, and who was on it?"). What gets filed is written in a compression dialect rather than prose, so a dense paragraph of background costs a fraction of the tokens and the prompt stays lean as the memory grows.

The vault

The other half is an Obsidian-compatible markdown document store. Every note, file, and document the agent creates or references lives here as plain markdown, organised and interlinked. It's not a hidden database — it's a structured personal wiki you own: you read and edit it right in the app, and because it's plain markdown it opens in Obsidian or any markdown editor too.

The graph holds structured facts and relationships; the vault holds the full narrative documents those facts came from. You edit a document with the agent side by side: the file open, the conversation beside it, a selected passage carried into the message so "rewrite this" resolves to the text on screen, and the edit landing in place rather than as a regenerated file. Every version is kept and only an explicit save creates one.

The memory is fully transparent, and that's intentional

One thing I feel strongly about: you should never have to wonder what your AI knows about you.

In 1Presence, both layers are fully exposed in the UI. The vault is a browsable, editable document library — open any file, edit it, see exactly what the agent has stored. The memory graph is equally visible — every entity, relationship, and fact, visualised so you can see how they're connected. You can see which facts the agent is drawing on when it responds, understand why it reached a particular conclusion, and correct or remove anything that's wrong.

"The agent remembers things about me" is only useful if you can verify what it remembers and trust that it's accurate. So the position we took is that the memory belongs to you, it should be readable by you, and you should always be in control of it.

Beyond chat — it runs things for you

Memory is the foundation, but the product on top of it is automation you can watch:

• Workflows. Multi-stage pipelines where each stage is run by a specialist agent: gather the numbers, draft the brief, pause for your approval, then deliver. Human review gates wherever you want them. A visual builder, a scheduler, a runs dashboard, and live stage transcripts so you can watch a run think.
• Routines. Single recurring jobs on a schedule: a daily briefing assembled from your inbox, calendar, and project notes, delivered at 8am without prompting.
• Dashboards. Live visual dashboards built from your real data, refreshing on their own schedule, with drill-down into individual records — and shareable read-only with anyone, on or off the platform.
• Specialist agents and skills. Stand up a named researcher, drafter, or editor by describing the role in chat. Each gets its own identity, skills, connector permissions, and memory scope.

Also in the box: living datasets (hand over a bank statement or a lead list and keep it as a structured, chartable record), re-fillable document templates (give it last quarter's branded one-pager, get it back editable and re-filled with this quarter's numbers), and a meeting recorder that files transcripts and summaries into your vault.

The design constraint behind all of it: every step is visible and auditable. You see what ran, what it read, what it produced, and where it filed the output — in your vault, in plain readable markdown. No silent background processes. No mystery outputs. The same transparency principle that applies to your memory and your vault applies to automation.

The primitives compose into an agentic OS

Memory, vault, agents, skills, workflows, dashboards, connectors — these are the primitives. On their own each does a defined job; together they compose into an agentic OS for your life or your company. Infrastructure that carries the recurring shape of your work, rather than a tool you keep re-briefing.

This is infrastructure you compose on: the same primitives the personal product is built from, opened up so you can arrange them around your own life or your company. More on the frame is at 1presence.com/docs/agentic-os.

Architecture

Each user gets a dedicated pod on GKE — isolated, internal-only, never internet-facing. GCP Workload Identity ties each pod to a service account scoped strictly to that user's data. The gateway provisions a pod on signup, brings it up on the first message and scales it to zero after ten minutes idle. State lives in GCS and Firestore; pods are completely stateless.

The retrieval discipline, the vault, the transparency UI, per-user isolation, the connector estate, and the workflow engine are all 1Presence.

Connectors

Gmail, Google Drive, Google Calendar, Microsoft 365 (Outlook mail + calendar, OneDrive), Notion, GitHub, Slack, LinkedIn, X, Monday.com, HubSpot, Motion, Read AI, Twilio (place calls with live transcripts), Strava, Google Analytics, Search Console, Tag Manager and YouTube — plus local folders and the web.

Pricing

$5 of credit at signup, no card required. Three personal plans:

The plans differ in credit headroom and in how deeply the agent can think on a given message. They do not differ in access: lasting memory, the vault, every connector and unlimited agents are on all of them.

Token usage draws down that credit as you go. Credit runs to a hard stop by default, so there are no surprise bills. If you would rather not be interrupted, auto top-up is opt-in: a fixed increment ($5, $10 or $20) charges only when credit runs out, under a monthly cap you set, and one-time top-ups work the same way. Credit you have bought is a wallet: it never expires, it survives a plan change or a cancellation, and it is refundable on request.

On whether the big labs make this redundant

Worth saying head-on. The major labs are all moving in this direction, the gap between a raw model and a personal assistant is closing fast, and a rising floor helps everyone building here.

The labs build the horizontal, median-user surface: a text box that has to work for a billion people. Three things follow from that, and none of them is a choice anyone could reverse next quarter. Opinion excludes at scale: every curated, life-shaped feature is a decision some fraction of a billion people would disagree with, so that economics rewards breadth, and ours rewards being right for one kind of person. The simple part of any assistant is already the chat; the complexity lives behind it, in routines, connectors, memory and the agents that use them, and making that layer usable by someone who will never configure anything is the job we took on. And the session we design for is the one that ends well: you asked, it is handled, and you are back in your day.

Underneath that, the bet is that three things stay hard to retrofit, and all three are described above: memory you can read and correct, a model layer that is swappable by design, and isolation that is per-user, single-tenant infrastructure rather than a policy over shared storage. Properties of the architecture, not items on a roadmap.

1Presence for Business — the operating system for your company

The personal assistant is one side of the product. The other is teams — and this is live, not a pitch deck.

An organisation gets a shared vault and shared memory the whole team builds on, instead of everyone briefing their own assistant from scratch. Teams get scoped access to their own corner of the shared knowledge. Purpose-built agents — primed on the company's products, processes, tone of voice, documentation, customer history — are shared across the org: a support agent that knows your product inside out, a comms agent that drafts in your voice, a documentation agent that updates itself when a feature ships. Members switch cleanly between their personal space and the company's with one control, so work and life never bleed together.

Knowledge accrues once rather than per person. What any member tells it, the team has, and it lives in the organisation's own vault rather than inside anyone's private one, so it is still there when the person who put it there moves on.

The boundaries are the architecture, not a setting. An organisation's vault and memory run under their own identity on their own infrastructure, separate from every member's personal space rather than a filter over shared storage. An admin gathers members into teams and scopes each team to its corner of that knowledge; what a team's agent can actually reach is the intersection of the team's scope and its own grants, resolved per turn and never widened by either side. Everyone keeps a private space alongside it, and the two never cross: work connections live in the organisation, personal ones stay with the person, and an admin can neither read a member's own space nor act through their personal accounts.

The question a technical reader asks first: an agent acts with the permissions of the member who invoked it, not the member who built it. The acting member is established by the gateway after verifying them and is never taken from the client, and every scope a run touches — vault, memory, connectors — resolves from that person. Sharing an agent, a workflow or a dashboard is a visibility binding: it changes who can see and run the thing, never what data anyone can reach through it. One honest limit, since it is the first case anyone probes: a scheduled run has no invoker, so it runs within the scopes bound to it and is recorded as the scheduler rather than as a person.

Billing is one account on the same three tiers, priced per seat, with every seat's credit funding one shared pool. A member is never personally charged for org work.

This is infrastructure your company composes on: the same primitives the personal product runs on (agents, skills, workflows, dashboards, shared vault, shared memory), arranged around how your team actually works and compounding as it does more. The company's knowledge accrues in one shared place rather than in everyone's separate chat histories.

The same transparency principle applies at the business level. Each agent's memory and vault — what it knows about your org, your customers, your processes — is inspectable and maintainable by the team. You're not feeding context into a black box and hoping it sticks; you're building a structured, readable knowledge layer that the agents draw from and that you can audit. And each agent runs on the same isolated pod architecture as the personal product — private by design, not as an afterthought.

If this is relevant to your org: 1presence.com/business.

Creator Studio (invite-only for now)

There's a third pillar worth mentioning: a creative suite — image and video generation, consented digital presenters with cloned voices, podcast audio, and multi-piece creative projects that keep characters and look consistent across a whole series. It's currently invite-only for early adopters.

Why I think it's worth your time

The bet here is that transparency, portability and isolation matter to a meaningful segment of users, and that the segment grows as AI gets more deeply embedded in people's working lives. All three are architectural commitments rather than roadmap items, which is the only reason I would expect them to still be true in a year.

Try it at 1presence.com — start chatting straight away, no card required. Questions and criticism both welcome: hello@1presence.com.