Scope & Architecture · Lane A Code

Pure Chat.aiFrom a chatbot to the agent that runs PURE

Today Pure Chat.ai converses, sees images, and drafts tickets. Best-in-class means it can reach everything we've built — the board, the dictionary, 156 memory facts, the live MCP tools, and the open web — reason across them, and take gated action, all from acquisto.biz on our own API.

305live board tickets
25live MCP tools
156memory facts
141data tables
15connectors
Weblive search
1 Everything it will reach

One assistant, wired to the whole system

Pure Chat.ai stops being a sandbox. Every surface we've built becomes a tool it can read — and, with approval, write. Nothing here is hypothetical; these are live tables and functions in our Supabase project today.

The Ticket System

Read, draft, dispatch, claim, update — the same board every lane uses.

305 tickets · pure_board
board.listboard.dispatchboard.updateintake.submit

The Dictionary

PURE canon — org model, brand rules, transaction terms. It speaks our language correctly.

20+ terms · pure_dictionary
dict.lookupdict.adddict.suggest

Memory

Standing facts, doctrines, decisions across every session — so it never forgets how PURE works.

156 keys · pure_memory
memory.getmemory.setmemory.sweep

Live Operations Tools

The pure-mcp server: deals, listings, docs, leads, approvals, QA, rate limits — already deployed.

6 servers · 49 tools
deal.readsearch.listingsdoc.statuslead.createapprovals.list

The Open Web

Native server-side web search + fetch — current facts, market data, comps, anything online, with citations.

Live search · fetch
web.searchweb.fetch

Vision & Connectors

Reads pasted screenshots & contracts; reaches FUB, Matterport, Maps, Zoho, Analytics via Composio.

15 connected apps
visionfollow_up_bossmatterportzohogoogle_maps
2 How it thinks

An agent loop, not a single reply

Every message runs a reason act observe loop on our own server (the chat Edge Function, holding the Anthropic key). Claude decides which PURE tools to call, calls them, reads the results, and only then answers — grounded in real data, with any write surfaced for your approval.

You
Ask anything

"What's blocking the Smith closing, and draft the agent a status note." · Paste a screenshot · "Find 3-bed comps near this listing."

Pure Chat
Reason + pick tools

Claude plans: look up the deal, check the doc status, search the dictionary for canon terms — then gather what it needs.

deal.readdoc.statusboard.listdict.lookupmemory.getweb.search
PURE backend
Execute & observe

Tools run against the live pure-mcp RPCs and Supabase (service-role, every call audited). Results stream back into the model.

You get
Grounded answer + gated actions

A real answer citing live data and the web — plus an approval card for anything that writes (dispatch a ticket, message an agent, save a fact).

board.dispatch approvecomms.notify approvememory.set approve
3 Capability matrix

What it can do — and what needs your nod

Reads run freely so it's fast and useful. Every write is human-gated through an approval card, scoped by who's signed in (agent / broker / super-admin), and written to the audit log.

CapabilityToolsAccess
Know the build
Answer about tickets, status, decisions
board.list · memory.get · dict.lookup · jobs.listRead · free
Know the business
Deals, listings, docs, leads, approvals
deal.read · search.listings · doc.status · approvals.list · rate.statusRead · free
Search the world
Current facts, comps, market, research
web.search · web.fetchWeb · cited
Move work
Create / dispatch / update tickets & leads
board.dispatch · ticket.update · intake.submit · lead.createWrite · approve
Reach out
Notify a person, send branded email / SMS
comms.notify · email.send · sms.send · lane.mailWrite · approve
Remember & define
Save a fact, add a canon term
memory.set · dict.addWrite · approve
4 The experience

It should feel best-in-class, too

The intelligence is only half of it. The interface makes the agent legible, trustworthy, and fast — so you always see what it touched and stay in control.

Tool transparency

Inline step chips — "looked up 3 tickets," "searched the web," "read the Smith deal" — so every answer shows its work.

Approval cards

Any write pauses on a card: the exact action, editable, with Approve / Edit / Cancel. Nothing happens behind your back.

Slash commands & quick chips

/ticket · /board · /find · /define · /remember · /web — power moves one keystroke away, plus smart suggested follow-ups.

