Skip to main content
A store is private to its agent until you share it. Sharing a store lets the workspace’s other agents, your own app or an AI assistant read it, and when you allow it, change it. Other agents need no key. Apps and AI assistants use one of the agent’s endpoint keys. Nothing else can reach it from outside the agent. Variable groups, databases and File Stores can all be shared.

Turn it on

1

Open the store

Open the agent, then its variable group, Database or File Store.
2

Open Manage access

Under the store’s name, Shared with says who may use it now, for example “Shared with: Other agents · API”, with its level, or Not shared. Click Manage access. A drawer opens with two tabs, Access and Activity. The same drawer opens from the agent’s Settings → External access, which lists every store under Data with who may use it and its calls of the last 7 days.
3

Choose the level and who

On Access, choose Read or Read & write. The default, Off, keeps the store private. Then choose who may use it:
  • Other agents: “Any agent in this workspace can use it. No key.” For a store in a project, the agents of that project.
  • Apps (API): your own app, over the web API, with an endpoint key.
  • AI assistants (MCP): an assistant at the agent’s MCP address, with an endpoint key.
A store you share for the first time starts with Other agents. While it is at Read or Read & write, at least one of them stays on: to stop sharing it, set it to Off.
4

Make a key, for apps and AI assistants

Make an endpoint key in the agent’s Settings → Keys, or use one you have. See Endpoint keys. Any key of this agent can call every store open to apps or AI assistants. An agent that offers no endpoint can still have keys: while a store is open to apps or AI assistants, a key may list no endpoint and reaches only those stores. Other agents need no key.
5

Call it

Under For developers, the drawer shows the store’s web address, its MCP address and ready curl calls to copy, for the ways in that are open.
Only people who can edit the agent change who may use a store. A store in Unsorted can’t be shared: move it into an agent first. A way in that is not open answers like a store that doesn’t exist: the web API answers 404 while Apps (API) is off, and the MCP address lists no tools for the store while AI assistants (MCP) is off. For what other agents do with a store you share, see Use a store another agent shares.

What stays private

  • Secrets are never readable or settable from outside. A read shows them masked, and a write to one is refused. Only people set a secret. Other agents never use them: their items can’t put a secret of a shared group in a step.
  • Connection variables are used only by the store’s own agent. Other agents can’t use them, and a key reads one only as the account’s name.
  • Tables and columns can’t be changed from outside, only rows.
  • Other credentials are refused. Personal access tokens and the workspace API key don’t open stores. Only an endpoint key of the store’s own agent does.
  • Another agent’s store gets the same answer as a store that doesn’t exist.

Web API

Every call goes under your agent’s address, with the kind of store in the path:
Send an endpoint key as in the Endpoint API:
Only endpoint keys work here. Bodies are JSON. Calls count against the same limit as endpoint calls: 120 a minute per key. {store}, {group} and {db} below can be the item’s id, its key or its name, URL-encoded. Names are unique within a kind, so a name is enough.

See what a key reaches

Each list answers with only the stores of that kind this key may use. access is read or read_write.

Environments

An agent can have more than one environment, such as Production and Demo. A call to /files/{store}, /variables/{group} or /databases/{db} reads and writes the environment the agent runs in, and the answer says which: environment in a JSON answer, or the x-environment header on a file download. When the agent is in Production, that is Production. A key whose store is set to Read & write can name another environment with ?environment=<name>. The name is not case sensitive, and production is Production.
  • A key set to Read that names an environment gets 403 environment_not_allowed. It always reads the current one.
  • A name the agent doesn’t have gets 404 environment_not_found.
  • A File Store or Database that is Separate in each environment has its own files or rows there. While they are still being copied, failed or are not set up, the call gets 409 store_contents_not_ready, such as “Leads has no rows in Demo yet.” It is never answered from Production.
  • A store that is The same in every environment answers the same whichever environment you name.
  • A variable’s value is never taken from Production. A variable with no value there reads as empty.

Files

A path starts at the store’s top folder, for example reports/2026/march.pdf. ifExists is fail (the default), replace or keep_both. Two things to know:
  • ?search= on a path is refused. To search inside a folder, put the search on the store and name the folder: ?search=…&folder=<path>.
  • A trailing slash does not mark a folder, and the server redirects it away. Use ?folder=true.
