Agent Clones
An agent is only for the user who made it. To give other people the agent you built, you let them clone it: each gets an agent of their own, a clone, that follows yours (the base). Everything the base provides stays the same on every clone and can only be changed on the base; each person adds what is theirs on their own clone.
People get a clone in two ways:
- Shared to clone. On the base's Permissions tab, share it with a user to clone ("Can clone"). Platform users and app users can both be given an agent to clone. They find it on their Agents page under Shared with you to clone and click Clone (or
POST /api/v1/agents/:id/clone). Sharing to clone never lets them use or change your agent itself. - Through an app. An app can give each of its users their own clone (see An agent for each user of an app).
Concepts at a glance
| Term | Meaning |
|---|---|
| Base | The agent you build and keep. It is never used by anyone else; it is shared only to clone |
| Clone | A user's own agent made from a base. It shows "Clone of base" and follows it |
| Official layer | Everything the base provides, its name included. Read-only on every clone, kept in sync with the base |
| Per-user layer | What a clone's user adds: memories, tasks, knowledge, preferences, artifacts, conversations, their own skills, rules and prompts |
| Identity | A clone acts as its user. An app's clone uses the app owner's models, tool workflows, workspace and MCP servers |
| Restrictions | Every agent has an allowlist of features, all of them until its owner restricts it. A clone has exactly its base's |
| Sync | A change to the base reaches every clone; running clones are redeployed |
| Pins | Library versions pinned on the base hold for every clone |
The official layer and the per-user layer
| Layer | What it holds | On a clone |
|---|---|---|
| Official | Everything the base provides: its name and description, its instructions and operating prompt, model and fallbacks, skills, rules and prompts, knowledge, tools, connectors, data sources, add-ons, settings and Library version pins | Read-only, shown as "From base". It cannot be changed or removed on a clone (403 with code clone-follows-base); change it on the base |
| Per user | What the clone's user adds: memories, tasks, their own knowledge bases and uploads, preferences, artifacts, conversations, and skills, rules and prompts they add | Theirs alone: no other clone, and not the base, sees it. Their skills, rules and prompts are added beside the official ones, never replacing them |
A change to the base reaches every clone: the platform updates each clone and redeploys the running ones, keeping each user's own records. Pins set on the base hold for every clone.
Renaming the base renames every clone: its user sees the new name on their agent pages, in the app and in STAN, and the base's Clones list shows it. A clone's name is its base's, unique among its user's agents: a user who already has another agent or workflow of that name gets "name (2)".
A clone's own knowledge: on the clone's Knowledge tab, under Your own knowledge, click New knowledge base and add documents to it (or POST /api/v1/library/knowledge-bases with cloneId). The clone answers from it beside the base's knowledge.
The base's clones
The base's Overview tab lists its Clones: each user's clone, whether it came through an app or by sharing, its status, and whether it is in sync with its base. If redeploying a running clone fails, that clone stays out of sync: the list shows the error, the clone's own page ("Clone of ...") shows it, and you get a notification. It is tried again when the clone next starts, when the base changes again, or when you click Sync now (POST /api/v1/agents/:id/sync, on the base for every clone or on one clone).
A base can't be deleted while it has clones, or while an app clones it for each user.
Stop sharing a base with someone who has a clone
On the base's Permissions tab, the trash icon beside a user stops sharing the base with them. If they have a clone of it, a warning names their clone and you choose what happens to it:
| Choice | What happens to their clone | REST clones= |
|---|---|---|
| Keep it working, stop syncing | It keeps running with the configuration it has now and reads the base's skills, rules, prompts, memories and artifacts at the versions it reads now. It stays read-only, and your later changes to the base no longer reach it. | keep |
| Suspend it | It is stopped and can't start until you share the base with them again. Their records stay. | suspend |
| Delete it | It is deleted with their own memories, tasks, knowledge, preferences, artifacts and sessions. | delete |
The base's Clones list shows a kept clone as Not synced: no longer shared and a suspended one as Suspended: no longer shared, with the date. The clone's own page says the same, and starting a suspended clone is refused (409 clone-suspended). Sharing the base with that user again makes a kept or suspended clone follow the base again: it takes the base's current configuration right away, and a suspended clone can be started again. A clone an app made for its user follows the app, not the share, so it is not affected.
# Without a choice, a user with a clone is refused (400) and the detail names the clone
curl -s -X DELETE "$STRONGLY_URL/api/v1/agents/$BASE_ID/permissions/members/$USER_ID" -H "X-API-Key: $DEV_KEY"
# 400 {"code": "validation-error", "detail": "... has a clone of \"Support assistant\" (\"Support assistant\" (...)): say what happens to it: \"keep\" ..."}
curl -s -X DELETE "$STRONGLY_URL/api/v1/agents/$BASE_ID/permissions/members/$USER_ID?clones=suspend" -H "X-API-Key: $DEV_KEY"
# 204; GET /agents/$BASE_ID/clones shows it with "unsharedAs": "suspend" and "unsharedAt"
developer.agents.remove_member(base_id, user_id, clones="keep") # or "suspend", "delete"
developer.agents.add_member(base_id, user_id=user_id) # it follows the base again
As whom a clone acts
| A clone acts as | For |
|---|---|
| Its user | Its identity, ownership, access checks and attribution; its per-user layer; the base's data sources, which are used as its user and recorded for them; and what it gets of the base's add-ons (see Add-ons: for each clone), never the add-on's own login |
| The app's owner (a clone made through an app only) | The models, tool workflows, workspace and MCP servers an app user cannot hold |
A clone always runs as its user, whoever starts it. When an administrator or the app's owner starts, restarts or redeploys a user's clone, or the base's changes redeploy it, it still runs as its user: its pod's token and its record name them, and the person who acted is named only in the audit log. Who may start, stop or restart a clone: its user, the owner of the app it belongs to, and platform administrators (see Who an agent runs as). The base's owner may not, unless they are also the app's owner.
A clone made by sharing uses its user's own access to everything else the base uses: the base's models, data sources, tool workflows and MCP servers must be ones they may use, and a clone they could not run is refused when they make it (403, naming each). Share those with them first. The base's add-ons are not shared with them: each clone gets a separate space in each add-on, or a new add-on, as you choose below.
Every AI Gateway call a clone makes is recorded for its user and the clone (and its app, for an app's clone).
Add-ons: for each clone
For each add-on the base uses, you (the base's owner, its developer) choose what each clone gets, on the base's Permissions tab under For each clone. The people who clone it never choose or change it.
| For each clone | What each clone gets |
|---|---|
| A separate space in this add-on | One add-on: each clone gets its own isolated database and login in it. Lower cost |
| A new add-on | A new add-on of the same type and size, owned by the clone's user |
A separate space is made when the clone is made and removed, with everything in it, when the clone is deleted. It is isolated by the database's own permissions, not by a convention the agent follows:
| Add-on | A clone's separate space |
|---|---|
| PostgreSQL, DuckDB | A database and a login that owns it; no login of a space can connect to any other database |
| MySQL | A database and a login with every privilege on it only |
| MongoDB | A database and a login with read and write on it only |
| Redis | A login that reaches only keys and channels starting with its prefix (clone_…:), with data commands only (no admin, scripting or commands that list or count every key) |
| Milvus (2.5 and later) | A database and a login whose role manages that database only |
| RabbitMQ | A vhost and a login with permissions on it only |
Neo4j, Greenplum, SurrealDB, Kafka, MQTT and Milvus before 2.5 cannot isolate one clone from another, so they offer A new add-on only. A new add-on is deleted with its clone.
A clone never receives the add-on's own login: its services (STRONGLY_SERVICES) carry its separate space's login, database, key prefix (connection.key_prefix, for Redis) or vhost (connection.vhost, for RabbitMQ), or its new add-on, and nothing else. Code an agent runs reads its add-on the usual way; with Redis it keeps every key under connection.key_prefix.
- Choose before anyone clones it. A base with an add-on not chosen cannot be cloned: the clone is refused (
400, codeclone-addon-mode-required) and the detail names the add-on. - The choice is fixed while a clone holds what it gave (its data is in it): changing it then is refused (
409, codeclone-addon-mode-in-use). - An add-on the base starts using later reaches its clones at their next sync, by the choice you make for it; one the base stops using is removed from every clone, with its data.
# The base's add-ons and what each clone gets of each
curl -s "$STRONGLY_URL/api/v1/agents/$BASE_ID/addons" -H "X-API-Key: $KEY"
# {"data": [{"addonId": "addon-…", "name": "orders-db", "type": "postgres", "cloneAddonMode": null,
# "availableCloneAddonModes": ["separate-space", "new-addon"], "clones": 0}, …]}
# A separate space in this add-on for each clone
curl -s -X PATCH "$STRONGLY_URL/api/v1/agents/$BASE_ID/addons/$ADDON_ID" -H "X-API-Key: $KEY" \
-H "Content-Type: application/json" -d '{"cloneAddonMode": "separate-space"}'
for addon in client.agents.addons(base_id):
print(addon.name, addon.clone_addon_mode, addon.available_clone_addon_modes)
client.agents.set_clone_addon_mode(base_id, addon_id, "separate-space") # or "new-addon"
# On a clone: what it holds (its separate space's name, database or key prefix; never a password)
print([(a.name, a.space) for a in client.agents.addons(clone_id)])
What an agent may do
Every agent has a list of what it may do. Anything that creates or controls platform resources is a feature, and an agent may use only the features it is granted:
| Feature | What it allows |
|---|---|
projects | Create and change projects |
workspaces | Create and control workspaces, code sessions and volumes |
apps | Create and change apps |
addons | Create and change add-ons |
datasources | Create and change data sources |
deployments | Deploy apps, add-ons, streaming workflows and marketplace offerings |
workflows | Create, change and build workflows |
models | Add and change AI Gateway models, fine-tuning, data forge, guardrails, the model registry and MLOps |
jobs | Create and run jobs and compute |
sharing | Share the user's records with other users |
stan | Run STAN, the platform assistant |
A new agent is unrestricted: it is granted every feature and may do whatever you may. To restrict it, turn features off on the agent's Overview tab, under What this agent may do (or PATCH /api/v1/agents/:id/allowed-features with the shorter allowedFeatures list). A restricted agent is offered only the tools of its features, and the platform refuses anything else it tries, from its own runtime or from code it runs in its workspace, at the platform API and at every platform service: 403 with code feature-restricted, naming the feature. A grant or a revoke applies from the agent's next request.
A clone has exactly its base's features: the same list, never more and never less. An app user's clone never adds data sources or add-ons, whatever the base is granted. An agent a user makes through an app (of their own design, not a clone) is granted no feature, and a request your app makes for its user is granted none either: they read, keep the user's own agent and Library records, and run the tool workflows wired into the agent.
An agent for each user of an app
An app can give each of its users their own clone: a per-user assistant that remembers that user, works on their tasks and answers from their documents. It pairs naturally with Branded Sign-in & Sign-up: people sign up on the app's own page, become app users whose home is the app, and never see the Strongly platform.
The base is one of the app owner's own agents. Your app makes each user's clone itself, through the API, when the user first needs it (for example on their first sign-in), forwarding the user's token:
curl -s -X POST "$STRONGLY_API_URL/api/v1/agents/$BASE_ID/clone" \
-H "X-Strongly-User-Token: $USER_TOKEN"
A user who has their clone already gets 409 naming it. The clone is theirs and lives in their own organization (on Strongly Cloud, the app's organization, where a user is bound to the app only if they are an active member of it). It uses the app owner's models, tool workflows, workspace and MCP servers through the app, and reads its base's official layer.
How the app talks to the platform for a user
Every request the platform's proxy sends your app carries the signed-in user in the X-Strongly-User-Token header (see User Identity Headers). When your app calls the user's areas of the API (/api/v1/agents, /api/v1/primitives and /api/v1/library) and forwards that header unchanged, the call acts as that user, through the app, instead of as the app's owner:
| What happens | |
|---|---|
Clone (POST /agents/:id/clone) | The user's clone of the base |
Create (POST /agents) | An agent of your own design for the user (Agent Builder input). It is the user's own and records your app |
| List, read, start, stop | Only the user's agents of this app are visible. Another user's agent answers 404 |
Chat (POST /agents/:agentId/threads/:id/runs) | The conversation is the user's; the agent runs as the user |
| Start, stop, redeploy as the app's owner (no user header) | Allowed for the app's agents. The agent still runs as its user |
| Knowledge, memories, tasks | The user's own records, and the base's to read |
Delete (DELETE /agents/:id) | The user's agent, its tasks and its per-user layer go. The official layer stays |
Every other call your app makes (workflows, models, add-ons) still acts as the app's owner, as an app always does. Your app never sends a key: inside the platform the pod's auth-proxy signs every call to STRONGLY_API_URL in as the app's owner. Your code adds only the user's header.
Who can reach the agent
- App users reach their own agents of their home app, and only through that app's calls for them. They still reach nothing on the platform itself: the dashboard stays closed to them, they hold no API keys, and an API call made any other way reaches nothing.
- Developers and admins who use the app are held to the same rule through it: their own agents of that app and their own records, and only what the base may do. An app they visit can never reach their other agents or anything else of theirs.
Library versions: latest or pinned
An agent reads the latest version of every Library item it uses. A skill's or prompt's version includes its bundled files, so changing only a file is a new version, and a pinned agent reads the files of its pinned version. To hold an item at a version, open the agent's Library versions tab and pick a version for it (or PATCH /api/v1/agents/:agentId/library-references/:id with pinnedVersion). Pins set on a base hold for every clone; a clone has none of its own. A pinned version that no longer exists is an error the agent reports, never a quiet switch to the latest.
Usage and cost
A clone runs as its user, so its model calls and its compute are recorded for the user and the clone (with the app named on each AI Gateway call, for an app's clone). In FinOps, filter or group by user, workload (the clone) or app.
Each clone that is started runs in its own deployment (one pod). An app's clones run on demand unless the base chooses otherwise (the agent's onDemandMode): they sleep while idle, so idle users cost nothing for compute, and wake on the next message, a scheduled task, or when their user signs in or opens the app, so a clone is usually ready by its user's first question. The clones list shows each clone's status (asleep, starting, running, in error) and why a wake at sign-in failed.
When clones are deleted
A clone is deleted, with its tasks, its per-user layer, its separate spaces (their logins and data) and its new add-ons, when:
- its user (or the app, for its user) deletes it (
DELETE /agents/:id); - the user is removed from the app or unbound from it as their home app (an app's clone);
- the user's account is deleted or archived;
- the app is deleted (an app's clone; the base, the owner's own agent, stays).
Walkthrough: share an agent with your team
You built an agent and want colleagues on the platform to each have their own.
- Decide what it may do. A new agent may do everything you may. To limit it, turn features off on the base's Overview tab, under What this agent may do. Every clone has exactly this list.
- Make sure they can use what it uses. A clone made by sharing uses its user's own access, so share the base's model, data sources, tool workflows and MCP servers with each colleague first. If you skip this, their Clone is refused and the message names each resource they cannot use. For each add-on it uses, choose under For each clone on the Permissions tab whether each clone gets A separate space in this add-on or A new add-on.
- Share it to clone. On the base's Permissions tab, add each colleague with Can clone. That role never lets them open, run or change your agent.
- They clone it. On their Agents page, under Shared with you to clone, they click Clone. Their clone opens with "Clone of your agent": your instructions, model, skills, knowledge and settings are shown read-only, and they add their own memories, tasks and knowledge.
- You keep improving the base. Every change you save reaches their clones; the base's Clones list shows each one and whether it is in sync.
With the REST API (each call made as shown; $DEV_KEY is your key, $USER_KEY your colleague's):
# Developer: the base, what it may do, and sharing it to clone
curl -s -X POST "$STRONGLY_URL/api/v1/agents" -H "X-API-Key: $DEV_KEY" -H "Content-Type: application/json" \
-d '{"name": "Support assistant", "personality": "Brief and exact.", "allowedFeatures": ["projects"]}'
curl -s -X POST "$STRONGLY_URL/api/v1/agents/$BASE_ID/permissions/members" -H "X-API-Key: $DEV_KEY" \
-H "Content-Type: application/json" -d "{\"userId\": \"$USER_ID\", \"role\": \"cloner\"}"
# Colleague: find it and clone it
curl -s "$STRONGLY_URL/api/v1/agents/clonable" -H "X-API-Key: $USER_KEY"
curl -s -X POST "$STRONGLY_URL/api/v1/agents/$BASE_ID/clone" -H "X-API-Key: $USER_KEY"
# The official layer is read-only on the clone
curl -s -X PATCH "$STRONGLY_URL/api/v1/agents/$CLONE_ID/config" -H "X-API-Key: $USER_KEY" \
-H "Content-Type: application/json" -d '{"personality": "Chatty."}'
# 403 {"code": "clone-follows-base", "detail": "... is a clone of ...: what its base provides cannot be changed or removed on a clone; change it on the base"}
# Their own records, on their clone
curl -s -X POST "$STRONGLY_URL/api/v1/primitives/memories" -H "X-API-Key: $USER_KEY" -H "Content-Type: application/json" \
-d "{\"kind\": \"semantic\", \"content\": \"Prefers short answers\", \"linkedIds\": [\"$CLONE_ID\"]}"
curl -s -X POST "$STRONGLY_URL/api/v1/library/knowledge-bases" -H "X-API-Key: $USER_KEY" -H "Content-Type: application/json" \
-d "{\"name\": \"My notes\", \"indexModelId\": \"$CHAT_MODEL_ID\", \"cloneId\": \"$CLONE_ID\"}"
The same with the Python SDK, as it ran:
from strongly import PermissionDeniedError, Strongly
developer = Strongly(api_key=DEV_KEY)
colleague = Strongly(api_key=USER_KEY)
base = developer.agents.create(name="Support assistant", personality="Brief and exact.",
allowed_features=["projects"])
developer.agents.add_member(base.id, user_id=colleague_user_id) # Can clone
print([(b.name, b.clone_id) for b in colleague.agents.clonable()]) # [('Support assistant', None)]
clone = colleague.agents.clone(base.id) # owned by the colleague
try:
colleague.agents.update_config(clone.id, personality="Chatty.")
except PermissionDeniedError as e:
print(e.status_code, e.error_code) # 403 clone-follows-base
print([f.name for f in colleague.agents.allowed_features(clone.id) if f.granted]) # ['projects']
developer.agents.update_config(base.id, personality="Brief, exact and friendly.")
config = colleague.agents.config(clone.id)
print(config.base_agent_name, config.config.personality, bool(config.base_synced_at))
# Support assistant Brief, exact and friendly. True
print([(c.owner_email, c.in_sync) for c in developer.agents.clones(base.id)])
# [('colleague@example.com', True)]
Walkthrough: a personal assistant for every user of an app
A clinic offers its patients a portal app with an assistant. Each patient gets their own: it follows the clinic's approved instructions, knowledge and tools, and it remembers that patient, works on their tasks and reads documents they upload, which no other patient can see.
- Build the base (your own agent): its instructions, model, the clinic's knowledge, the tool workflows it calls. Under What this agent may do, turn off what patients' assistants should never do (often everything that creates platform resources). App users never add data sources or add-ons, whatever you grant.
- Build the app and turn on Branded Sign-in & Sign-up, so patients sign up on the portal's own pages and never see the platform.
- In your app's code, make each patient's clone of the base the first time they need it, and forward the request's
X-Strongly-User-Tokenon calls to/api/v1/agents,/api/v1/primitivesand/api/v1/library; each call then acts as that patient through the app.
The app calls below were made from a deployed app's server, forwarding the signed-in user's token (the pod's auth-proxy adds the app's own credentials):
# The patient's clone, made on first use
curl -s -X POST "$STRONGLY_API_URL/api/v1/agents/$BASE_ID/clone" -H "X-Strongly-User-Token: $USER_TOKEN"
# 201: their clone, "ownerId" the patient, "appId" the app, "baseAgentId" the base
# Their own knowledge base, beside the clinic's
curl -s -X POST "$STRONGLY_API_URL/api/v1/library/knowledge-bases" -H "X-Strongly-User-Token: $USER_TOKEN" \
-H "Content-Type: application/json" -d "{\"name\": \"My documents\", \"indexModelId\": \"$CHAT_MODEL_ID\", \"cloneId\": \"$CLONE_ID\"}"
# What the clone may do: the base's grants, never data sources or add-ons
curl -s "$STRONGLY_API_URL/api/v1/agents/$CLONE_ID/allowed-features" -H "X-Strongly-User-Token: $USER_TOKEN"
In Python, inside the app:
from strongly import Strongly
client = Strongly() # inside the app: no key, the auth-proxy signs calls in as the app's owner
BASE_AGENT_ID = "<the base: one of the app owner's own agents>"
def agent_for(request):
"""The signed-in user's clone of the app's agent, started on first use."""
me = client.for_user(request.headers["X-Strongly-User-Token"])
mine = me.agents.list().to_list()
agent = mine[0] if mine else me.agents.clone(BASE_AGENT_ID)
if agent.status != "running":
me.agents.start(agent.id)
return me, agent
def chat(request, message):
me, agent = agent_for(request)
thread = me.agents.create_thread(agent.id, title="Chat")
return "".join(
event["data"]["delta"]["content"]
for event in me.agents.chat(agent.id, thread.id, message)
if event.get("event") == "thread.message.delta"
)
Set what the base may do, who may clone it and a pinned version from your own code (as the base's owner):
client.agents.set_allowed_features(BASE_AGENT_ID, []) # nothing that creates platform resources
client.agents.add_member(BASE_AGENT_ID, user_id=user_id) # a user may clone it themselves
for clone in client.agents.clones(BASE_AGENT_ID):
print(clone.owner_email, clone.status, clone.in_sync, clone.base_sync_error)
client.agents.set_library_version(BASE_AGENT_ID, skill_id, pinned_version=3) # None: read the latest
A token that does not verify, has expired or names a user who no longer exists is refused (401 with the reason); the call is never made as the app's owner instead. Forward the header from the request you are serving; do not store it (it expires after an hour).
Calls your app makes outside those three areas (for example POST /api/v1/data-sources) act as the app's owner, as an app always does: they create the owner's records, never the patient's, and the patient's clone gains nothing from them.
Walkthrough: as a platform user given an agent to clone
- Open Agents. Under Shared with you to clone, each agent shows who shared it.
- Click Clone. If the base uses something you may not use, the message names it; ask the owner to share it with you.
- Your clone opens with "Clone of base". Settings, instructions, model, knowledge and tools from the base are read-only, marked "From base".
- Add your own: memories and tasks as you work, your own knowledge on the Knowledge tab under Your own knowledge, your own skills, rules and prompts.
- Delete your clone at any time; your own records go with it. Clone again later for a fresh one. A clone can't be duplicated, exported or saved as a template (
403 clone-not-copyable): clone the base again instead.
Errors
| Status | Code | When |
|---|---|---|
403 | forbidden | The base is not shared with you to clone, or it uses something you may not use (the detail names each) |
409 | conflict | You already have a clone of that base (agentId names it) |
403 | clone-follows-base | A change to a clone's official layer: change it on the base |
403 | clone-not-copyable | Duplicating, exporting or saving a clone as a template: a clone can't be copied; clone the base again |
403 | feature-restricted | An agent tried something it is not granted (feature names it) |
422 | resource-in-use | Deleting a base that still has clones |
400 | validation-error | An unknown feature, or a role other than cloner when sharing an agent |
400 | validation-error | Stopping sharing a base with a user who has a clone of it without saying what happens to the clone (clones: keep, suspend or delete; the detail names the clone) |
409 | clone-suspended | Starting a clone suspended when its base stopped being shared with its user |
400 | clone-addon-mode-required | Cloning a base with an add-on whose For each clone is not chosen (the detail names it) |
409 | clone-addon-mode-in-use | Changing For each clone of an add-on while a clone holds what the current choice gave it |
400 | validation-error | A separate space in this add-on for an add-on type that cannot isolate one |
403 | clone-follows-base | Choosing For each clone on a clone: its base's owner chooses |
403 | forbidden | Starting, stopping or redeploying a clone you are not the user of, the app's owner of, or a platform administrator |
403 | forbidden | A memory, skill, rule, prompt, artifact or preference linked (linkedIds) to an agent that is not yours: records are linked only to your own agents, so nobody adds to another user's clone or to a base's official layer |
Every refusal is an RFC 9457 problem (application/problem+json) with type, title, status, detail and code.
API and SDK reference
- REST: Agents API:
GET /agents/clonable,POST /agents/:id/clone,GET /agents/:id/clones,POST /agents/:id/sync,GETandPATCH /agents/:id/allowed-features,GET /agents/:id/permissions,POST /agents/:id/permissions/members,DELETE /agents/:agentId/permissions/members/:userId(clones),GET /agents/:id/config(base and sync state),GET /agents/:id/library-references(fromBase), andGET /agents/:id/addonsandPATCH /agents/:agentId/addons/:id(cloneAddonMode). - Python SDK: Agents:
agents.clonable,clone,clones,sync,allowed_features,set_allowed_features,permissions,add_member,remove_member,config,library_references,addons,set_clone_addon_mode, andclient.for_user(token)for apps.