Citations

Web answers link their sources; data answers name the record (deal #, ticket id) so claims are checkable.

Streaming replies

Tokens stream as Claude thinks; the PureLoader shows during tool calls. It feels alive, never frozen.

Scope & identity

It knows who's signed in (Mike, Shana, an agent) and only offers tools that role is allowed — broker vs agent vs super-admin.

5 Rollout

Four phases, mostly already underway

We ship value at every phase — nothing waits for the whole thing. Lane A (Design) owns the experience and the live grounding; Code owns the agent loop, tool execution, and gated writes.

0
Done

Conversational core

The foundation is live as of this session.

  • Full conversation memory (sends history)
  • Vision — reads pasted screenshots & images
  • Helpful assistant persona + ticket drafting
  • Server-side Anthropic proxy (chat Edge Function, key held server-side)
Shipped — live on acquisto.biz/pure-chat.html
1
Lane A

Ground it in live PURE knowledge

Before any backend change, make Pure Chat genuinely knowledgeable today by feeding it a curated, live context pack.

  • Inject dictionary canon (brand, org model, naming) so it never misuses our terms
  • Live board snapshot — open tickets, easiest-first — so "what's open?" is real
  • Key memory facts (deploy doctrine, identity model, standards)
  • Read-only, no new infra — front-end composes the system context
Ready to build now — on your go
2
Code

Agentic tool-use (reads) + web search

Upgrade the chat function to a real tool-use loop over the live read tools, plus native web search.

  • Define tool schema run Anthropic tool-use loop, executing via pure-mcp RPCs
  • Read tools first: board.list, deal.read, doc.status, search.listings, dict.lookup, memory.get, approvals.list
  • Enable Anthropic server-side web_search + web_fetch with citations
  • Every tool call audited to audit_log; rate-limited per IP
Code lane — builds on pure_chat.backend_plan
3
Code
+ Lane A

Gated writes + approval UX

Let it act — safely. Writes return a proposed action the front-end renders as an approval card.

  • Write tools: board.dispatch, ticket.update, lead.create, memory.set, dict.add, comms.notify
  • Service-role inserts (anon is read-only on pure_board) behind a confirm token
  • Lane A builds the approval-card UI + tool-activity step chips
  • Per-principal scope from the signed-in session (agent / broker / super-admin)
Joint — Code backend + Lane A experience
4
Code

Connectors & deep retrieval

Extend reach to outside systems and make recall semantic.

  • Connector tools via Composio / pure-connect: FUB leads, Matterport, Maps, Zoho, Analytics
  • Embeddings retrieval over dictionary + memory + docs for fuzzy recall
  • Outbound comms (email/SMS) once A2P/SES are live
Phase 5 servers (pure-connect / pure-comms / pure-money)
6 Guardrails

Powerful, but never reckless

Human-gated writesReads are free; every write pauses on an approval card. The agent proposes — you commit.
Per-principal scopeTools are filtered by the signed-in role. An agent can't reach broker-only money or deploy tools.
Full audit trailEvery tool call lands in audit_log with caller, args, and result — the existing pure-mcp pattern.
Rate & spend capsPer-IP request limits on the public proxy; the key never leaves the server. No PII to the model beyond the task.
7 The handoff

What we're asking Code to build

Sent directly to Code via lane-mail. The conversational core is already live — this is the agent layer on top of the existing pure-mcp tools and pure_chat.backend_plan.

  1. Tool-use loop in the chat function — Anthropic tools schema mapped to pure-mcp RPCs; execute observe continue until final answer.
  2. Read tools first — board.list, deal.read, doc.status, search.listings, dict.lookup, memory.get, approvals.list (all already exist as RPCs).
  3. Native web search — enable Anthropic web_search + web_fetch server-side, return citations.
  4. Gated write path — board.dispatch / ticket.update / lead.create / memory.set / comms.notify return a proposed action + confirm token; service-role commits only after the front-end approval.
  5. Scope + audit — resolve principal from the session, filter tools by role, log every call to audit_log; rate-limit the public endpoint.
Pure Chat.ai — Best-in-Class Agent · Scope & Architecture Lane A (Design) Code · v6.laneA · grounded in live Supabase inventory