AI that actually does things.
The Assistant has memory, identity, and permissions. It drafts the doc, books the meeting, sends the contract, and routes the task. Every action is policy-checked. Every decision is audit-logged. Nothing happens that the user could not have done themselves.
Four layers, built for action.
The Assistant is not one model. It is four layers stacked: memory, planner, executor, auditor. Each is replaceable. Each is observable.
A per-user, per-workspace memory store. Lives in your tenant. Reads the work graph. Never includes another user's data without that user's grant.
Decomposes "draft the recap and book the follow-up" into typed steps. Each step has preconditions, side effects, and a reason. Plans are inspectable.
Calls module APIs through the same auth path a user would. Cannot escalate. Policy gate runs before every side effect. Holds for human approval where required.
Every step, every input, every output, every policy decision is logged with a stable hash. Reproducible from the log alone.
Five things that compound.
A chatbot summarizes. The Assistant operates. The difference is that operation requires identity, permission, and audit, which most chatbots do not have.
Every draft is generated from spans in the work graph. No hallucinated metrics. No invented quotes. The cite is on every paragraph.
The Assistant inherits the user's permissions. It cannot send mail from an account it cannot read. It cannot edit a doc the user cannot edit. Escalation is impossible by design.
Money-moving actions, external sends to net-new addresses, contract signs, and large data exports require explicit human confirmation. The held action shows up in the user's queue.
Per-user, per-workspace memory of preferences, decisions, and prior conversations. Memory is auditable, editable, and exportable. You can delete a memory permanently.
Picks up your jargon, named systems, and abbreviations from your docs and history. Refers to "M-318" or "the Frankfurt cluster" the way your team does, not the way a generic model would.
Three phases, per action.
A user asks. The planner expands the ask into typed steps. The executor runs the steps in order, with policy and audit on each. Three loops, one log.
Decompose to typed steps
The planner produces an inspectable plan: step type, target module, args, preconditions, and a side-effect tag (read / write / external).
Gate every side effect
Each writing step passes the policy engine. Reads are unrestricted. Writes are checked against the user's permissions. Sensitive actions are explicitly held.
Log every event
Every step writes an event with input hash, model, policy decision, side effect, and latency. Recorded in the workspace audit log, replayable, and exportable.
Nine more, all in policy.
Each is on by default for every workspace, gated by the workspace's policy bundle.
Per-user identity
Acts as the user, not as a shared service account. Audit attributes every action to a human.
Policy engine
Rego-style rules. Pre-built bundles for high-value, external-recipient, after-hours, and sensitive scope.
Memory you can read
Click into the memory store, see what the Assistant remembers, edit or delete any entry. Logged.
Streaming UX
Plans, steps, and outputs stream live. Users see what is about to happen before it does.
Multi-user delegation
"Have the Assistant draft this on Mia's behalf and ship for my review." Delegations are time-boxed and audited.
Model neutrality
Anthropic, OpenAI, Cohere, Mistral, or a model you host yourself. Per-workspace default plus per-skill override. Bring your own model key.
Encrypted in transit and at rest
TLS 1.3 on every request. Memory, plans, and logs are encrypted at rest by the managed hosting layer.
No training on your data
Your tenant's content is not used to improve a shared model. Enforced by the model provider's API terms.
Skill marketplace
Curated skills with permission manifests. Install with one click. Each skill discloses its scope.
Operates every module.
The Assistant is the only surface that touches every other module. It is also the only surface that touches all of them through their public APIs, not behind their back.
One actor for the whole stack
Every module exposes a typed API. The Assistant uses those APIs, the same ones third parties use. Nothing private. No back doors. That is why permission boundaries actually hold.
Programmatic Assistant.
Drive the Assistant from your own code. The plan, policy, and audit surface are first-class.
// Ask the Assistant to draft and act. Stream the plan, policy decisions, and outputs. import { Wrx } from "@wrxstack/sdk"; const wrx = new Wrx({ token: process.env.WRX_TOKEN }); const run = await wrx.assistant.run({ as_user: "mia@acme.com", ask: "Recap the Acme call, send MSA v3 to legal, and book the onboarding walkthrough Thursday.", policy: "standard_b2b_sales", on_hold: "prompt_user" // or "deny", "escalate" }); for await (const ev of run.events()) { switch (ev.kind) { case "plan": console.log("plan:", ev.steps); break; case "policy": console.log(ev.step, ev.decision, ev.reason); break; case "action": console.log("did:", ev.target, ev.id, ev.latency_ms); break; case "hold": await wrx.assistant.confirm(ev.action_id, { actor: "mia@acme.com" }); break; case "audit": // writes to the workspace audit log with input hash break; } }
Assistant vs. ChatGPT Enterprise.
ChatGPT Enterprise is a chat surface with optional connectors. wrxstack Assistant is an action layer with identity, policy, and audit on every step.
wrxstack Assistant vs. ChatGPT Enterprise
| Capability | ChatGPT Enterprise | wrxstack Assistant |
|---|---|---|
| Per-user identity on actions | Service account model | Acts as the user, audit attributes back |
| Policy gate on side effects | Not built in | Rego-style per step |
| Audit log | Prompt log | Step + policy + side effect, exportable |
| Memory you can edit | Opaque | Readable, editable, exportable |
| Native operates the platform | Custom GPTs + connectors | All 16 modules, native |
| Hold-for-approval | Not native | Per-policy, per-step |
| Model choice | OpenAI only | Anthropic, OpenAI, Cohere, or self-hosted models |
Common questions.
Six things security and engineering leaders ask in the first hour of evaluating Assistant.
How is "acts as the user" actually enforced?
The Assistant signs every API call with a delegated token tied to the user's session. The platform's auth layer treats it like any other authenticated request, with the same ACL checks. There is no shared service account that can write on behalf of multiple users. An action's audit row has the user identity, not the assistant identity.
How does memory work, and is it visible?
Memory is a per-user, per-workspace store of preferences, decisions, and conversational facts. You can see every entry in a dedicated UI. You can edit or delete entries. Deletion propagates to derived embeddings within 10 minutes. Memory never crosses tenant boundaries.
What does the policy bundle actually contain?
A typical bundle has rules for high-value financial actions, external recipients on first contact, sensitive scopes (HR, finance, legal), after-hours actions, and bulk operations. Each rule produces an allow, allow-with-confirm, or deny. Bundles are versioned, reviewable, and testable.
How do you keep the model from inventing facts that look like actions?
The planner is constrained: every step has to type-check against the public module schemas. Steps that do not type-check are dropped. Outputs are grounded in retrieved spans. The audit row carries the input hash so a reviewer can replay and verify.
What is the worst-case if a rogue actor compromises the Assistant?
The Assistant can do at most what the user could do. There is no privilege escalation path. Policy gates fire even if the Assistant is bypassed. The audit log records every action against the acting user and is exportable for review. Recovery is a session revoke plus a normal incident response.
Can we bring our own model?
Yes. The Assistant supports Anthropic, OpenAI, Cohere, Mistral, and any OpenAI-compatible endpoint, including one you host yourself. Set a per-workspace default and override the model per skill. You bring your own model-provider key.
Does the assistant work across all my apps, or just one?
Across all of them. The Assistant reads and acts on the whole work graph, tasks, projects, docs, the CRM, inbox, meetings, contracts, and the 60+ integrations, in a single request. It can pull a figure from a document, update the matching CRM deal, and open a task from one instruction. A copilot bolted onto a single app can only act inside that app. Every action runs as the user, inside their permissions, and is written to the audit log.
Pairs well with.
The Assistant gets sharper with every other module live. Three to start with.
Type. Watch. Audit.
Pattern-matched, browser-only demo. Real grounded responses, real audit trails: the same three columns the production assistant writes to the workspace audit log.
⌘ + Enter to send · Esc to clear · Runs entirely in your browser.
Assistant response · session local
Who this is not for.
Assistant takes actions inside Atlas, so it is not a general-purpose chatbot. It is built and maintained by one person and does not yet hold SOC 2 or any formal certification, so it suits small and mid-size teams that value speed over a procurement checklist. If you need an open-ended model for research and long-form writing, or a vendor with an enterprise compliance program already in place, a large model provider will fit better.
An AI you can actually trust.
Free to start, no credit card. Standard policy bundle in the box. SSO available.