What a Collaborative Writing Tool actually does
Enables multiple users to co-edit documents in real time while AI rewrites, expands, and enforces house style — under your brand, not Notion's.
A white-label AI collaborative writing tool combines two distinct engineering layers: a real-time CRDT-based editor (Yjs + Tiptap + Hocuspocus) that synchronizes simultaneous edits from multiple users without conflicts, and an AI co-editing layer (Claude Sonnet 4.6 with prompt-cached style guides) that responds to selection-aware commands ('Rewrite this paragraph in active voice', 'Expand this bullet into a section', 'Match our house style'). The two layers are deliberately separate — the CRDT handles document state, the AI handles suggestion generation, and neither blocks the other. AI suggestions appear as tracked changes that editors can accept or reject.
The 2026 market offers no honest white-label SaaS in this category. Notion AI ($10/user/mo add-on) and Coda AI (~$10/user/mo) are the closest reference products — both are vendor-locked platforms with their own branding on every surface. Sudowrite is fiction-focused with no white-label tier. Lex and Type are early-stage startups with no reseller programs. The decisive economic argument: at 40 seats, Notion AI's add-on costs $4,800/year, while the actual Claude Sonnet 4.6 API cost for heavy use (5 rewrites/user/day at $0.012/rewrite) is ~$144/year — a 33× markup. For a content agency or publisher that does deliverables inside a writing tool every day, owning the writing surface means owning the workflow.
AI capabilities involved
Selection-aware text rewrite, expand, and shorten
House-style enforcement with prompt-cached style guide
AI track-changes suggestions
Semantic search across workspace documents
Real-time CRDT synchronization (not AI but mandatory)
Who uses this
- Content agencies that produce client deliverables (blog posts, whitepapers, marketing copy) and want their brand on the editing surface their clients see
- Publishing-technology founders building editorial workflow software for media companies who need a branded writing surface with AI editorial assist
- B2B SaaS founders adding document creation to an existing product (proposal tools, content marketing platforms, knowledge management)
- Enterprise content teams at agencies managing 40+ writers who need style-guide enforcement built into the editor rather than applied as a post-process
- Legal-tech and consulting-firm founders who need a branded document surface with AI drafting that runs on Anthropic's infrastructure (not OpenAI's) for security positioning
SaaS alternatives on the market
Real products you can sign up for today — with current 2026 pricing, honest pros and cons.
Notion AI
Internal teams that already use Notion as their primary knowledge base and want AI-assist without switching tools
20 AI responses free (trial)
$10/user/mo add-on (requires Notion Plus at $10/user/mo base)
Pros
- +Deeply integrated AI that understands the structure of the Notion document (databases, linked pages, inline properties).
- +AI can query across the entire workspace — 'Summarize all Q1 meeting notes tagged Project Alpha.'
- +Reliable multi-user real-time editing on Notion's battle-tested sync infrastructure.
- +AI write and rewrite actions are fast (~1–2 second latency) and reliable at production scale.
Cons
- −No white-label tier at any price — Notion branding on all surfaces including client-shared pages.
- −Total cost for a team: $10 base + $10 AI = $20/user/mo, $240/user/year — expensive for large content teams.
- −AI training data: Notion's terms allow AI training on content by default on lower plans — check your plan's DPA.
- −Cannot customize the AI model, prompts, or style-guide enforcement — locked into Notion's proprietary AI behavior.
Coda AI
Teams that use documents and structured databases together and need AI to operate across both — not for pure writing workflows
Limited free doc (3 makers, 1,000 rows)
$10/month per maker for AI add-on (Pro base $12/maker/mo)
Pros
- +AI is deeply integrated with Coda's formula language — AI can write and execute formulas, not just text.
- +Stronger than Notion for structured-data documents (tables, automations) with AI-generated table content.
- +Coda Packs (integrations) connect AI to external data sources including Salesforce, Jira, and Google Analytics.
- +Document templates with AI assistance built in are a strong onboarding differentiator.
Cons
- −No white-label tier — Coda branding on all client-facing documents and portals.
- −'Maker' pricing model is complex — editors are free but the creator who builds the doc pays, creating billing confusion in agencies.
- −AI assist is more powerful on structured docs than on freeform writing — less suitable for agencies doing pure content writing.
- −Performance can degrade on very large documents (1,000+ rows or 100+ pages).
Liveblocks
Developers building a collaborative writing product who want managed sync infrastructure instead of self-hosting Hocuspocus
Free up to 100 MAU
$99/mo (Starter, 1,000 MAU)
Pros
- +Not a writing product but the best real-time collaboration infrastructure for building one — Liveblocks handles the CRDT sync so you focus on the editor and AI layer.
- +Tiptap has an official Liveblocks integration that makes collaborative editing setup significantly faster than building on raw Yjs.
- +Presence (cursors, who's viewing) is built-in and production-tested.
- +Usage-based pricing scales naturally with product growth.
Cons
- −Infrastructure only — you still build the entire editor, AI integration, and product layer.
- −MAU-based pricing can surprise at scale: 5,000 MAU = $349/mo.
- −No document storage — you bring your own database for document content.
- −Vendor dependency: your real-time sync depends on Liveblocks' uptime — check their SLA.
The AI stack
The AI stack for a collaborative writing tool is text-generation-dominant with a prompt-caching layer that dramatically reduces cost for teams with consistent style guides. The CRDT sync stack (Yjs + Hocuspocus) is not AI but is architecturally mandatory.
AI co-editing — rewrite, expand, style-check
Generates AI-assisted text edits in response to user commands (rewrite selection, expand bullet, enforce style guide)
Claude Sonnet 4.6 with prompt caching
$3/$15 per M tokens (cold); $0.30/M cache hit on inputPaid-tier clients where quality of style enforcement is the core selling point; agencies with well-defined house style guides
GPT-5.4 mini
$0.75/$4.50 per M tokensFree tier or budget-conscious plans where volume is high and style-guide precision is secondary
Mistral Large 3 (2512)
$0.50/$1.50 per M tokensEU-based content agencies where data residency is a requirement and EU-language content is the primary use case
Our pick: Claude Sonnet 4.6 with prompt caching for the paid tier. Load the workspace's style guide as a 5K-token cached system prompt — at 90% cache-hit rate on a busy team, the effective input cost drops to $0.30/M, making the per-rewrite cost ~$0.003 (selection = 500 tokens in + 300 out). Use GPT-5.4 mini for the free tier.
Real-time CRDT sync
Synchronizes simultaneous edits from multiple users without conflicts — mandatory for any collaborative editor
Yjs + Hocuspocus (hosted, $30/mo)
$30/mo (Hocuspocus Cloud Starter, 100 connections)MVP and early-stage products where speed to market matters more than infrastructure ownership
Yjs + Hocuspocus (self-hosted on Fly.io)
~$20–40/mo on Fly.io (1–2 persistent machines)Production builds at scale where 100+ simultaneous connections are expected and infrastructure cost matters
Our pick: Start with Hocuspocus Cloud at $30/mo for the MVP. Migrate to self-hosted Fly.io when you exceed 80 simultaneous connections or need per-document access control at the WebSocket layer.
Editor framework
Browser-based rich-text editor with extension API for embedding AI actions as first-class toolbar commands
Tiptap (open-source, MIT)
$0 (MIT license)All builds — the open-source core handles 90% of collaborative writing needs
Our pick: Tiptap open-source core + Yjs extension for collaboration. Build AI actions (rewrite, expand, style-check) as custom Tiptap extensions that call Supabase Edge Functions — this avoids the commercial Tiptap AI license cost while keeping full control.
Semantic search across workspace
Enables users to find related documents and relevant past content while writing
text-embedding-3-small (OpenAI)
$0.02/M tokensDefault embedding layer for all document search
Our pick: text-embedding-3-small for all semantic search. Chunk documents at 500-token intervals with 50-token overlap. Store vectors in pgvector on Supabase — the same database powering auth and document storage.
Reference architecture
The architecture separates into two persistent layers and one stateless AI layer: (1) Supabase Postgres stores document content as Yjs document state (serialized) plus version snapshots; (2) Hocuspocus WebSocket server handles live sync between browser clients; (3) Supabase Edge Functions handle all AI calls on user command. The hardest engineering challenge is making the AI suggestion appear as a ProseMirror transaction that integrates naturally with Yjs's CRDT — a bad implementation causes conflicts when two users are editing simultaneously.
User opens a document
React frontend + Tiptap editorThe browser loads the document's Yjs state from Supabase Storage (serialized Y.Doc binary), initializes a Tiptap editor with it, and connects to the Hocuspocus WebSocket server using a signed JWT scoped to the document ID and workspace ID.
Real-time co-editing sync
Yjs + Hocuspocus WebSocket serverEvery keystroke generates a Yjs update that is sent to the Hocuspocus server, which broadcasts it to all other connected clients for the same document. Cursors and selection ranges are synchronized via Hocuspocus awareness protocol. No AI is involved in this layer.
User selects text and triggers AI action
Tiptap AI extension → Supabase Edge Function (ai-action)User selects a paragraph and right-clicks → 'Rewrite in active voice'. The Tiptap extension reads the selected text and the document title, posts them to the Supabase Edge Function `ai-action` with the action type ('rewrite'), the user's workspace style guide (fetched from `workspace_style_guides` cache), and the surrounding context (200 tokens before + after the selection).
Claude Sonnet 4.6 generates the suggestion
Supabase Edge Function → Anthropic APIThe Edge Function calls Claude Sonnet 4.6 with a prompt-cached system prompt containing the workspace style guide. The style guide is cached as a separate cache block using Anthropic's cache-control header. Claude returns the rewritten text as a JSON object with the replacement content and a brief explanation of changes.
Suggestion is inserted as a tracked change
Tiptap extension → Yjs CRDTThe Tiptap extension inserts the AI suggestion as a ProseMirror tracked-change mark (using Tiptap's track-changes extension or a custom mark). The original text is preserved as a deletion mark; the suggested text is shown as an insertion. Both changes are committed to the Yjs document as a single atomic transaction, visible to all collaborators.
Collaborators see the AI suggestion
Hocuspocus → all connected clientsThe Yjs transaction is broadcast via Hocuspocus to all other connected browsers. Other collaborators see the tracked change appear in real time (green insertion, red deletion). Any collaborator with edit rights can accept or reject the AI suggestion via the track-changes UI.
Document auto-save and version snapshot
Tiptap onChange handler → Supabase Edge Function (save-document)Every 30 seconds and on user-triggered save, the Tiptap editor serializes the current Yjs document state to binary and posts it to the `save-document` Edge Function. The function updates `documents.yjs_state` in Postgres and, if the content has changed by more than 500 characters since the last snapshot, inserts a row in `document_versions` with the snapshot and a Claude Haiku 4.5-generated 1-sentence summary of what changed.
Estimated cost per request
~$0.005 per 2K-word AI rewrite on GPT-5.4 mini; ~$0.012 on Claude Sonnet 4.6 cold; ~$0.003 on Claude Sonnet 4.6 with style-guide cache hit (90% of calls at active workspaces)
Cost calculator
Drag the sliders to model your actual usage. The numbers update in real time so you can stress-test economics before writing a single line of code.
Assumes a white-label writing tool with per-seat monthly pricing. Defaults model 50 writer seats at $20/seat/mo = $1,000 MRR. AI cost is dominated by rewrites-per-user-per-day, not CRDT infrastructure.
Estimated monthly cost
$101
≈ $1,212 per year
Calculator notes
- At 50 seats × 10 rewrites/day × 22 working days = 11,000 rewrites/mo at $0.003 each = $33/mo in AI. Against $1,000 MRR, the AI gross margin is 96.7%.
- The Hocuspocus hosted $30/mo handles 100 concurrent connections — at 50 seats with typical 50% concurrent usage at peak, this is sufficient. Upgrade to $100/mo at 100+ concurrent connections.
- Style-guide prompt cache TTL is 5 minutes on Anthropic — for active writing sessions the cache hit rate is ~90%, reducing the effective per-rewrite cost from $0.012 to $0.003.
- Document storage in Supabase grows with version history — plan for ~1KB per version snapshot per document; 1,000 documents × 100 versions = 100MB, well within Supabase Pro storage.
Build it yourself with vibe-coding tools
By the end of the weekend you'll have a working collaborative editor where two people can type simultaneously in the same document and trigger AI rewrites — Lovable handles the auth, dashboard, and billing shell while a Tiptap + Yjs starter handles the actual editor.
Time to MVP
12–16 hours Lovable shell + 8–12 hours Tiptap editor integration (2 weekends)
Total cost to MVP
$25 Lovable Pro + $30 Hocuspocus + ~$40 Anthropic API credits + $0 Tiptap open-source
You'll need
Starter prompt
Build a white-label AI collaborative writing tool shell using Vite + React + Supabase + Tailwind CSS. This app is the auth/billing/dashboard layer — the actual editor is a Tiptap component embedded via an iframe or a shared Supabase session. 1. AUTH: Supabase email/password signup and login. Each user belongs to a `workspace_id`. After login, redirect to Dashboard. 2. DASHBOARD: A list of documents from the `documents` table (workspace_id, title, updated_at, created_by, collaborators array). Show each document as a card with title, last-edited date, and collaborator avatars. 'New Document' button creates a row in `documents` and redirects to /editor/{id}. 3. WORKSPACE SETTINGS: A settings page where workspace admins can: (a) paste a house style guide (textarea, stored in `workspace_style_guides.style_text`), (b) manage team members (invite by email via Supabase invite, see current members list), (c) set document retention policy (number of versions to keep, stored in workspace settings). 4. BILLING: Stripe integration for team subscription — Starter ($15/seat/mo, up to 10 seats), Pro ($20/seat/mo, unlimited). Show current seat count, plan, and a 'Manage Billing' button linking to Stripe Customer Portal. A Stripe webhook Edge Function updates workspace plan on checkout events. 5. EDITOR ROUTE: /editor/{documentId} — render a full-screen iframe loading the Tiptap editor app at a separate URL (e.g., editor.yourdomain.com). Pass the document ID and a Supabase JWT as URL params so the editor can authenticate and load the correct document. All tables use RLS with workspace_id scoping. Store API keys in Supabase Secrets.
Paste this into Lovable
Follow-up prompts (run in order)
- 1
Set up the Tiptap collaborative editor as a separate Next.js app. Install @tiptap/react, @tiptap/starter-kit, @tiptap/extension-collaboration, @tiptap/extension-collaboration-cursor, and y-hocuspocus. Initialize a Tiptap editor with the Collaboration extension connected to Hocuspocus Cloud using the document ID from the URL param. Add collaborator cursors with the user's name and a color. The document content should auto-save to Supabase every 30 seconds by serializing the Yjs doc with Y.encodeStateAsUpdate and storing the binary in Supabase Storage at documents/{id}/state.bin.
- 2
Add the AI rewrite action to the Tiptap editor. Create a custom Tiptap extension that adds a floating action menu when text is selected. The menu should show: 'Rewrite', 'Expand', 'Shorten', 'Fix Style'. On click, read the selected text (editor.state.selection), post it to a Supabase Edge Function 'ai-action' along with the action type and the workspace style guide fetched from the API. The Edge Function calls Claude Sonnet 4.6 with the style guide as a cached system prompt. Return the AI suggestion as a tracked change (mark the original as deleted, insert the new text as proposed) using Tiptap's track-changes marks.
- 3
Add version history to the Tiptap editor. Every time the document is saved, compare the character count to the last saved version. If the difference exceeds 200 characters, insert a row in `document_versions` with: document_id, created_at, version_number (auto-increment per document), character_count, and a summary (call Claude Haiku 4.5 with the full document text asking for a 1-sentence 'what changed' summary). On the Dashboard document card, add a 'Version History' button that opens a side panel listing all versions with their summaries and a 'Restore' button.
- 4
Add semantic document search. When a document is saved, call the Supabase Edge Function 'embed-document' which chunks the document text at 500-character intervals, calls text-embedding-3-small to get a vector for each chunk, and stores them in `document_chunks` (document_id, workspace_id, chunk_index, text, embedding vector). Add a search bar on the Dashboard that calls Edge Function 'search-documents', embeds the query, runs a pgvector cosine_distance query filtered by workspace_id, and returns matching document cards ranked by relevance.
- 5
Add the house-style enforcement prompt caching. In the ai-action Edge Function, fetch the workspace style guide from `workspace_style_guides` and include it as a separate cache-control block in the Anthropic API call. Use `'cache_control': {'type': 'ephemeral'}` on the style guide content block. Log cache hit rates in a `ai_cache_stats` Supabase table (request_id, workspace_id, cache_hit bool, tokens_in, tokens_out, cost_usd). Add a 'Style Cache Stats' widget on the Workspace Settings page showing cache hit rate and estimated monthly savings.
Expected output
A working branded collaborative writing environment where two users type in the same document simultaneously, trigger AI rewrites that appear as tracked changes, and use the dashboard to manage multiple documents with version history — ready to demo to a first paying content agency client.
Known gotchas
- !Lovable cannot build the Tiptap editor directly — it generates a placeholder iframe or a simple textarea. The collaborative editor must be a separate Next.js sub-app; plan for this architecture split from day one or you'll spend two days undoing Lovable's attempted editor implementation.
- !Hocuspocus Cloud's free tier is limited to 5 concurrent connections — create a paid $30/mo account before testing with more than two simultaneous users, or your demo will fail mid-call.
- !Anthropic's prompt cache TTL is 5 minutes of inactivity — if a writer pauses for more than 5 minutes, the next AI call will incur the full cold-cache cost. Cache the style guide again on every document load (not just on first call) to minimize cold-cache surprises in your cost estimates.
- !Tiptap's track-changes extension (used for showing AI suggestions) is a Tiptap Pro commercial feature at $149+/mo — for the MVP, implement a simpler 'accept or discard' pattern using a custom mark instead of a full track-changes implementation.
- !The Yjs document binary state grows indefinitely as edits accumulate — implement a Yjs snapshot and garbage collection step that trims the update history weekly, otherwise large documents will have 10–50MB of accumulated CRDT state after months of active editing.
- !Per-workspace prompt caching only works if all users in a workspace share the same system prompt — do not let individual users customize the style guide prompt in a way that creates cache misses; workspace-level style guides must be identical strings.
Compliance & risk reality check
A collaborative writing tool handles customer documents — potentially containing confidential business content, personal data, or HIPAA-regulated health information depending on the industry. Compliance requirements scale with who the clients are.
Per-workspace document isolation (critical architecture requirement)
A multi-tenant writing tool where content agencies use the same platform serves competing clients. Workspace A must never be able to read or search Workspace B's documents through any path — direct query, semantic search, or leaked vector embeddings. A misconfigured RLS policy here is both a GDPR breach and a catastrophic business-confidentiality failure.
Mitigation: Every Supabase query including pgvector cosine_distance searches must include `WHERE workspace_id = $user_workspace_id`. The Hocuspocus WebSocket connection must be gated by a document-specific JWT that verifies the user's workspace_id matches the document's workspace_id. Run automated cross-workspace penetration tests before launch.
GDPR Article 17 right-to-erasure on stored documents
Under GDPR, users have the right to request deletion of their personal data. In a writing tool, 'documents' are user-generated content that may include personal data. When a user requests deletion, all documents, document versions, and document chunk embeddings (pgvector rows) must be deleted — not just archived.
Mitigation: Implement a 'Delete My Data' flow in workspace settings that hard-deletes `documents`, `document_versions`, `document_chunks`, and `workspace_style_guides` rows for the requesting user, plus the binary Yjs state files in Supabase Storage. Test that the deletion cascade works correctly — orphaned vector embeddings are the most commonly missed element.
AI content disclosure (EU AI Act Art. 50, effective August 2, 2026)
The EU AI Act Article 50 requires that AI-generated text be disclosed to readers where the AI-generated content is intended to inform or persuade. In a writing tool, this applies to final published content that originated from AI suggestions — your tool should provide an export flag or metadata noting that AI assistance was used.
Mitigation: Add a document metadata field `ai_assisted: boolean` that is automatically set to true when any AI suggestion is accepted in the document. Include this flag in document exports and API responses. For clients publishing to external audiences, surface a 'This document was produced with AI writing assistance' disclosure template they can add to published content.
HIPAA if used by healthcare organizations
Healthcare organizations using a collaborative writing tool for clinical documentation, care plans, or patient communications create PHI in the document store. HIPAA requires a BAA with every technology vendor in the chain — Anthropic (via AWS Bedrock), Supabase (via their BAA), and Cloudflare.
Mitigation: Do not market your writing tool to healthcare organizations without first executing BAAs with Anthropic (use Claude via AWS Bedrock, which has a cloud-level BAA), Supabase (BAA available on Team plan), and Cloudflare (BAA available on Business plan). Route Claude API calls through Bedrock for HIPAA-eligible documents.
Build vs buy: the real math
7–11 weeks
Custom build time
$18,000–$25,000
One-time investment
4–6 months
Breakeven vs buying
At 40 seats paying $20/seat/mo = $800 MRR, a $20K custom build pays back in 25 months from subscription revenue alone — longer than ideal. But the real comparison is against Notion Plus ($10/user/mo) + Notion AI ($10/user/mo) = $800/mo for the same 40 users, under Notion's brand. Switching to your own product means your $800/mo cost goes away and becomes $800/mo revenue — the effective payback is under 2 months from the savings alone. At 100 seats, the payback from savings is 2–3 months and you have a product asset worth significantly more than the build cost.
Skip the DIY — RapidDev builds the production version
A Lovable MVP gets you a demo. Production needs auth that doesn't leak data, AI calls that don't bankrupt you, observability when models drift, and code you can audit. That's what we ship.
Discovery call (free)
30 minWe map your exact Collaborative Writing Tool use case: who uses it, target volume, AI model choice, integrations, compliance scope. You get a detailed scope document and fixed-price quote within 48 hours.
AI-accelerated build
7–11 weeksOur engineers use Claude Code, Lovable, and custom tooling to ship 3–5x faster than agencies. You see weekly progress in a staging environment — not a black box.
Launch + handoff
1 weekWe deploy to your infrastructure, transfer the GitHub repo, set up CI/CD and monitoring, and train your team. You own 100% of the source code, prompts, and model configurations.
What you get
Timeline
7–11 weeks
Investment
$18,000–$25,000
vs SaaS
ROI in 4–6 months
30-min call. Fixed-price quote within 48 hours. No commitment.
Frequently asked questions
How much does it cost to build a white-label collaborative writing tool?
A RapidDev custom build runs $18,000–$25,000 for a 7–11 week project covering the Tiptap + Yjs CRDT editor, Hocuspocus sync infrastructure, Claude Sonnet 4.6 AI actions with prompt caching, version history, semantic search, and Stripe billing. A DIY approach using Lovable for the auth/dashboard shell and Tiptap open-source for the editor costs $25 Lovable Pro + $30 Hocuspocus + ~$40 Anthropic credits for the first month.
How long does it take to ship a collaborative writing product?
The Lovable auth/billing shell takes one weekend. The Tiptap + Yjs collaborative editor integration takes another 1–2 weeks to get right, especially the AI action extension and the Hocuspocus connection. A RapidDev full build takes 7–11 weeks. The CRDT layer is the slowest part — debugging real-time sync conflicts between simultaneous users requires more iteration than standard web development.
What is the real cost of AI rewrites when running Claude Sonnet 4.6?
Without prompt caching: ~$0.012 per rewrite (500 input tokens + 300 output tokens on Claude Sonnet 4.6 at $3/$15 per M). With Anthropic's prompt cache on the 5K-token style guide: ~$0.003 per rewrite (90% cache hit rate at typical active-workspace usage). At 50 users doing 10 rewrites/day over 22 working days = 11,000 rewrites/mo × $0.003 = $33/month total AI cost against $1,000 MRR.
Why can't Lovable build the collaborative editor itself?
Real-time collaborative editing requires a CRDT (Conflict-free Replicated Data Type) library like Yjs and a persistent WebSocket connection server like Hocuspocus. Lovable generates standard React components with Supabase CRUD — it cannot configure persistent WebSocket infrastructure or build ProseMirror editor extensions. Lovable is excellent for the product shell (auth, dashboard, billing, settings) but the editor itself must be built in a separate Next.js app using Tiptap's collaboration extensions.
Can RapidDev build a white-label collaborative writing tool for my agency?
Yes. RapidDev has shipped 600+ production applications including real-time collaborative tools. The standard collaborative writing build at $18K–$25K covers the Tiptap + Yjs editor, Hocuspocus sync server on Fly.io, Claude Sonnet 4.6 AI actions with prompt caching, workspace style-guide enforcement, version history with AI summaries, and Stripe team billing. Book a free 30-minute consultation at rapidevelopers.com.
How does prompt caching work for house-style enforcement?
Each workspace uploads a style guide (tone of voice, terminology, forbidden phrases, grammar rules) that is stored in Supabase. When a user triggers an AI rewrite, the Edge Function sends the style guide as a separate prompt block with Anthropic's `cache_control: ephemeral` flag. Anthropic caches this block for up to 5 minutes — subsequent rewrites from any user in the same workspace reuse the cached block, reducing the input cost from $3/M to $0.30/M (90% discount). The cache refreshes every 5 minutes of inactivity.
What happens when two users edit the same paragraph simultaneously?
Yjs's CRDT algorithm handles simultaneous edits mathematically without conflicts. If User A types 'Hello' and User B simultaneously types 'World' at the same cursor position, Yjs deterministically merges both changes — you get 'HelloWorld' (or 'WorldHello', depending on the merge algorithm's tie-breaking) without either user's content being lost. The AI action is a Yjs transaction — if an AI suggestion and a human edit happen simultaneously, both are applied in the order they reach the Hocuspocus server, and both appear as tracked changes that editors can review.
Want the production version?
- Delivered in 7–11 weeks
- You own 100% of the code
- AI cost monitoring built in
30-min call. No commitment.
