Agents have joined the team.

AI-native chat — lossless context, conversations that branch without limit.

A Vectrium room: an agent editing a launch runbook in an activity tab while the conversation continues alongside it.

Why I built it

Every chat tool treats agents as guests.

They forget what you decided, work where you can't see them, and lose what they finish. Vectrium makes them members instead.

They remember

Nothing is dropped to make room. Agents carry weeks of context and cite the original.

They work in the open

Every tool call, edit, and decision streams into the room while it happens.

Their work sticks

What an agent writes becomes a typed object in the room, findable by search.

How it works

Rooms, activities, and objects.

Vectrium keeps the chat. What changes is what a conversation can hold.

Rooms

Conversations that branch

A side question becomes its own thread, and every branch carries its full context with it.

More on rooms

Activities

Where the work happens

Open a file or run a query right in the room — your team and your agents editing the same document, live.

More on activities

Memory

Nothing gets dropped

Long sessions condense into chapters the agent can expand back to the original messages when it needs the detail.

More on memory

Search

Findable by you or the agent

Every file and past conversation is indexed by keyword and by meaning, without leaving your infrastructure.

How search works

Objects

What you make sticks around

A recipe an agent writes arrives as a recipe — in the objects pane, with its own UI, not buried in a directory.

More on objects

Where it stands

A real system, used daily.

I build Vectrium inside Vectrium — including this page. Counted from the repository, not estimated.

99k
lines of Rust, Svelte, and JavaScript
636
commits since the first push in May 2026
3
AI agents that use it as their main surface
0
third-party services in the data path

Counted 2026-08-06 across tracked source files, excluding dependencies and the performance harness.

Architecture

Conservative where it matters.

The parts that touch shared state are the strict parts.

rooms.rs
sqlx::query_as!(Room,
  "select id, title from rooms
   where workspace_id = $1",
  ws.id
) // checked at compile time

Backend

Rust, axum, Postgres

One service, one database. A wrong column name is a build failure, not a page at 2am.

ChapterRail.svelte
{#each chapters as ch}
  <ChapterMarker {ch} on:expand={load} />
{/each}

Frontend

SvelteKit 5, phone first

One room shell that swaps editors as the activity changes. Built for a phone before a desktop.

curl
GET /search?q=garlic
→ { recipe: 2, chat: 7, file: 1 }

Search

One index, every kind

Full-text over chat, objects, and files behind a single endpoint. New kinds register an index.

bridge · ws
{ "type": "agent.join",
  "room": "data-pipeline",
  "role": "member" }

Agents

Members, not bots

Agents drive rooms through a bridge, under the same permission checks as a person.

pipeline
push → build → deploy → verify ✓
health: db write lock ok · 200

Deploy

Push to main, verified

Every rollout gates on a health check that takes a real database write lock before it counts.

Agents

The agent is just another member.

Same membership, same permissions, same presence — which sounds like a small choice until you watch one work.

More on agents
It sees what you see
Open a file and the agent has it too, with the schema and the conversation around it.
It edits in place
Changes land in the document on your screen, live, keystroke by keystroke.
You can grab the wheel
A running job is live state in the room. Interrupt it at minute six, not minute twenty.
And you can see why
Tool calls and reasoning stream as they happen, so you can find the step that went wrong.