- Brand
- Cohesive AI
- Category
- AI
- Primary Subcategory
- Shared Team AI Workspaces & Skill Libraries
Integration details
Description
A chat ends. The work doesn't. With Cohesive connected, what the agent makes lands in your workspace as a canvas, a file, or an automation that runs on its own schedule. Open it later, edit it, and pick up where you left off. Every call runs as you and sees only what you can.
- Integration type
- Plugin
- Verification status
- Not applicable
- Platform
- ChatGPT
- Primary Subcategory
- Shared Team AI Workspaces & Skill Libraries
- Secondary Subcategories
- None listed
- Brand
- Cohesive AI
- Access
- Account required
- First tracked
- 2026-11-20
- Tool count
- 63
- Market
- US
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Not discoverable in ChatGPT yet
ChatGPT now suggests Plugins on its own when they match a user's request, but not every Plugin is being surfaced yet.We haven’t seen Cohesive suggested yet. Sign up and we’ll track it, and your Discoverability Score will appear here once ChatGPT starts surfacing it.
What discovery looks like

Get alerts for Cohesive
Get updates when Cohesive’s Discoverability Score or category rank changes.
Competing in ChatGPT Shared Team AI Workspaces & Skill Libraries
View Category63 tools agents can invoke
Create an automation. Creates an automation on exactly one of canvas or workspace. Instructions come from instructions. Scheduling is one of three shapes: cron recurring, on that cadence, interpreted in tz (an IANA zone; the server default applies when omitted) run_at one-off, a single run at that RFC 3339 instant and no cadence neither on-demand only: it runs when triggered with automation_run cron and run_at are mutually exclusive. An invalid cron or time zone is rejected with the server's explanation. Exactly one of: canvas, workspace. At most one of: cron, run_at.
automation_create
Delete an automation. Deletes an automation permanently: its cadence stops and it can no longer be run. Past runs are chats and survive. Deleting an already-deleted automation also succeeds.
automation_delete
Edit an automation. Edits an automation. Only the properties passed are sent; everything else is left unchanged. Setting cron "" clears the cadence entirely, making the automation on-demand only — to stop scheduled runs while keeping the cadence, use automation_pause instead. run_at schedules a single run at that RFC 3339 instant, which is also how a one-off that has already fired or been paused is re-armed. Setting run_at "" clears the pending run, exactly like pause. Only the automation's owner can edit it; the server rejects anyone else.
automation_edit
Show one automation. Shows one automation in full, including its instructions. The state derives from the stored cadence: active (a next run is scheduled), paused (a cadence is stored but nothing is scheduled), or on demand (no cadence). When the scheduler skipped the most recent firing, the reason and time are shown.
automation_get
List automations. Lists automations. With no filter, lists the signed-in account's own automations across every canvas and workspace. With canvas or workspace, lists every owner's automations on that one resource (ones the account does not own are read-only). At most one of: canvas, workspace.
automation_list
Pause an automation's scheduled runs. Pauses an automation: the pending run is cancelled while the cron cadence stays stored, so automation_resume picks the schedule back up without re-entering it. On a one-off (a run-at instant, no cron cadence) there is nothing to resume from: pausing cancels the single pending run outright. Re-arm it with automation_edit run_at.
automation_pause
Resume a paused automation. Resumes a paused automation by re-submitting its stored cron cadence, which makes the platform compute the next run time. Resuming needs a cadence to recompute from, so it does not apply to a one-off or an on-demand automation — schedule those with automation_edit run_at or automation_edit cron.
automation_resume
Run an automation now. Starts a run immediately, outside any cadence. The run executes asynchronously in a new chat (flow session) — the session id comes back right away, without waiting for the run to finish. The scheduler's fire-time gates still apply: an archived or missing target canvas or workspace rejects the run, which exits 1 (error) with the platform's explanation; a billing denial exits 6 (payment required).
automation_run
List an automation's runs. Lists an automation's runs, newest first — scheduled firings and automation_run triggers alike. Each run is a chat (flow session); read one in full with chat_get. Page with before using the previous page's pagination next_ts. Owner-only.
automation_runs
Move a canvas to the trash. Archives a canvas (soft delete), cascading to the chats and files that live on it. Everything is restorable with canvas_restore — nothing is destroyed.
canvas_archive
Render a canvas to a webp image. It lets an agent see the canvas as drawn: check layout, overlaps, or how an edit came out. To show a canvas to a person, use canvas_view. The whole canvas is fit to the frame by default. To see a region as a person would, pass bounds (a rectangle in canvas coordinates, "x,y,width,height") or node_ids; both take the coordinates and ids that canvas_view returns. The image carries the canvas ground and grid. background solid drops the grid; background transparent drops the ground too, for compositing. The render runs server-side and takes tens of seconds. At most one of: bounds, node_ids. The rendered webp is returned as an image block.
canvas_capture
Read one comment thread in full. Returns a thread's summary line and its full transcript: every comment in order with its time, author, and comment id. An edited comment is marked, and a deleted one is shown as a tombstone rather than its text. Thread ids come from canvas_comment_list, or from canvas_view where a commentMarker node's id is its thread id. A thread that is not on this canvas fails as not found. data carries the thread structured — comments[] with ids, authors, timestamps, and bodies — beside the prose in content.
canvas_comment_get
List a canvas's comment threads. Lists the comment threads on a canvas, one block per thread: thread id, resolved state, comment count, placement (anchored to a node id, or free-floating at a coordinate), participants, who commented last and when, and a truncated preview of that newest comment. Read a thread in full with canvas_comment_get. mentions_me is matched after the fetch over a bounded number of pages, so the result says when more threads exist than it scanned. data carries the threads structured — ids, flags, placement, participants, timestamps, and the preview — beside the prose in content.
canvas_comment_list
Create an empty canvas in a workspace. Creates a canvas. The workspace is the canvas's home; folder files it into a folder of the workspace tree, the same tree file_mkdir and Library files use. Pass a folder path ("Onboarding", "Clients/FAI/") or the file-record id of a folder. The folder need not exist beforehand, though only file_mkdir keeps an empty one around. Without folder the canvas lands at the workspace root. Rename with canvas_rename, relocate with canvas_move, trash with canvas_archive. Put content on it with the canvas_node_add_* tools and canvas_edge_add.
canvas_create
Add an edge between two nodes. Connects two nodes. source and target are NODE ids from canvas_view — never a file or entity id; for placed files and media the node id differs from the file id, and an edge to a non-node id is skipped. label puts short text at the midpoint ("depends on"). Handles (top, right, bottom, left) pin which side the edge leaves and enters; omit them to auto-route, set them for feedback loops and multi-edge pairs.
canvas_edge_add
Delete edges.
canvas_edge_delete
Update an edge's label or style.
canvas_edge_update
Apply a batch canvas edit (the raw canvas-edit payload). Applies one canvas-edit call from raw JSON — the escape hatch for building a whole diagram, or several changes, in a single atomic round-trip. The payload is the canvas-edit action's input, verbatim: {"nodes": [...], "delete_node_ids": [...], "edges": [...], "delete_edge_ids": [...]} Each nodes[] entry is {entity | entity_id | id, position, width, height}; entity is one of canvas_text_note, canvas_text_label, canvas_shape, canvas_connector, or a generic remote record. payload is the canvas-edit object: {nodes, delete_node_ids, edges, delete_edge_ids}.
canvas_edit
Return one canvas's details. Returns a canvas. parent_path is where it sits in its workspace tree ("" at the root, otherwise a folder path); absent when the server does not report it, including a canvas shared directly from a workspace the account cannot view. Re-file it with canvas_move. view_url is the public URL to show a person; dashboard_url opens the canvas in the app for a signed-in user.
canvas_get
List accessible canvases. Lists every canvas the signed-in account can access, most recently modified first. With workspace, lists only that workspace's canvases (unpaginated — limit does not apply). parent_path is where a canvas sits in its workspace tree ("" at the root, otherwise a folder path); absent when the server does not report it, including a canvas shared directly from a workspace the account cannot view.
canvas_list
Move a canvas to another workspace or folder. Relocates a canvas: workspace re-homes it to another workspace, folder files it into a folder of the workspace tree, root moves it back to the workspace root. The tree is the one file_mkdir and Library files use; folder takes a folder path ("Onboarding", "Clients/FAI/") or the file-record id of a folder. The folder need not exist beforehand, though only file_mkdir keeps an empty one around. Workspace and folder moves go in one request; workspace alone lands the canvas at the new workspace's root. Filing takes edit rights on the workspace. At most one of: folder, root.
canvas_move
Add a free-floating connector line between two points. Adds a connector: a line or arrow between two absolute canvas coordinates, attached to nothing. To connect two NODES so the link follows them, use canvas_edge_add instead — connectors are for freehand arrows and diagram lines between positions. Connectors take no position or size; their geometry is start and end. arrow_mode none|end|both presets the arrowheads; curve smooth, straight, or step (default, right-angle).
canvas_node_add_connector
Place a file that exists. Places a file the platform already holds — a card deleted earlier, or a file from any workspace of the organization — and prints the same result as file_upload: file id, node id, path, display. The node id is what edges, moves and deletes take. A file already on the canvas is moved, not placed twice, and its node id comes back.
canvas_node_add_file
Add a text label (a single line of free-standing text). Adds a text label: one line of text directly on the canvas — headings, captions, annotations. Font sizes are 16px (default), 20px, 32px, 48px; keep content to roughly 8 words at 16-20px, 5 at 32px, 3 at 48px; a label auto-sizes to its text. Omit color for the theme-adaptive default (this is usually right). Colors are the spectrum palette: orange, yellow, green, blue, violet, mulberry, brown, indigo, olive.
canvas_node_add_label
Add a text note (a sticky with a title and markdown body). Adds a text note: a titled sticky holding markdown content. Notes default to 288x288; use 192 height for short notes and 384 for long ones. The title should be 2-6 words. Colors are the sticky palette: apricot, butter (default), meadow, sea, orchid, rose, clay, mist, oat.
canvas_node_add_note
Add a card for a record in a connected tool. Adds a card for a record that lives in another tool (slack, notion, github, ...), built from the fields passed. platform and id name the record; placing the same platform id again moves the card it already has instead of adding a second one. The result carries the node id, which is what edges, moves and deletes take.
canvas_node_add_record
Add a shape (rectangle, circle, diamond, triangle, pentagon, cylinder). Adds a shape, optionally with centered label text (content). Shapes default to 144x144; 192x96 works well for sequence-diagram boxes. fill takes the sticky palette (apricot, butter, meadow, sea, orchid, rose, clay, mist, oat); stroke takes the spectrum palette and defaults to the stroke paired with the fill. no_fill draws a stroke-only outline.
canvas_node_add_shape
Delete nodes from a canvas. Deletes nodes by node id. Deleting a file's node removes the card from the canvas; whether the file itself survives follows the platform's file rules (a reference's deletion removes only the reference).
canvas_node_delete
Read nodes in full. Fetches the complete stored content of specific nodes — the full text of notes that canvas_view truncates, complete entity data, exact geometry. If a node's content shows it is a file record (entity base "file_record"), the node holds only file METADATA: the file's content is a different id and a different tool — read it with file_read file_record_id (metadata with file_get file_record_id). Passing a file id here fails and says so.
canvas_node_get
Move a node to a new position. Repositions one node by its node id (top-left corner, canvas coordinates, 16px lattice). Works for every node type, including files and media. Content is untouched.
canvas_node_move
Resize a node. Resizes one node by its node id (dimensions in canvas units, 16px lattice). position moves it in the same call.
canvas_node_resize
Update a node's content or style. Updates a canvas-native node in place: pass only the properties to change; the rest of the node is untouched (the platform merges partially). The node's current type decides which properties apply — title/content/color for notes and labels, fill/stroke/shape/content for shapes, start/end and the stroke properties for connectors. Only canvas-native nodes (notes, labels, shapes, connectors) update this way. A file's content is edited through the file itself, and an HTML block through the file_* tools on its file id — the canvas card re-renders on its own.
canvas_node_update
Publish a canvas to a public URL. Publishes a canvas as a read-only public snapshot — anyone with the URL can view it, no Cohesive account needed. The URL comes back as view_url and is the one to give a person; dashboard_url opens the canvas in the app for a signed-in user. Revoke with canvas_unpublish. Publishing runs server-side and takes a while (it rebuilds the snapshot and the social card), so this waits for it to finish and reports the outcome. The snapshot is a point-in-time copy: later canvas edits are not published until the canvas is published again. view_url is the public URL to show a person; dashboard_url opens the canvas in the app for a signed-in user.
canvas_publish
Return a canvas's full content document. Returns the canvas's full content document as {nodes, edges}, each keyed by id. Node and edge shapes follow the canvas frontend's document model and are not a stable contract. Full documents can be very large — survey with canvas_view first, then use node_ids here to fetch specific nodes in full.
canvas_raw
Rename a canvas.
canvas_rename
Restore an archived canvas.
canvas_restore
Revoke a canvas's public URL. Takes a published canvas offline: the public URL stops serving, and a publish still in flight is cancelled. The canvas itself is untouched.
canvas_unpublish
Show a canvas inline. Hosts that support MCP Apps render an interactive board in the conversation; the result is also the canvas's compact projection — identity, geometry, and semantic content with styling stripped and free text truncated — as node and edge tables. Use canvas_raw node_ids to fetch specific nodes in full. state adds each HTML block's state summary as block_state; read the data with file_state_get.
canvas_view
Show one chat.
chat_get
List the signed-in account's chats. Lists the signed-in account's live (non-archived) chats, newest first. Page with before using the previous page's pagination next_ts.
chat_list
Copy a file record to a new parent or path, and place the copy. Copies a file record to a new destination; the source is untouched. The path rule matches upload. overwrite replaces the contents of an existing record at the destination path, preserving its ID and share state. Exactly one of: workspace, canvas, chat.
file_copy
Delete a file record. Soft-deletes a file record. Recently deleted records can be restored with file_recover.
file_delete
Change how an .html file renders: block or document, kind, chromeless, natural box. Rewrites the display of an .html file — the identity every node showing it follows: block or document, the block's kind (app or static), chromeless, and the natural box a later placement lands at. Only the flags passed change. A kind that becomes static is checked against the stored HTML: scripts, handlers and forms are refused. Nodes already on a canvas keep their position, box and layer; those are the node's (canvas_node_move, canvas_node_resize, and the layer through canvas_node_update). At most one of: block, document. At most one of: chromeless, no_chromeless.
file_display
Show one file record. view_url is the URL to show a person; raw_url serves the bytes for fetching or embedding and is not for people; dashboard_url opens the record in the app for a signed-in user. download_url is a signed link to the bytes, valid until download_url_expires_at: the way to move a file anywhere, or to read one file_read cannot return inline.
file_get
List file records under one parent resource, recent files, or deleted files. Lists file records scoped to exactly one parent — a workspace, a canvas, or a chat (flow session) — or one of two cross-workspace views (newest first; page with before): recent, the signed-in account's recently modified Library files, and deleted, recently deleted files still restorable with file_recover. A workspace's canvases sit in the same tree as its files. They are left out by default; kinds picks the row kinds to list (file, folder, link, canvas), so kinds canvas is the canvas tree and kinds file,folder,link,canvas the whole workspace tree. Exactly one of: workspace, canvas, chat, recent, deleted. At most one of: kinds, recent, deleted. view_url is the URL to show a person; raw_url serves the bytes for fetching or embedding and is not for people; dashboard_url opens the record in the app for a signed-in user.
file_list
Create an empty file-system directory. Creates a folder-kind file record — a file-system directory — under exactly one parent: a workspace, a canvas, or a chat (flow session). Directories normally come into being when a file path names them; mkdir exists so an empty directory can be prepared before files move in. Organizing files into folders is this plus file_move path. A workspace's directories are its tree: the folders the left rail shows, holding Library files and canvases alike. canvas_move folder files a canvas into one, and an empty directory stays around only when created here. Exactly one of: workspace, canvas, chat.
file_mkdir
Move a file record to a new parent or path. Moves a file record to a new destination. The path rule matches upload: no extension or a trailing / means a directory (the current file name is kept); an extensioned path renames. Omitting path keeps the name at the destination root. Exactly one of: workspace, canvas, chat.
file_move
Move a canvas or chat file into the workspace Library. Moves a canvas or chat file into the workspace Library — what dragging it to the Library does in the app. The file keeps its ID, and a reference (a link record) is left behind in its source container in the same action, so the canvas or chat still shows the file, now pointing at its Library home. workspace defaults to the source container's workspace, and parent_path places the file under a Library directory (default: the Library root).
file_promote
Publish a file record to a public URL. Makes a file record publicly readable — anyone with the URL can view it, no Cohesive account needed. Two URLs come back. view_url is the viewer page: the one to give a person. raw_url serves the file's bytes: use it to fetch the content, embed the file in another file, or hand it to another service — never as the URL to show someone. Revoke with file_unpublish. view_url is the URL to show a person; raw_url serves the bytes for fetching or embedding and is not for people; dashboard_url opens the record in the app for a signed-in user.
file_publish
Read a file record's content. Returns a file record's bytes. For reading, not transfer: text comes back inline up to the output cap and an image up to 3 MiB as an image block; anything else is refused. To move a file anywhere, or read one that does not fit, use file_get and hand its download_url to whatever needs the bytes.
file_read
Cohesive ChatGPT Plugin FAQ
How the directory, categories and Discoverability Score work.
Read the methodologyHow do I improve Cohesive's ChatGPT Plugin 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 Cohesive alternatives on ChatGPT?
As of 2026-11-20, Cohesive competes with Noodle Seed, 00Widget, AAS Core, ActVox, Agent Relay in ChatGPT, AgentGrid.io - Shared Drive, AI 超級大腦課・知識庫工具, AInauten Tools and 40 more in ChatGPT Shared Team AI Workspaces & Skill Libraries, 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.