Scope Levels

  • Desktop app
  • All plans
View as Markdown

What it does

AgentsRoom files what an agent knows and what it can reach on a ladder of scopes: the account (yours, everywhere), the folder a project is filed under (typically a client or an employer), the project (one repository, shared with everyone who clones it), and a single saved agent. Knowledge accumulates downward: an agent in a project filed under "Acme / incidents" reads the account knowledge, Acme's, incidents', then the project's. Connections work the other way round: an agent can be restricted to the servers, databases and dev commands it is allowed to address.

Current grid: memory exists at account, folder, project and agent level; skills at account, folder, project, agent and ticket level; prompts at account and project level; environment variables, CLI options and MCP servers at Settings, folder, project and agent level; the Quick, QA and Backlog agent profiles at Settings, folder and project level; teams at account, folder and project level; SSH, database and dev command connections at account and project level, restrictable per agent.

A folder is how you give a client its own environment: its CLI, accounts, variables, MCP servers, auto-launched agents and teams, set once and synced to your account so every computer finds them. An SSH host can be tied to a folder, and every project opened on that host is then filed in it.

Where to find it

  • Folder scopes: right-click a folder in the sidebar > Folder settings. Section AI providers holds the CLI and accounts, Environment the per-CLI variables and options and the MCP servers, Auto-launched agents the Quick, QA and Backlog agents, Knowledge the Zone skills, Concierge the folder's standing agent, Git the folder's commit defaults.
  • Folder teams: Teams panel > Configure > <folder> folder teams > New folder team (shown when the project is filed in a folder).
  • Tie an SSH host to a folder: SSH connection form > Client folder of this host.
  • Memory scopes: the Project memory modal shows tabs for the project, Memory of <folder> (only when the project is in a folder), Global and Agents (Agent notebooks, "What each of your agents has learned", one folder per agent). The Agents tab is always there, empty included.
  • Zone memory, from the zone itself: Folder settings > Workspaces > Zone memory > Open the memory.
  • Agent scope: Edit agent > Default skills, Connections (attach servers, databases, commands) and Memory notebook, which shows how many notes that agent wrote and opens them with Open.
  • Project scope: Project settings > Agents > Project skills and Project memory.

How to use it

  1. Pin knowledge once for a whole client: Folder settings > Knowledge > Zone skills. Only global skills can be pinned (a folder spans several repositories). They reach every agent of every project below, and they add up along the chain rather than replacing each other.
  2. Give a folder its own knowledge base: write notes in the Memory of <folder> tab, or let agents do it with memory_save and scope: "folder". The zone memory is yours (account-side), never committed, and mirrored into every project of the folder so agents read it as files.
  3. Set a Concierge for a folder: the agent you talk to about the zone rather than about one repo (triage a ticket, find which project it belongs to). It launches from the folder row in the sidebar and runs in the folder's most recently opened project.
  4. Restrict an agent's reach: Edit agent > Connections, attach servers, databases or commands. Each family is restricted only if you pin at least one item of that family; the agent's list tools then show only those, and its action tools refuse anything else.
  5. Let a specialist keep its own notebook: agents call memory_save with scope: "agent"; the notes land in the account memory under agents/<agent name> and follow the agent from project to project. Read or correct them yourself in Edit agent > Memory notebook > Open, or browse every agent's notebook from the Agents tab of the Project memory modal.