A web page or image with scripts that an outside key writes is never shown as a page in the app. People see its text, or download it.

Variables

A DELETE of a variable that something uses fails with 409 variable_in_use. The people who work in the app see the full Used by list; a key learns only the kinds. Change those uses, then delete again. Writes take an optional If-Match: <revision> header, using the revision number from the variable’s answer. If someone changed the variable since, the call fails with 409 revision_conflict and the current revision, so read it again and retry. A value that is not a number is 400 invalid_request. Secrets are always masked, and only people in the app can set a secret’s value. A variable group has a value per environment: see Environments. A variable’s revision counts per environment. revision 0 means the variable has no value in that environment yet. Send If-Match: "0" on a PUT to write only if there is still no value there: the first write wins, and a later one gets 409 revision_conflict with the current revision.

Connection variables

A variable of type connection holds an account of one app, shared with the workspace. It reads as an object and never shows credentials:
An empty one reads as null. Like every variable, it has a value per environment. See Connection variables. A PUT sets one:
  • The body’s value is the account’s id, or null to clear it.
  • To create one, send "type": "connection" and "connectionApp", the id of the app. Without it the call fails with variable_type_mismatch: “A Connection variable needs its app.” The app is fixed after that.
  • The account must be in the workspace, of the variable’s app, shared, and one the person behind the key may use.
  • Only a person sets one. A key counts as the person who made it. If that person has left the workspace, the call is refused.
  • A DELETE of one is a person’s call too.
These answer 400. A step can’t use a Connection variable of another app, or one the agent doesn’t have: that is refused as agent_variable_unknown when the step is saved.

Databases

filter is JSON in the web address, with the operators eq, ne, gt, gte, lt, lte, in, like and is_null:
POST /databases/{db}/query always runs read-only, even on a store set to Read & write. To change data, use the row calls.

Errors

Errors look like { "error": { "code": "…", "message": "…" } }.

MCP

An agent’s MCP address lists a set of tools for each store open to AI assistants (MCP):
Connect with an endpoint key of the agent, as in AI assistants over MCP. Tools are named <key>__<action>, for example CRM__find_rows. A store that is Off, or not open to AI assistants, lists nothing, and an assistant sees a change on its next call. Every store tool reads and writes the environment the agent runs in, and takes no environment. A Database or File Store whose rows or files are not ready there answers store_contents_not_ready. The variable tools’ answers carry environment. list_variables and search_variables answer { variables, truncated }. query is always read-only. read_file returns text, or a binary file up to 1 MB as base64. write_file takes up to 5 MB a call; use the web API for larger files. delete_file moves the file to the Trash. An agent’s address lists at most 100 tools, endpoints first and then stores by name. A store beyond the limit is left out.

Activity

The Activity tab of Manage access lists the calls made from outside the agent: which other agent and which of its items, or which key, whether through another agent, the web API or MCP, the action, the table, variable or file it touched, whether it worked, and when. Another agent’s item you can’t open is not named. A refused call shows as “Refused: …” with why. Values, rows, SQL and file contents are never recorded. When a copy of an agent that uses the store takes its contents, the row reads Copied into a shared agent. Each write is one row. Reads in the same minute from one key, or from one item of another agent, are counted together, with failed reads counted apart by what went wrong. Entries are kept 30 days.

Call a store from another agent

Another agent needs no key. Turn on Other agents in the store’s Manage access, and the store shows in that agent’s pickers under Shared by other agents. See Use a store another agent shares. Another agent always reaches the store’s Production values, rows and files, whatever environment either agent runs in. While that agent runs in another environment, its writes are refused with link_read_only_outside_production: “Demo can read Leads from Sales but not change it. Only Production can.”

Copies

A copy of a shared agent has every store at Off, shared with no one, and no endpoint keys come with it. A store another agent shares with the agent travels as the copy’s own store, with its structure, and with its contents only when they are included and may still be shared when the copy is made. See Stores from other agents.

Next steps

Endpoint API

Keys, limits and calls to your agent’s endpoints.

Data stores

What each kind of store holds, and how other agents use one.

Agent variables and secrets

Where secrets are kept and how they stay private.

Connect MCP

The tools that build and run your workspace.