One room for the record, the work, and the memory

A Project Room is built on multi-version concurrency control (MVCC), the same technique databases use to let many readers and writers share data without locks. The filename is the stable identity; every write publishes a new immutable version with its own file ID. That gives agents the guarantees they need to run unattended:

• Snapshot reads, reproducible reasoning. A file ID always resolves to exactly one version. An agent that planned against plan.md v3 can cite v3, replay from v3, and prove what it saw, even after another round publishes v4.
• Atomic publishing. A same-name write becomes current only once it is ready. No agent ever reads a half-uploaded or half-compiled file; until the swap, every reader gets the previous version.
• Optimistic concurrency, not locks. A write that depends on a version someone else already replaced is refused with a conflict (HTTP 409). The agent re-reads the latest version, merges its changes, and retries. No coordinator, no lock to forget to release.
• Replay-safe writes. Writing the same output filename again just publishes another version, so a round that crashes and replays its log can redo its writes without side effects. Agents write freely because nothing is ever destroyed.
• Every agent write is undoable. List a file's history, inspect any retained version's compiled text, and restore it in one call. The replaced head stays in history too, so even a rollback can be rolled back.
• Deletes are soft. A removed file stays recoverable for the retention period (7 days by default) from the deleted-files list. An over-eager agent cleanup is a recoverable mistake, not an incident.

• Text arrives ready. Markdown, JSON, CSV, and other UTF-8 text are available the moment they're uploaded — ideal for notes, rules, and agent memory.
• Documents are compiled. PDFs, Word, Excel, PowerPoint, and other binary files are converted and indexed. Compile status is visible per file, and a failed compile can be retried without re-uploading.
• See what the AI sees. Open any file's compiled Markdown — whole, or a specific line range — to confirm exactly what an investigation will read.
• Dates and titles travel with the file. Attach a source date (year, month, day, or timestamp) and a title, so "which figure is current?" has an answer.
• Provenance built in. Files produced by a task can carry the ID of the response that generated them, so every derived document traces back to the investigation behind it.

Search: a cheap, precise read primitive

Agents call search with keywords or a natural-language question and get back ranked, deduplicated passages, each carrying its file ID, its line numbers in the compiled Markdown, and its source date. Then they read just the surrounding lines.

• Context-frugal by design. Return only the top passages an agent asks for, then read an exact line range of the compiled file. A round pulls the background one step needs, not the whole room.
• Filters an agent can reason with. Scope a search to specific file IDs, to files produced by a given task, or to a source-date window. That's how an agent asks "what did round 4 write?" or "what changed since the last run?"
• No silent mixing. With a date filter, undated files are excluded, so an agent's "since July" query never quietly pulls in material of unknown age.
• Citations that survive hand-offs. File ID plus line number is stable under MVCC, so a passage one round found can be cited, verified, or re-read by any later round.

Delegate: complete-record deep reasoning as a tool call

When the answer has to hold against the entire record, the agent doesn't try to read it. It delegates: one call hands the question, the room (or several rooms), and the agent's Finding and Composition Criteria to Continua's complete-record engine. The agent polls for the result and gets back verified findings, not a wall of text.

• Up to 1 billion tokens of working context, outside the agent. Every ready file in the rooms is read with 100% page coverage and measured recall. The agent's own context only ever holds the conclusions.
• Reasoning budgeted per step. Extraction runs on fast models, reconciliation gets more depth, and contested, high-materiality findings escalate to frontier models across 20+ models from multiple vendors. Use auto, or pin a model. How routing works →
• Gaps closed recursively. If a finding depends on something not yet established, the engine opens its own sub-investigation. What the record can't answer comes back as an explicit open question the agent can plan around. Gap recursion →
• Verified before the agent sees it. Each finding is checked for support, currency, and conflicts, labeled fact or inference, and scored. Guardrails cover 100% of findings in both Lite and Strict mode. Verification →
• Machine-readable results. Findings arrive as structured findings.json with sources and quotes, so an agent can test whether the evidence actually supports the claim before acting on it.
• Safe to retry, safe to fan out. Each delegated analysis carries an idempotency key: a replayed round gets the existing result back instead of paying twice, and a round can launch several sub-analyses in parallel.

Beyond a single room

• Multiple rooms, one investigation. Combine a deal room with your team's policy room and last year's precedent room; the investigation reconciles all of them as one record.
• Rooms plus everything else. Add one-off attachments, live web search, or MCP-connected systems to the same run, under the same citation discipline.
• Your rules, applied explicitly. Tell the investigation which definitions and approved rules to follow, which sources take precedence, and which prior decisions to preserve or reassess. Contradictory or expired rules are flagged, not silently resolved.
• Coverage you can check. Files still compiling or in a failed state are not counted as ready sources — and you can see which is which before you run.

Every task stays in the room

Investigations run against a room are listed with it. For each one you can see the original question, the Finding Criteria and Composition Criteria it was given, its results, its deliverables, and its findings.json evidence. Follow-ups chain to the task they continue, so the full conversation — including every correction and clarification — stays reconstructable.

Scheduled and delayed runs

• Recurring: run any investigation on a five-field cron schedule, in your time zone.
• One-time, later: run once after a delay — "check again in two hours" — and the schedule closes itself when done.
• Pause, resume, change, cancel at any time; execution history is kept, and each run links to the response it produced.
• Durable by design: scheduled runs read from room files, connected MCP systems, and web search — never from temporary uploads that could expire before the run.
• Billing-aware: a schedule that can't be billed pauses with a stated reason rather than failing silently.

Self-driving, long-running agents

With Agent mode on, a run can read the room, delegate sub-analyses, write results back, and arrange its own next run. The room becomes the agent's durable memory — so an interrupted run is recovered, not repeated.

