QUAN 2.0 documentation

Overview

QUAN 2.0 is an agentic AI operating system: a coordinated team of specialized AI agents with persistent memory, real tools and connectors, and approval-gated actions, working across web, a native Mac app, Telegram, and iMessage. It is an operator, not a chatbot. You give it a goal, and it reasons, plans, uses tools, verifies its own work, and returns a finished result, pausing for your approval on anything consequential.

QUAN 2.0 is proprietary and closed-source. Access is by request. It is built and operated by InterSpace Labs (legal entity: InterSpace Distribution).

Key concepts

• Agent. A configured operator with its own system prompt, default model, and tool set. QUAN ships shared agents (General, Sales, CMS) and lets members create their own.
• Persistent memory. Typed, editable long-term memory of people, projects, and decisions, split into a shared house scope and per-member private scopes.
• Tools. Real actions an agent can take: email, calendar, web search, code execution, browser automation, image generation, and more. Every tool is scoped and, where consequential, approval-gated.
• Connectors (MCP). External systems plugged in over the Model Context Protocol (for example Notion or GitHub). Adding one is configuration, not code.
• Reasoning core. The plan, execute, and verify loop that runs on harder tasks, with a critic that checks the work before it is returned.
• Orchestration. Delegating a goal across multiple specialized agents in parallel and synthesizing their results, under a strict budget.
• Approval. A staged action that waits for a human tap before it executes. Anything touching money, mail, customer records, or the outside world is staged.

How it works

Give QUAN a goal and it runs the same loop every time, from understanding to delivery, pausing only where you want a say.

1. Understand. It interprets the request and recalls everything relevant from persistent memory.
2. Plan. On non-trivial work it drafts a plan, decomposing the goal into ordered steps. Plan mode lets you review and approve the plan first; say go to proceed.
3. Route. It selects the right model for each task. Members choose a tier (Low, Medium, or Max) and QUAN auto-selects the underlying model.
4. Act. It calls real tools and connectors, runs code in an isolated sandbox, and drives a real browser when a system has no API.
5. Delegate. For bigger jobs it fans out to specialized agents in parallel and synthesizes their work, with a manager keeping the effort on budget.
6. Verify. An adversarial critic reviews the result, catches errors and gaps, and triggers a bounded correction. Background jobs loop until they converge.
7. Confirm. Consequential actions are staged for one tap. Nothing leaves the building without you (unless you turn on auto-accept for a conversation).
8. Remember. It writes the outcome back to memory you own and promotes what worked into reusable know-how.

Channels

The full agent stack runs server-side. Each surface is a way in, and your agents and memory follow you across all of them.

• Web. A fast, full-featured workspace in the browser.
• Mac app. A native, universal (Intel and Apple Silicon) macOS desktop app.
• Telegram. Connect your own bot and message your agents on the go, approvals included. See Connect your Telegram bot.
• iMessage. Text QUAN like a colleague, right from Messages.

Connect your Telegram bot

Every team member can connect their own Telegram bot and chat with their agents from Telegram, approvals included. Your bot is private to you: it serves only the one chat you link, and every message runs as you, reaching only your own agents.

1. Create a bot. In Telegram, open @BotFather, send /newbot, choose a name and username, and copy the token it gives you.
2. Connect it. In QUAN, open Profile & settings → Telegram, paste the token, and choose Connect.
3. Link your chat. Open your new bot in Telegram and send /start. It replies with a 6-digit code.
4. Confirm. Enter that code back in QUAN to finish linking. This step happens in your signed-in session, so only you can complete it.
5. Use it. Message your bot like the web app: switch agents with /agent, change the model with /model, plan first with /plan, and approve actions right from the chat.

Keep your bot token private. You can disconnect anytime from Profile & settings, which removes the bot and its access.

Models & routing

QUAN is model-agnostic. It routes across many models, reaching for the right one for each task, and works with your own API keys or self-hosted models.

Tiers (team members)

Invited members do not pick a raw model. They choose a tier, and QUAN auto-routes the actual model per task and, on Max, leans on multi-agent orchestration.

Bring your own, or use what is included

• Included. Every plan ships with an all-inclusive catalog of all major models, open-source and frontier alike, including Claude Opus, Sonnet, and Haiku, available under a single monthly subscription.
• Free with your own. Run your own self-hosted models, or plug in your own API keys, and QUAN is fully free to use, with no subscription.

Connection routes are configurable and updated on request.

Capabilities

• Persistent memory and learning across people, projects, and decisions.
• Multi-agent teams with manager, planner, and critic roles.
• Real tools and actions: email, calendar, invoicing, web search, code, browser, image generation.
• MCP connectors for Notion, GitHub, and any Model Context Protocol server.
• Autonomous workflows: one instruction triggers plan, act, verify, and self-correct.
• Sandboxed code execution in Python and JavaScript.
• Computer use: drives a real browser for apps with no API.
• Document intelligence over PDF, DOCX, XLSX, images, audio, and video.
• Knowledge and retrieval from a private, searchable knowledge base.
• Voice and transcription.
• Offensive and defensive security tooling, scope-gated and approval-bound.
• Runtime self-extension: writes and installs its own tools, skills, and connectors.
• Builds and ships real frontends: writes the code in its sandbox and deploys it live, base-path aware.