Settings

  • providerEnvVars (folder, Folder settings > Environment > <CLI> environment variables): KEY=value lines per CLI for every project of the folder, {{secret:NAME}} allowed. Merged key by key: Settings, then the folder, then the project, then the agent.
  • providerCliOptions (folder, Folder settings > Environment > <CLI> CLI options): replaces the Settings options of that CLI for the folder's projects; an agent's own options still win. Empty = inherit.
  • mcpServers (folder, Folder settings > Environment > MCP servers): servers every agent of the folder gets, merged by name with Settings and the project (a project or an agent can switch one off).
  • quickAgentOverride, qaAgentOverride, backlogAgentOverride (folder, Folder settings > Auto-launched agents): profiles used by the folder's projects unless the project sets its own. Order: project, folder, Settings.
  • Team scope folder (Teams panel): a team offered in every project filed under the folder or its sub-folders, synced with your account like a global team.
  • SSHConnection.folderId (SSH connection form > Client folder of this host): projects opened on this host are filed in that folder. A project you move to another folder stays there; changing the host's folder moves the projects still in the old one.
  • defaultSkillIds (project, Project settings > Agents > Project skills): skills every agent of the project inherits.
  • memoryEnabled (project): master switch of the project memory.
  • Folder settings (Folder settings modal): zone skills, concierge, commit rules and conversation attachment defaults; a subfolder's value wins over its parent's, except zone skills which accumulate.
  • Agent: Default skills and Connections in the agent editor.

Agent tools (MCP)

  • settings_list, settings_get, settings_set with scope: "folder": every folder key above (providerEnvVars, providerCliOptions, mcpServers, the three agent profiles).
  • teams_list, teams_get: also return the folder teams of the project's folder chain, with scope: "folder".
  • memory_list, memory_get, memory_save: take scope = project (default), folder (nearest folder for writes, whole chain for reads), global (account), agent (the caller's notebook).
  • skills_list, skills_get: return project and account skills with their scope.
  • prompts_list, prompts_get: return project and account prompts with their scope.
  • ssh_list, db_list, commands_list and their action tools (ssh_connect, ssh_exec, db_schema, db_query, commands_run, commands_get): filtered by the agent's attached connections when it has any; a scopeNote tells the agent the list is restricted.

Providers

All providers, no difference: scopes are resolved by AgentsRoom when it builds the agent's prompt and by its MCP server.

Mobile

Not available: the phone has no folder tree and no agent editor beyond name and colour. What a folder sets still applies to what the phone starts: an agent launched from the phone gets the folder's variables, CLI options and MCP servers, the Quick agent button uses the folder's profile, and the team list shows the folder's teams. Its server, database and command lists are not filtered (the scope is an agent permission, not a display preference). An agent launched from the phone runs on the desktop with the same scopes.

Limits

  • Connections at folder level do not exist yet (account and project only, restrictable per agent).
  • Environment variables and your own MCP servers are not sent to an SSH host: an agent running on a remote host gets the folder's CLI, accounts, CLI options, agent profiles and teams, but not its variables or user MCP servers.
  • A new project pins its own Quick agent at creation (the agent picked in the New project dialog), so the folder's Quick profile applies to projects that do not pin one; clear the project's override to inherit the folder's.
  • Folder settings edited on two computers at once merge key by key: the newest edit of each setting wins.
  • An agent's connection scope is read once when its session starts: changing it in the editor applies to the next launch.
  • The agent notebook is keyed on the agent's display name: renaming an agent opens a new notebook and leaves the old one visible.
  • Team steps ignore agent connections (ids are machine-specific).
  • Zone memory is not applied the two-root taxonomy of project memory.
  • The agents/ and zones/ folders stay visible in the Global tab next to your own folders: the named tabs are a second view of the same store, not a move.

Common questions

  • Where does knowledge about the code go, versus knowledge about the client? Code knowledge in the project memory (shared with everyone who clones). Client context in the folder memory (yours, mirrored into the folder's projects). Personal habits in the account memory.
  • I pinned a skill on a subfolder and the parent's skills disappeared? They should not: zone skills accumulate root first. Check the parent folder's own Zone skills.
  • Why does my agent see only two servers? It has connections attached in Edit agent > Connections. Detach them to restore the full list.
  • Can each client have its own LLM gateway, MCP servers and teams? Yes: put the client's projects in a folder and set them in Folder settings (Environment, Auto-launched agents) and in the Teams panel (New folder team). They follow your account to your other computers.
  • How do I make a remote server behave like the client's environment? Tie the SSH connection to the client's folder (Client folder of this host): every project you open on that server is filed there and inherits the folder.
  • Does the concierge need a repository? Yes, a CLI needs a working directory; a folder with no project shows no launch button and says why.

Related