How a room makes this safe:

• State lives in files, not in a chat. The goal, acceptance criteria, plan, memory, and budget are ordinary room files — readable and editable by your team.
• Write-ahead logging. Before any side effect, the round records what it intends to do; after, it records what actually happened. A crashed or timed-out round is taken over and replayed from its log, not started again.
• One step per round. Each round claims a single plan item with a checkable "done when." Items that don't finish are split; items that fail twice are marked blocked with a reason.
• Idempotent hand-offs. Each round starts the next with a deterministic key, so a retry never spawns a duplicate run, and a scheduled wake-up never collides with a relay already in flight.
• Waits are cheap. When the next step depends on a date or a condition, the agent switches from relaying to a schedule — and backs off automatically if repeated checks find nothing new.
• Budget is counted, not guessed. Spend is summed from the room's actual billed tasks each round; the agent stops before the ceiling, not after.

• Learns from the whole task chain. Not just answers, but the follow-ups: user additions, expert corrections, business decisions, and conclusions that were later reversed.
• Facts, methods, and decisions kept apart. Domain knowledge says what is true and when; work methods say how to handle a problem; decision cases record context, options, rationale, and outcome. Methods reference knowledge instead of copying it.
• Gaps are first-class. Missing evidence, source conflicts, and unresolved questions live in their own file until the record resolves them — then the answer moves into the knowledge itself.
• Every entry points back. Each item keeps its source room, file or task, location, and date, so a reusable rule is never an orphaned claim.

Incremental by design — not a fresh summary every week

Memory that is rewritten from scratch quietly forgets. Room-based knowledge is maintained the opposite way:

• File-level change detection. Each run compares the current list of source rooms, files, and tasks against the last successful processing record — new, changed, unchanged, and previously unfinished items are handled differently. A replaced file with a new file ID counts as changed.
• Fixed filenames, updated in place. The same topic always lives in the same file. Each update reads the full current version, integrates what's new, and saves the complete text under the same name — the room's version history keeps everything that came before.
• Correct, merge, or revise — don't append. New evidence can add to an entry, correct it, merge a duplicate, or narrow where it applies. Superseded conclusions leave the current text with a short note on why.
• Progress is recorded only after the save is verified. A source is marked processed only once its knowledge has been written and read back. Anything that failed to read, compile, or save stays open for the next run.
• Never learns from itself. The knowledge base's own files are excluded as sources, so outputs are not re-distilled into echoes.

One team, one source of truth

• Team rooms, shared by default. Create a room inside a team so knowledge belongs to the team, not to whoever happened to write it. Open it to the whole team or to selected members.
• Knowledge that crosses projects. A dedicated team knowledge room (see Memory that compounds) consolidates what was learned across every deal room, with sources attached, so the tenth review starts where the ninth left off.
• Edit once, apply everywhere. Change a policy file and every later investigation that reads the room follows it. Version history shows who changed what, and when; any change can be rolled back.
• Precedence you state, not guess. Tell an investigation which rules and decisions in the room take precedence. Expired, contradictory, or superseded entries are flagged instead of silently applied.
• The foundation of your Second Brain. Rooms are where the Enterprise Second Brain keeps its knowledge, ontology, policies, and recipes. They are readable, owned by you, and never used to train models.

Skills: your team's workflows, packaged and shared

A skill is a reusable workflow written down as a file: what to read, what to extract, how to judge, what to produce, and when to stop and ask. Store skills in a team room and they become shared infrastructure. Anyone can run them, and agents can load them as their operating instructions.

• Plain-language, versioned files. A skill is a room file with a question, Finding Criteria, Composition Criteria, and a guardrail level. Read it, edit it, roll it back like any other file.
• Run by people, on schedules, or by agents. Start a skill on demand, put it on a recurring schedule, or let a long-running agent load it as its protocol. In the long-running blueprint, the agent's own operating rules are written into the room as _protocol.md.
• Consistent results across the team. Two analysts running the same skill on the same room get the same method, the same evidence standard, and the same deliverable shape.
• Ready to start from. Begin with Continua's blueprints, enterprise knowledge maintenance and long-running goals, then adapt them to your own process.
• Open to your own tools. Through the Continua MCP server, your own agents can read team knowledge, apply skills, and write results back to the same rooms.

Access

• Personal or team rooms. Create a room for yourself, or inside an active team.
• Team-wide or selected members. Open a room to the whole team or limit it to named members.
• Read-only or ask-enabled sharing. Share a room view-only, or let readers ask their own follow-up questions against it.
• Permissions carry through. Schedules, agents, and sub-tasks act with the same room permissions as the person who set them up — never more.

Provenance

• Every file shows when it was added, its source date, and — when generated by a task — which response produced it.
• Every task shows its question, criteria, sources, results, and evidence, and links to the task it followed.
• Every version and deletion is retained for the retention window, so "what changed, and when?" is always answerable.

Human in the loop

• Connected systems, gated by you. MCP connections can be read-only or write-enabled, and writes can run automatically, always, or only after approval.
• Approval is a follow-up, not a bypass. When a run proposes a consequential action, it stops with the proposal. Your reply continues the same task chain and carries the approval forward.
• Dangerous and irreversible means stop. Long-running agents pause before anything they can't undo themselves and that affects people or systems outside the room — sending a message, publishing, paying, deleting data with no history, changing permissions. Writing versioned room files, creating deletable drafts, and scheduling the next round don't need a human.
• Plain-numbered replies. When an agent waits for you, it lists numbered items with options and a recommendation. Reply "1 approve; 2 choose B; 3 raise budget to 80" and it resumes from exactly where it stopped.

Continua is designed to support professional judgment, not replace it. Review important findings against their supporting evidence before relying on them. Read Trust & Security →