Terminal and CLI

QUAN runs as a full agentic coding agent in your terminal. It reads your code, edits files, runs commands, searches, and verifies its work, using the same memory, agents, and skills as the rest of QUAN. Model inference is relayed through QUAN, so the model keys stay on our servers, not on your machine.

Getting started

Start a session and talk to it in plain language. It uses tools on its own, with no copy and paste. Print mode runs a single task and exits, which suits scripts and pipes.

• Interactive: launch a session and chat; it streams its work as it edits and runs.
• One shot: pass a task to run it once and print the result.
• Resume: reopen the latest session in the current directory and continue where you left off.

Inline shortcuts

• @path attaches a file to your message; Tab completes the path.
• !cmd runs a shell command inline; its output carries into your next message.
• # note saves a memory instantly.
• Tab autocompletes commands, agents, and files; Up recalls history; Esc stops a running task.

Checkpoints and rewind

Every file the agent writes or edits is snapshotted first. /rewind undoes the last change, /rewind all reverts everything to the start of the session, and a single change can be targeted by id. Edits are shown as a colored diff, so you always see exactly what changed.

Agents, skills, and models

• Switch agents with /agent or /<name>; each carries its own role and instructions.
• Skills are expert playbooks the agent opens on demand for design, writing, diagrams, and more.
• Switch models with an interactive picker; the choice is remembered.
• Effort trades speed for depth with /effort.

Control and safety

• Permission modes: ask before edits and commands, auto to run freely, or plan for read only.
• Hooks run around tool use, so you can gate or audit actions.
• At a glance: /doctor for health, /cost for token usage, /diff for git changes.

Search and speed

• Web search finds answers without an exact URL, then reads the best result in full.
• Parallel tools: when the agent needs to read several files or search a few ways at once, it does them together instead of one by one, so multi step work finishes faster.

Connect external tools (MCP)

Point the CLI at any Model Context Protocol server, local or remote, and its tools become available to the agent alongside the built in ones. Use /mcp to see what is connected. This is how the CLI reaches services like code hosts, databases, and issue trackers.

Stay oriented

• Context meter: /context shows how full the working memory is, so long sessions never hit a wall by surprise.
• Status footer after every turn: model, mode, effort, context used, tokens, and checkpoints at a glance.
• Live plan: for multi step jobs the agent keeps an on screen checklist that ticks off as it works.

Show it, do not just tell it

Attach an image to a message and, on a vision capable model, the agent reads it: hand a screenshot of a layout or a sketch and ask it to build that.

The tool belt

The terminal reaches QUAN's own capabilities, not just your files:

• Create documents: render a real PDF, Word, or spreadsheet (agreement, letter, memo, report, invoice) and save it right where you are working.
• Reach people: send WhatsApp, Telegram, or email through the company connectors. Every send asks you to approve first.
• Hand off: /handoff sends a summary of the session to your phone, so you can start at the desk and continue on the move.

Keep typing while it works

You do not have to wait. While QUAN is running a command or thinking, anything you type queues and runs next, so the conversation never blocks. The input box shows the active agent and your place in the queue.

Many agents, not one

• Parallel subagents: QUAN can split a big job into independent pieces and run them at the same time, each as its own agent with its own context. Read-only by default, capped, and you approve the spawn.
• Delegate to a colleague: hand a question to a live specialist agent (general, sales, CMS) that runs on the server with its own role and memory, and get the answer back in your terminal.

Extend it yourself

• Custom tools: drop a small file in your tools folder and QUAN gets a new ability, no source changes. It is discovered automatically and listed with a command.
• Connect anything over the Model Context Protocol, as above.
• Scriptable: a JSON output mode streams structured events for CI and pipelines.

Built for safe operations

• Credentials by name: QUAN can use a stored credential by referencing its name; the secret value is injected only at the moment a command runs and is never shown to the model or written into a transcript.
• Egress audit: every outbound action is recorded, and you can block destinations by host.

A private vault for your secrets

QUAN keeps its own credential vault on your machine, so passwords, API keys, and tokens are stored encrypted at rest and never travel anywhere they do not need to. You can save a secret from the terminal with a hidden prompt, ask QUAN to remember one for you, or list what is stored, and QUAN only ever sees the names, never the values. When a task needs a credential, the value is unlocked just for that one command and handed straight to it. You choose how the vault is locked: a key kept on your machine, or a passphrase only you know.

Rides out a dropped connection

