01
Embeddings on your own Ollama
Vector embeddings run through the Dhara Ollama endpoint, not a third-party model API. Your corpus is never the training data for someone else's product.
Architect · The workspace your team actually returns to
A workspace that remembers what your team decided, and why.
Architect is what we built so engineering decisions stop being lost between Slack threads, Looms, and re-litigated meetings. It carries diagrams, sessions, and decisions across weeks — with a memory layer that grounds every model call in your own corpus, not the open internet.
Owned embeddings. Sovereign memory. No third-party model with a copy of your context.
Surface signal
Status
LIVE
Tenancy
Single-tenant
Workspace
architect.eleven11.pro
Why this exists
Decisions don't survive the week.
Every team that ships infrastructure has the same loop. A Slack thread, a Loom recording, a Notion page, a whiteboard photo, a follow-up meeting — and three weeks later somebody re-litigates the decision because nobody can find what was decided. Architect is what we built so our team, and yours, can stop doing that.
It is a workspace your team opens every day. Not a tab in a dashboard. Not a wiki you remember to update. The place where the next decision gets made because the last one is still in the room.
Self-sustained by design
Owned, not rented.
When your AI tooling stops working because a third-party provider had a bad day, that's a problem. Architect is built so that doesn't happen — and so the corpus your team builds isn't somebody else's training data.
02
Memory units in your tenant Postgres
The vector store, the knowledge graph, and the memory spine live inside your workspace's Postgres on a per-tenant Hetzner box. Single-tenant by construction, not by configuration.
03
Auth at the edge, not in the app
Cloudflare Access in front, header-trust at the origin. No JWT secrets to rotate, no session table to compromise, no third-party SSO to depend on for read access.
04
BYOK for query-time models
Architect never silently routes your context to Anthropic. You bring your model key, you choose the model, you control the spend. Suggestion, never default.
05
Export and deletion are part of the contract
Workspace export is a function, not a support ticket. Deletion is a path that actually completes. Read the trust hub for the specifics — it's not boilerplate.
The primitive
Three things you can name. Typed.
Architect is built on three primitives — a canvas to draft on, a session to lock decisions into, and a matter to own the work after. They compose deliberately. Promotion between them is a ceremony, not a side effect.
01 · Drafting
Canvas
/c/<slug>
Where ideas start. Tiles you can drag, connectors that mean something, generative widgets when you need them. Drafts don't have to commit to anything. Move things around the way you would on a whiteboard, except the canvas remembers.
02 · Locking
Session
/s/<slug>
Where ideas become decisions. A session is a notebook with a lock — once you lock it, the version is anchored, immune to silent edits, citable later. The locked text is what every future model call leans on when it answers a question about prior context.
03 · Owning
Matter
/p/<matter>/<page>
Where decisions become work. Matters are the system of record — the place an ask gets a billable hour and a runbook. When a session graduates into something with an owner and a deadline, it lands here.
Memory spine
Recall first, model second.
This is the layer that separates Architect from a chat-on-top-of-your-notes tool. Every model call grounds itself in your corpus, every claim carries a citation, and a second pass catches drift before it reaches you.
Memory has its own page — read the explainer.
Memory units + vector recall
Every locked thought lands as a `memory_unit` in pgvector. Recall is a first-class call, not a model-side guess.
Grounded LLM calls
Model calls cite the units they leaned on. If the model can't ground the answer, it says so instead of hallucinating one.
Distortion guard
A second pass checks the model didn't drift from its citations. Wrong-but-fluent answers get caught before they reach the user.
Consolidation + reaper
Near-duplicate units merge. Stale units age out. The spine stays useful instead of growing into a swamp.
Knowledge graph
Concept-overlap edges between sections, browseable at `/mind`. The structure that lets prior context resurface across unrelated matters.
How it fits the fleet
The other tools, inside your canvas.
Architect doesn't replace your existing tools — it consumes them. Every Eleven11 product publishes a widget contract; Architect renders those widgets inside the canvas and the matter pages, so a Dhara finding, a Cal availability check, or a Kosh table view lives next to your prose, not in another tab.
dhara
Findings render as canvas tiles and matter sections. Severity, evidence, fix proposals — all inside the same workspace where you'd already be discussing them.
kosh
A Kosh table view appears as a Tier-B canvas widget. Asks can recall rows. Memory can promote a row into a citable unit.
cal
Availability checks, event creation, and free/busy resolution land as inline answers in sessions. No tab-switching to your calendar.
pr
A proposal session can stage a draft into the PR pipeline; the draft comes back as a versioned memory unit when published.
studio
Render queues and generated assets surface as widgets. A Studio carousel renders inline so the team can review without leaving the matter.
alerts
Every locked session, every promoted ask, every model failure emits a normalized event. The audit trail is the same one operations watches.
Surfaces & contracts
Six routes. Each with a clear job.
Architect's URL space is small on purpose. No tab graveyard. Each surface is something a workspace actually visits.
Mind has its own page — see the screenshot and walkthrough.
/c/<slug>
Canvas
Spatial workspace — tiles, connectors, generative widgets.
/s/<slug>
Session
Lock-ceremony notebook — prose with versioned snapshots.
/p/<matter>/<page>
Matter page
Anchored asks, billing buckets, template promotion.
/mind
Mind
Workspace knowledge graph — drill, tune, suggest.
/onboard/import
Import
Bring Obsidian, Markdown, paste, or a URL list.
/e/<token>
Episode
Scoped, revocable share of a `/mind` view.
Senior engineering, visible
The proofs are in the substrate.
Senior engineering is the kind of thing every consultancy claims and very few demonstrate. These aren't adjectives — they're design decisions visible in the code, the migrations, and the deploy shape.
Hand-authored idempotent migrations
No `drizzle-kit generate`. Schema is what you wrote. Every migration is safe to re-run, so dev and prod don't quietly diverge.
Every model call cites + grades itself
Asks pass through verifiable rules; a Pass-B reviewer auto-retries when the answer fails its own grade. Hallucination is a caught error, not a UX surprise.
No silent catches
Every error surfaces, logs, or carries an inline comment explaining why swallowing is safe. You can read the codebase and trust what you see.
Single image, two processes, no surprise drift
The web tier and the worker tier ship from the same Dockerfile. Migrations only run on one. The deploy is the same shape every time.
The fleet is the proof
Eleven11 runs on Architect. Customer engagements, sales motion, infra audits, this very marketing site — all of them live as matters in the same workspace shape we'd hand you.
Who this is for
Teams where memory is load-bearing.
Architect earns its keep when the cost of losing context starts to exceed the cost of maintaining a workspace.
Founders and CTOs making architectural decisions across multiple systems.
Engineering leaders who want decision history without a wiki maintenance tax.
Teams already running consultants or agencies — Architect's session lock and matter pages produce billable artifacts naturally.
Solo operators carrying load that exceeds a single-person memory budget.
Organizations that want their AI tooling to ground every claim in their own corpus, not the model's training data.
FAQ
Final friction, reduced.
Is this another AI productivity tool?
No. Architect is a workspace with a memory spine that's grounded in your own corpus. The AI calls are governed by recall, citation, and a distortion guard — not by free-form generation.
How does this relate to Dhara, Kosh, Studio, and the other products?
Architect sits above them. Each tool publishes widgets and resources Architect consumes. A Dhara finding, a Cal availability check, a PR draft, a Kosh table view, a Studio render — they all land as tiles or matter sections inside the same canvas.
Do we have to import everything to start?
No. `/onboard/import` accepts Obsidian vaults, plain Markdown, paste, or a URL list — but a brand-new workspace works without any import. Memory accrues from the first locked session.
Who owns the data?
You do. Architect is single-tenant per workspace and the memory spine lives in your workspace's Postgres. Export and deletion paths are part of the contract — see the trust hub.
Open Architect
The workspace is live. Walk in.
Architect is the surface our team uses every day. Open the workspace if you have access; talk to us if you want to bring your team in.
Direct line
Consultation requests stay owned. We reply from e11 after reviewing fit and timing.