Stable Baseline

Stable Baseline is an end-to-end, agent-managed workspace for documentation, diagramming, whiteboarding, planning, and a shared knowledge graph (your team's brain). From ChatGPT you can author and edit living documents in Markdown with 40+ types of embedded diagrams (flowcharts, BPMN, sequence, mind maps, Gantt, and more); generate pixel-perfect diagrams and whiteboards and get them back as PNG, JPEG, or SVG; design a whole whiteboard from a single prompt; generate infographics on the fly from plain language; plan work with phases, tasks, dependencies, and timelines; log risks and improvements; and build a self-learning Knowledge Graph that shares context across all of it. It works at any level, from an individual organising personal notes to an enterprise managing organisation-wide context, through 180+ tools across 19 categories spanning documents, diagrams, infographics, whiteboards, plans, tasks, improvements, knowledge graph, members, and teams.

View in the ChatGPT registry

Integration type: Plugin
Verification status: Not applicable
Platform: ChatGPT
Category: Productivity
Primary Subcategory: Collaborative Docs & Workspaces
Secondary Subcategories: None listed
Brand: Stable Baseline
Access: Account required
First tracked: 2026-04-27
Tool count: 168
Geography: US

ChatGPT Plugin Discoverability Score

ChatGPT organic discovery is not live yet

Stable Baseline is tracked in the ChatGPT Plugin registry. Public organic-discovery measurement is not live for ChatGPT yet, so there is no score to publish today.

Get notified when your score goes live

Enter your work email and we’ll notify you when ChatGPT Plugin organic discovery scoring launches.

No spam. Unsubscribe any time.

Talk to our team

Primary Subcategory

Competing in ChatGPT Collaborative Docs & Workspaces

View Category

Listed in alphabetical order

Primary Subcategory

CaipiOrganic discovery is pendingGet the score at launch

Catalyst by ZohoOrganic discovery is pendingGet the score at launch

CodaOrganic discovery is pendingGet the score at launch

Document360Organic discovery is pendingGet the score at launch

FiberyOrganic discovery is pendingGet the score at launch

Stable BaselineOrganic discovery is pendingGet the score at launch

Score explained

How the Discoverability Score works

Organic discovery scoring for Stable Baseline on ChatGPT is not live yet. The score will use measured agent conversations when it launches.

InvisibleBuriedEmergingCompetitiveWinning

Organic discovery scoring is pending. Your Plugin score will appear on this scale when measurement goes live.

FoundDiagnostic

Whether Claude found your Plugin in connector search. It must be Found before it can reach the picker, but the score counts picker appearances—not search results.

PickedMain score

How often your Plugin appeared in the picker, or Claude invoked it directly, across contested conversations. This percentage is the Discoverability Score; the headline number is rounded.

PositionedDiagnostic

What position your Plugin appeared in when it was shown in the picker. This shows prominence, but it does not affect the score.

Read the full scoring methodology Recommended guideHow to get your Claude Connector organically discoveredFollow the practical steps agents use to find, shortlist, and choose your Connector.

Tools

168 tools agents can invoke

Per-item: apply a successor's `suggested_start_date`/`suggested_end_date` to its real dates and clear `needs_dependency_review`. For a whole-plan cascade use `applyTaskDependencyCascade`.
Add a comment or activity entry to an improvement.
Add evidence to an improvement. Types: document_section, diagram_node, incident_note, feedback, free_text.
Add a comment or activity entry to a plan.
Add a user to a team as a regular member. Idempotent — returns already_member=true if already on the team. User must be an active organisation member.
Author shapes onto a whiteboard from high-level specs (you do NOT need the full Excalidraw element schema). Appends to the canvas. PLACEMENT ON AN EXISTING BOARD (critical): NEVER guess x/y onto a board that already has content — guessed coordinates land ON TOP of existing shapes and create an unreadable pile. Either (a) OMIT x/y entirely and the server auto-places the new elements together in clear space BELOW the current content, or (b) FIRST call getWhiteboard({ includeElements:true }) to see where existing shapes already are and choose a genuinely EMPTY region. Pass explicit x/y only for a deliberate layout in space you have confirmed is empty. PREFER THE RICHEST FORM THAT FITS, not plain rectangles: for a sticky/post-it note use { type:'sticky', text, backgroundColor } (a first-class note with an auto-fitting bound label — there is NO sticky-note stencil; OMIT x/y and it is auto-placed in clear space below existing content, so it doesn't land on top of the current drawing); for kanban/scrum/story boards, flowcharts, UML/ER, BPMN, org charts, wireframes/mockups, charts or people use a LIBRARY STENCIL in ONE call — { type:'stencil', stencil:'<name e.g. decision>', x, y } fuzzy-matches by name with no prior listWhiteboardStencils call (pass width/height to SCALE the whole stencil and text to fill its single label); for cloud/software-architecture use ICONS — { type:'image', iconPath:'dev/docker.svg', x, y } (paths from listArchitectureIcons); reserve raw rectangles/ellipses for when no standard form fits. Expressive enough to reproduce real Excalidraw templates (sticky-note brainstorm grids, sketchy mind maps, flowcharts). Each spec: { type: 'rectangle'|'ellipse'|'diamond'|'sticky'|'text'|'arrow'|'line'|'freedraw'|'frame'|'image'|'stencil', id?, x, y, width, height, text? (STRONGLY PREFER setting a shape's label via its own `text` — it becomes a centered, auto-WRAPPED bound label fitted to the shape; do NOT drop a separate type:'text' element on top of a shape as its label. Standalone type:'text' is for free-floating titles/notes and now also wraps to its width; Yes/No label on an arrow — emojis are fine, e.g. 'Risks ⚠️'), fontSize?, fontFamily? (1=hand-drawn default, 2=normal, 3=code), textAlign?, backgroundColor? (name 'blue'/'green'/'yellow'/'pink'/'violet'/'orange'/'teal'/… or hex), strokeColor?, fillStyle? ('solid'|'hachure'|'cross-hatch'), strokeStyle? ('solid'|'dashed'|'dotted' — use 'dashed' for grid/category borders), strokeWidth? (1 thin/2 bold/4 extra), roughness? (0 clean, 1 default, 2 very sketchy/hand-drawn — use 2 for organic mind maps), roundness? (number type or null for sharp), opacity?, name? (frame title), frameId? (put a shape inside a frame), start?:{id}, end?:{id} (connect arrows/lines to shapes by id — connectors AUTO-CLIP to the shape edges, never overrun to the centre, AUTO-ROUTE around any shapes in between so a decision's No/loop-back branch never cuts straight through the boxes between source and target, and bound text auto-wraps + centres), routing? ('straight' default | 'elbow' for clean right-angle flowchart/org-chart connectors | 'curved'), startArrowhead?/endArrowhead? (arrowheads are SOLID filled triangles by default — just OMIT them. Pass null for a plain mind-map spoke with no head. Do NOT pass 'arrow': that is Excalidraw's open 'V' and is auto-upgraded to a solid triangle anyway), points? ([[0,0],[dx,dy]] relative, only for manual geometry — almost never needed; binding by id is better), props? (escape hatch: any other Excalidraw field) }. ARCHITECTURE ICONS: to place a software-architecture icon (AWS/Azure/GCP/Docker/Kubernetes/databases/etc.), first call listArchitectureIcons to find one, then add a spec { type:'image', iconPath:'<relative_url e.g. dev/docker.svg>', x, y, width:96, height:96, text?:'<caption shown below>' } — the icon is stored as a URL reference (never base64). Use imageUrl instead of iconPath for any other public image. Combine icons with labelled boxes + elbow arrows for clean architecture diagrams. LIBRARY STENCILS: for hand-drawn, on-brand elements (scrum/kanban columns, flowchart symbols, UML/ER, BPMN, org-chart nodes, wireframe widgets, stick figures), FIRST call listWhiteboardStencils to find one, then add { type:'stencil', stencilKey:'<key from listWhiteboardStencils>', x, y } (or { type:'stencil', stencil:'<name e.g. decision>', pack?:'<pack>', x, y } to fuzzy-match by name). A stencil is a mini-whiteboard (a collection of elements) of kind 'symbol' or 'template' (listWhiteboardStencils returns the kind + its embedded `labels`). For a SYMBOL (one atomic labelled node — flowchart box, BPMN task, org node), pass id + text + width/height: the label auto-fits its single slot and arrows bind to it via start/end {id}. For a TEMPLATE (a multi-component layout — Alerts, Forms, Tables, Charts), place it WHOLE (no single text); the result returns its `children` (id + text + colour + position) so you retext, recolour, or DELETE specific parts by id via updateWhiteboardScene (cluster children by y to act on a whole row/variant). STRONGLY prefer stencils over plain rectangles for wireframes/mockups, kanban/scrum boards, UML/BPMN, org charts; for dense flowcharts, plain shapes with bound text + elbow arrows are equally reliable. (For a plain sticky/post-it note use type:'sticky', NOT a stencil — there is no sticky-note stencil.) FRAMES: a frame is a NON-DESTRUCTIVE, ANY-SIZE container. To enclose shapes that ALREADY exist, add ONE type:'frame' sized to cover them (Excalidraw auto-captures elements inside a frame's bounds) or set those shapes' frameId — never recreate or delete-and-redraw content just to frame it. If a frame doesn't fully cover its content, just RESIZE the frame (patch its width/height). Deleting a frame (deleteIds:[frameId]) leaves all its contents intact on the canvas — it only removes the frame border + title. PRESENTATION/SLIDES: when the user wants a presentation or slide deck, create type:'frame' slides sized width:1280,height:720 (16:9), laid out LEFT-TO-RIGHT at the same y (x: 0, then 1440, 2880, 4320, …), each with a `name` (the slide title). Put every slide's shapes/text/images INSIDE its frame by setting their frameId to that frame's id (give the frame an id and reference it). Slides play in order (left-to-right, then top-to-bottom) in the board's Present mode and export to PPTX, so one frame = one slide. FLOWCHART recipe: rectangles (roundness null for sharp process boxes), diamonds for decisions, arrows with routing:'elbow' and Yes/No as the arrow's text. Use type 'sticky' for sticky/post-it notes (a solid-fill note with an auto-fitting bound label — set text + backgroundColor); type 'line' with no arrowheads + roughness:2 for sketchy mind-map spokes. FREEHAND DOODLES: to actually draw/doodle/sketch freehand, use { type:'freedraw', points } where points is a RELATIVE [[x,y],…] path of the stroke (e.g. a squiggle, circling or annotating something, a hand-drawn star/heart/smiley/arrow, an organic blob) — it renders as one smooth freehand stroke. x/y is the origin; omit x/y to auto-place. Chain several freedraw specs for a multi-stroke doodle. NOTE: freehand is always SOLID (Excalidraw ignores strokeStyle on freedraw) — colour, strokeWidth and opacity DO apply; a freedraw with strokeStyle:'dashed' or 'dotted' is automatically rendered as a smooth dashed/dotted line so the dashes actually show. Give shapes ids and reference them from connectors. Connectors may also bind to shapes ALREADY on the board by their id (get them via getWhiteboard includeElements:true) — you do NOT need to resend existing shapes; the server reads the live scene to bind the arrow and route it around the other boxes. Great for brainstorms, mind maps, flowcharts, org charts, SWOT, retros. PROCESS: for any non-trivial board call getWhiteboardGuide FIRST to plan it; then after adding, ALWAYS call getWhiteboardImage to SEE the result and check layout, labels, spacing, overlaps and how shapes connect — if anything looks off, fix it with updateWhiteboardScene (patch by id) and render again, iterating until it looks right. RESULT: returns `added` (count), `placement` (bounding box {x,y,width,height} of what you just added) and `autoPlaced` (true when you omitted x/y so it was placed in clear space below existing content) — use placement/autoPlaced to tell the user WHERE the new elements landed, never invent a location.
Add an existing organisation member to a workspace with a workspace-level role. Idempotent — returns the existing membership if already a member. Caller must be a workspace owner or admin.
Apply a previously previewed KG scope change. Atomically writes kg_scope rows and dispatches a re-ingest batch (batch_id = token). Idempotent. Rate limit 5/h.
Auto-schedule every item in a plan so all FS/SS/FF task-dependencies are respected (topological pass, durations preserved). Returns the before/after diff and logs a comment on every item that moves. Use `forwardOnly: true` to only shift items currently in violation (never pull already-valid items earlier). Use `pinnedItemIds` to keep specific items at their current dates. Pairs with `previewTaskDependencyCascade` (same inputs, dry-run).
Emergency stop for KG ingestion: cancels queued/running build runs, queued/running rebuild batches, demotes still-eager unfinished chunks. Optionally narrowed to one project. Requires can_manage_kg + (project write if project_id supplied). Rate limit 5/min.
Cancel a pending invitation by id. Sets status='revoked'. Server resolves the organisation_id from the invitation row; the credential must match that org AND hold can_manage_members. Idempotent. Rate limit 30/min. Use when the user asks to cancel, revoke, or undo a pending invitation — for example to correct a typo'd email address before re-inviting.
Cancel a single KG rebuild batch. Queued runs flip to 'cancelled' immediately; running runs finish naturally. Requires can_manage_kg. Rate limit 5/min.
Create a document from CDMD markdown. Call getCdmdLanguageGuide first if unfamiliar with syntax. Do not include DIAGRAM/IMAGE markers — insert them after with dedicated tools. Supports @-mentioning people: embed `` to notify a teammate. Use listAssignablePrincipals to look up the user_id from a name; mentions of users outside the project are silently dropped.
Step 2 of file ingest. After the file is uploaded via the PUT URL from createDocumentIngestSession, call this to start the async conversion. Returns { jobId, documentId } immediately — the document is created as a draft and progressively populated as the worker processes the file. Poll getDocumentIngestJob({ jobId }) to track progress. Idempotent: calling twice with the same sessionId returns the same job/document.
Step 1 of file ingest. Mint a single-use PUT upload URL for a large file (PDF, DOCX, plain text, or markdown — up to 150 MB). Returns { sessionId, uploadUrl, expiresAt, maxBytes }. Upload the raw bytes to uploadUrl with PUT, then call createDocumentFromUpload({ sessionId, projectId }) to start the conversion. The file is auto-deleted once the document is created.
Create a folder in a project. Supports nesting via parentId.
Create a PUT upload URL for a document image (max 10MB). Use the returned assetUrl with insertImageInDocument.
Create an improvement item in a project. Requires projectId and title. Auto-assigns friendly ID.
Create an improvement category or sub-category. Max two levels.
Create a new organisation owned by the calling credential's user. Auth: server-side eligibility gate via `can_user_create_organization` (free-tier users may only have one org). Per-credential rate limit 3/day. Slug auto-generated. The new org is OUTSIDE the credential's current scope (credentials are bound to one org); to use the new org from MCP, mint a fresh credential.
Create a plan in a project. Requires projectId and title.
Create a phase in a plan. Position and wbs_code are auto-computed.
Create a new project inside a workspace. Mirrors the UI Create Project dialog. Auth: write on workspace + credential's `can_lifecycle` capability. Validates name (1..200) and description (0..2000); icon defaults to '📁' if omitted. Server-side limit gate via `can_create_project_in_workspace`. Rate limit 30/min.
Create a task in a plan. Requires planId and title.
Create an FS/SS/FF scheduling edge with lag/lead between two items in the same plan (rendered as a Gantt arrow). FS = Finish-to-Start, SS = Start-to-Start, FF = Finish-to-Finish. `lagDays`: positive = lag, negative = lead/overlap. Rejects self-loops, duplicate (pred+succ+type) edges, cross-plan edges, and cycles.
Create a new team inside an organisation. Caller is added as the team's lead. Subject to plan team limit. Rate limit 30/min.
Create a PUT upload URL for a Vega/Vega-Lite data file. Use returned assetUrl in your Vega spec.
Create a whiteboard — an infinite Excalidraw canvas. A whiteboard is a hidden document (it won't appear in listDocuments) that hosts a single freeform canvas, and opens in the immersive whiteboard editor in the app. Returns documentId + diagramId. Author shapes afterwards with addWhiteboardElements (high-level specs) or updateWhiteboardScene. For anything beyond a blank board, call getWhiteboardGuide first to plan the layout (stencils vs architecture icons vs code/BPMN diagrams vs plain shapes), and render with getWhiteboardImage to verify as you go.
Create a new workspace inside the organisation. Auth: ceiling — credential must hold `can_lifecycle` AND user must be org owner/admin. Rate limit 30/min. Slug auto-generated. Caller becomes workspace owner. Plan limits surface as WORKSPACE_LIMIT_REACHED errors.
Render tabular data as an aligned grid of labelled cells on a whiteboard, deterministically. Pass rows (an array of arrays) OR data (an array of objects), with optional headers; the server lays out evenly-spaced cells so you do NOT place each cell by hand. Use this to turn data, CSV, or JSON into a readable table on the board. Returns a compact summary. Auto-places below existing content unless x/y are given.
Delete a diagram from a document.
Delete a document.
Delete a folder recursively, including all nested folders and documents.
Delete an image from a document and storage.
Delete an improvement and all associated evidence and activity.
Delete an improvement category. Cannot delete system categories.
Delete a comment from an improvement.
Delete a plan, all its phases, and all tasks/improvements within it. This is a destructive operation that cannot be undone.
Delete a comment from a plan.
Delete a plan phase and all tasks/improvements within it. This is a destructive operation that cannot be undone.
Delete a resource_permissions row. Refuses if the row is the LAST admin grant on the resource. Rate limit 30/min. Use when the user asks to revoke access, remove access, take away access, unshare, or delete a permission grant on a specific resource.
Remove a task-dependency edge. Neither item's dates are changed.
Delete a team. Cascades: team members and team-granted resource permissions are removed automatically. Destructive; rate limit 5/min.
Delete a data file attachment from a document.
Delete a whiteboard (the host document and its canvas).
Design a complete, visually polished whiteboard from a natural-language goal using the PREMIUM multi-agent pipeline (the same one the in-app assistant uses): it browses the stencil/icon library, composes the board, renders it, critiques the rendered image, and refines — far better than hand-placing shapes. COST + APPROVAL: this costs 50 credits per board and requires the user's explicit approval. Call it FIRST without `confirm` to get the exact cost + the workspace credit balance; show that to the user and only call again with `confirm: true` once they agree. If they decline (or lack credits), build the board directly with the standard whiteboard tools (addWhiteboardElements / insertWhiteboardDiagram / listWhiteboardStencils) at no extra charge. It runs in the BACKGROUND and returns immediately with a sessionId; the board fills in over 1-3 minutes. The 50 credits are refunded automatically if the design fails on our side.
Per-item: clear `needs_dependency_review` without changing dates — keeps the edge, ignores the suggestion. Use when the successor should stay put despite the predecessor shifting.
Copy-paste existing whiteboard elements — the MCP equivalent of selecting a group and pressing Ctrl/Cmd+D. Clones the given elements (plus their group peers + bound text/labels) with FRESH ids, offsets the copy by dx/dy, and by default groups it into ONE new unit so it moves together. Use it to build something once (a labelled stencil frame, a kanban card, a UML class) then stamp out consistent repeats fast — then retext/recolour each copy by its new id (via the returned idMap) with updateWhiteboardScene. Pass `groupId` to copy a whole group as a unit (e.g. a placed stencil's groupId from its placement result) and/or `ids` for specific elements. Internal references (group membership, bound text containerId, arrow start/end bindings) are remapped within the copied set; a binding to an element you did NOT copy is dropped. Returns { duplicated, idMap (old id → new id), groupId (the copy's new unit group), elementCount }. Render with getWhiteboardImage afterwards to verify.
Edit a document with line-based patches. Call getDocument first for line numbers and versionTimestamp. Call getCdmdLanguageGuide if unfamiliar with CDMD syntax. Do not edit DIAGRAM/IMAGE markers manually — use dedicated diagram/image tools. To @-mention a person in your patch, insert ``; look up the user_id via listAssignablePrincipals. Mentioned users are notified automatically.
Find and replace text in a document. Searches for all occurrences and replaces them. Case-sensitive by default. Diagrams/images are automatically protected — only document text is affected. Note: when the `replace` value contains a `` marker (e.g. inserting a user mention), it round-trips losslessly through the editor and triggers notifications if it adds a new user mention.

Stable Baseline FAQ

How do I improve a ChatGPT Plugin's discoverability?

The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.

What are Stable Baseline alternatives on ChatGPT?

As of 2026-08-14, Stable Baseline competes with Caipi, Catalyst by Zoho, Coda, Document360, Fibery, Neurnav, Notion, xTiles, Zeck in ChatGPT Collaborative Docs & Workspaces, ranked by public Discoverability Score.

Where is this profile measured?

This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.