A network blip no longer kills a long job. If the connection drops or stalls mid task, QUAN keeps the work alive: it waits, reconnects, and retries up to ten times with a backoff, then resumes exactly where it was, showing you each reconnect as it happens. A spent retry budget surfaces a clear error instead of a silent stall, and a single keystroke stops it instantly if you would rather not wait. Every timeout and retry count is tunable.

Sees and uses your computer

When you ask, QUAN can look at your screen and operate your machine directly: take a screenshot and read it, then move the mouse, click, type, use keyboard shortcuts, scroll, and drag, watching the result after each step. It is off until you arm it with a single command, which also checks that the right macOS permissions are granted and tells you how to fix any that are missing. Built entirely on what the operating system already provides, with nothing to install.

The CLI shares QUAN's memory, agents, and skills, so what it learns is available everywhere QUAN works.

Multi-agent orchestration

For work that is too large for a single pass, QUAN coordinates a team of agents:

• Planner decomposes the goal into steps.
• Manager fans the steps out to specialized agents in parallel and synthesizes their results.
• Critic reviews the synthesized answer, looking for errors, unsupported claims, and missed requirements, then triggers a bounded correction.

Fan-out is capped by a budget (a maximum number of sub-agents and a concurrency limit) so parallelism never runs away. Delegation is one level deep and respects ownership: an agent can only delegate to agents the same member owns.

Memory

QUAN keeps a Claude-Code-style file memory: one typed fact per file, with an auto-generated index loaded each session.

• Scopes. A shared house memory available to every agent, plus a private memory per member and agent.
• Types. Facts are typed as user, feedback, project, or reference, so recall stays relevant.
• Yours to control. You can view, edit, and delete what QUAN remembers about your business, end to end.
• Learning loop. Outcomes feed a digest; repeated successes are promoted into reusable procedures, and contradictions are reconciled on a schedule.

Security & trust

QUAN is powerful by default and contained by design. The model is treated as untrusted; the guardrails are the product.

• Hard infrastructure boundary. The agent can never touch production databases or servers directly.
• Human-in-the-loop. Email, payments, and customer writes are staged for explicit approval.
• Sandboxed execution. Code and browser automation run isolated, behind an egress firewall, never near your data.
• Encrypted vault. Secrets are AES-256 encrypted; the model sees names, never values.
• Per-member scopes. Every teammate sees only their own agents and the tools an admin granted them.
• Full audit trail. Every action the agents take is recorded and reviewable.

Usage & limits

Team members have weekly usage limits with a rolling weekly reset.

• Per-tier weekly caps. Low, Medium, and Max each have their own weekly allowance, with Max getting a smaller separate cap (like Opus).
• Block until reset. When a tier is spent, that tier is paused until the weekly reset. Lower tiers keep working in the meantime.
• Visible meter. The model picker shows how much of each tier you have used and when it resets.
• Bring your own to remove limits. Self-hosted models or your own API keys are not metered.

Admins are never limited, and they set each member's weekly caps in the Team panel.

Team & administration

Administrators manage the workspace from the Team panel:

• Invites. Add members by email; each gets their own login and private workspace.
• Tool grants. Each member has a tool pool (a ceiling). Their agents can only ever use tools from that pool, enforced server-side.
• Weekly limits. Set Low, Medium, and Max weekly caps per member.
• Roles. Promote a member to admin (no usage limits) or demote back to member.
• Member-owned agents. Members create and edit only their own agents, and only with their granted tools.

Getting access

QUAN 2.0 is available by request. Tell us a little about you and we will reach out with access.

Request access →

Questions? Add them to your request above and we will follow up.

FAQ

Is QUAN 2.0 a chatbot?

No. A chatbot answers questions; QUAN carries the work. It remembers context, plans, uses real tools, verifies its output, and returns finished results.

Is QUAN 2.0 open source?

No. QUAN 2.0 is proprietary and closed-source. Access is by request.

Which models can it use?

Members pick a Low, Medium, or Max tier and QUAN auto-routes the right model for each task. You can also bring your own API keys or run self-hosted models.

Can it touch my database or servers?

No. There is a hard boundary: the model has no direct access to production databases or servers, and code runs sandboxed behind an egress firewall.

What happens when I hit my weekly limit?

That tier pauses until the weekly reset, while lower tiers keep working. Using your own models or API keys removes the limit.

Glossary

• Operator. An agent that does the work, as opposed to a chatbot that only talks about it.
• Tier. A member-facing routing level (Low, Medium, Max) that maps to one or more underlying models.
• MCP. Model Context Protocol, the open standard QUAN uses to connect external tools and data.
• Approval. A staged consequential action awaiting a human tap.
• Plan mode. A mode where QUAN presents a plan and waits for your go-ahead before acting.
• Auto-accept. A per-conversation mode where staged actions run automatically.
• House memory. Shared memory available to every agent; private memory is scoped per member and agent.