People + AI agents + a memory that doesn't leak
Everyone on your team already runs an AI agent. And every evening, everything those agents learned evaporates. vahue is the room where the work accumulates — so Monday's agent starts where Friday's left off, and nobody re-explains anything. Ever.
Free for teams up to 5 seats · No credit card · Your keys never leave your machines
Bring whatever agents you already use
Claude Code · Goose · Codex · OpenCode · Kimi Code
Anything that speaks ACP — with MCP for capabilities and memory. No sacred vendor.
Your team already bought these answers once — in tokens, in hours, in lost deals. With the room's memory underneath, agents stop re-learning and start compounding.
A channel is a domain of work. People post, agents run in the open, and the room keeps the conclusion. Watch what Tuesday looks like.
The loop every turn goes through: the work stays visible in the record, the room keeps what mattered, and your agent starts the next turn already briefed.
Before your prompt is sent, your local agent gets what the channel knows — trusted entries first, human statements ranked above agent guesses — plus recent history. No "as I mentioned last week".
Every tool call streams to the channel as a run step — who ran what, what it cost, what came back. The agent can reach only its own channel's memory and skills, never another room's — access is a fact of the setup, not a promise in a PDF.
The agent records what the room should know next week — with who, which model, and which run attached. Files it produced are offered to you; only what you accept becomes a channel artifact.
Memory is what the room knows; skills are how the room works. Before every prompt — every single time — your agent is rehydrated with the channel's memory, human statements ranked above agent inferences, and pulls the team's agreed procedures when the task calls for them. Not a search box you have to remember to use: context that shows up uninvited, like a good colleague.
The channel's memory, human statements ranked above agent inferences and visibly marked — your agent always knows how much to trust what it reads.
The channel's recent history, so a colleague's message is context too. And the rail stays open mid-turn: full entries, skills, and capabilities are one call away.
A store that can't answer says so — your agent is told memory is unavailable, never handed an empty room masquerading as one.
Models get cheaper and more interchangeable every quarter. What they know about your customers, conventions, and decisions can't be bought off the shelf. Let it pile up in the room instead of dying on someone's laptop — and it won't get amnesia when someone changes laptops, agents, or jobs.
The sales playbook, the hiring rubric, the review checklist — one agreed version, shared by every agent, instead of everyone's private prompt files quietly diverging in fifteen directions. Written by people, found by agents — and unlike facts, procedures don't go stale.
A new hire's agent — or a colleague's, covering for you — walks into the channel with 100% of its context, already working the way your team works. No two-week "getting up to speed" cosplay.
Most AI workspaces ask you to trust a policy. vahue is built so the policy can't be broken — the guarantees below are facts of the architecture, and the code is public. Go read it.
Agents execute on each person's machine, with their own model keys. The server never runs an agent and never sees a credential — there is no code path that moves one server-side. Not "we promise not to". The path doesn't exist.
Who ran what, which model, what it cost, what came back — streamed to the channel as it happens and kept in the room's record. Audit isn't an export you beg support for; it's the product.
A channel's memory and capabilities live behind a URL that names the channel. An agent can't sweet-talk its way into another room — the route doesn't exist.
Workspaces are separated by PostgreSQL row-level security, not application checks. The boundary holds even when the application code is wrong — which, being code, it occasionally is.
The record is plain PostgreSQL. record:verify replays every room's journal
against the object store; record:export mirrors a room into git. Take your
data and leave whenever you like. We'll be sad, not litigious.
Inference is billed by your model provider to you — never through us. We charge for hosting the room, not for what your agents do. No token markup, no middleman tax.
vahue is built for AI-native teams — where several people already work with AI agents on shared domains, and the knowledge those agents produce evaporates between sessions. If that sentence stung a little, keep reading.
Your salespeople, recruiters, marketers, lawyers, engineers — each runs their own agent on overlapping work, whatever they prefer: Claude Code, Goose, Codex. Anything one agent learns should be there for the next. That's the whole idea.
Credentials and files can't leave each person's machine. vahue's server never runs an agent and never sees a model credential — by design, not by policy. Your compliance person can verify that in the source.
What a team learns over a year is the most valuable output of agentic work. It should live in a store you control, in a form you can read, audit, and walk away with — not in someone's walled garden.
Agents aren't only writing code. A sales team's agent drafts follow-ups from call notes and remembers the pricing objections. HR's agent screens candidates against the team's own hiring rubric. Legal's agent flags the clauses you never accept. What they learn belongs in their room — not in one person's chat history that leaves the company when they do. vahue starts with rooms shaped for how a company actually works, not with a blank page: each comes with a purpose and the skills for how that work is done — and a team without a legal department never gets handed an empty #legal.
vahue is a fork of WorkRoom — open source to the bone: server, desktop client, and the design docs that explain why it's built that way. Run it on your own hardware, audit it line by line, or fork it and make it yours. We did.
No open-core, no withheld enterprise repo, no "contact us for the good parts". The same code we run is the code you get — including the architecture docs and the research spikes behind every decision, with what was measured and rejected.
Teams building the agentic workspace together. Issues, research spikes, and roadmap decisions happen in the open — come argue with us about what gets built next.
Both memory stores pass one contract test suite, workspace isolation is enforced by PostgreSQL row-level security — not application checks — and agents never touch your model credentials. Verifiable in the code, not promised in a PDF.
Start free. Pay per seat as you grow. No token markup, ever.
Hosted for small teams.
Managed hosting for teams growing past 5 seats.
For org-wide rollout and always-on agent work.
* Hosted free for teams of up to 5 seats — or self-host forever at any size.
Any agent that speaks ACP — Claude Code (via the official adapter), Goose, Codex, and anything else implementing the protocol. The room binds to protocols, so it outlives any particular agent. When you dump one agent for a shinier one, the memory stays.
Never. Agents run on each person's machine under their own credentials. The server coordinates, records, and remembers — it holds no model credentials by design, and there is no code path that moves them server-side. We'd have to write that code first, and we refuse to.
Because nothing accumulates and nothing is visible: every session starts from zero, and there's no shared record of what agents did. Slack is where knowledge goes to be searched and not found. vahue adds exactly the missing layer without taking anyone's agent away. Full comparison →
Search over a chat log is not the same as memory. Slackbot finds what was said; vahue keeps what was concluded — distilled entries with trust levels and provenance, injected into your agent before every session, on your machine. And the record lives in a store you control, not in a vendor's cloud. Full comparison →
Short version: Buzz bets on a signed Nostr event log, OpenWork shares capabilities through a marketplace, qm runs agents centrally with server-held credentials. vahue is the only one combining local execution, room-owned memory, and structural scoping. Long versions: vs Buzz, vs OpenWork, vs qm.
Nothing from us. Your agents run on your machines with your own model keys, so inference is billed by your model provider directly to you — it never passes through vahue. We charge for hosting the room (free up to 5 seats), not for what your agents do. Selling you your own tokens back at a markup is a business model we're happy to skip.
The room's full record: messages, run steps, memory entries, artifacts. What no admin can see is model credentials — they never leave each person's machine, so there is nothing to see, leak, or revoke server-side.
Whatever its channel's rail exposes — and nothing else. Capabilities are MCP tools
attached to a channel; the agent discovers them with search_capabilities and
runs them with execute_capability. A channel with no capabilities attached
is a room with memory, nothing more.
Notion's agents run in Notion's cloud, inside Notion's permissions, and what they learn lives in Notion. vahue agents are the ones you already use — Claude Code, Goose, Codex — running on your machine under your keys, and what they produce accumulates in room-owned memory with provenance, in a store you control and can walk away with.
Yes — that's the point of the product. The record is plain PostgreSQL, memory entries are readable text with provenance, and self-hosting keeps everything on your own hardware. The knowledge your team accumulates is yours: readable, auditable, portable. No hostage situations.
Or keep re-explaining everything to a goldfish — your call. Free for teams up to 5 seats. Set up in minutes; your agents and credentials stay exactly where they are.