SkillAgentSearch skills...

scenario-team-admin

Use when administering a Scenario team from an agent through MCP: restricting which models a team or project can run (model access control, allowlist, blocklist), inviting or removing team and project members, changing roles, capping a member's Creative Unit spend, creating or deleting projects, aud…

Install / Use

npx skills add scenario-labs/skills --skill scenario-team-admin

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

86/100

Supported Platforms

Universal

Our assessment of scenario-team-admin

scenario-team-admin scores 86/100 on our quality scale, 2445th of 4,698 Development & Engineering skills we index.

Its SKILL.md is 15 KB long, well organised into 10 sections and no code examples: a thorough specification that gives an agent plenty to work with.

With 1,048 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
30/30
Structure
13/20
Description
15/15
Adoption
13/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 29 days ago, so scenario-team-admin is actively maintained.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-11-10. Automated pattern scan on 2026-11-10. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

scenario-team-admin compared with similar skills

All 4 of these similar skills score higher than scenario-team-admin; compare them before choosing.

SkillScoreStarsUpdatedFormat
scenario-team-admin (this skill)by scenario-labs861.0k29d agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
Agent-Reachby Panniantong100112.3k8d agoCLAUDE.md
rufloby ruvnet10081.9ktodayCLAUDE.md
headroomby headroomlabs-ai10079.8ktodayCLAUDE.md

Frequently asked questions

How do I install scenario-team-admin?
Run npx skills add scenario-labs/skills --skill scenario-team-admin. The install tabs above show the steps for each supported agent.
Which AI agents does scenario-team-admin work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is scenario-team-admin safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is scenario-team-admin still maintained?
The repository was last updated 29 days ago, so scenario-team-admin is actively maintained.

name: scenario-team-admin description: "Use when administering a Scenario team from an agent through MCP: restricting which models a team or project can run (model access control, allowlist, blocklist), inviting or removing team and project members, changing roles, capping a member's Creative Unit spend, creating or deleting projects, auditing API keys and their roles or scopes, or attributing consumption per user or model. Keywords: governance, model control, consumption cap, spend limit, API key hygiene, team admin, enterprise." license: MIT

Scenario Team Administration

Overview

Enterprise teams govern Scenario from the same agent that generates on it: which models anyone may run, who is on the team and in which projects, how much each member may spend, and which API keys exist with which roles. Every tool here is catalog-only: scenario_tools_search returns the schema and lane, and scenario_tool_execute_read / write / delete runs it with {name, parameters}, scope ids inside parameters (see the scenario skill). Two facts decide most failures before any argument does: the identity behind the call, since team-level writes need a human team admin over OAuth and refuse API keys, and the list mode the team runs, since the same model-access edit means the opposite thing in blocklist and allowlist mode. teams_list already tells you both: each team row carries modelsManagement, its model lists, plan, and context.userRole. A credential that reaches one team and one project has its scope; more than one is a stop-and-list, per the scenario skill. If a sibling skill named here is missing from your available skills, load it with skill_get (Scenario MCP) or ask the user to install it (https://github.com/scenario-labs/skills#install); unattended, proceed from tool schemas and flag the gap.

Quick reference

| Task | Tool | Lane | Notes | | -------------------- | ------------------------------------------------------------------- | -------------------------- | ------------------------------------------------------------------------------------ | | Read model access | model_access_get | read | Mode plus the team's active list; project_id adds that project's list alongside it | | Change model access | model_access_update | write | level team or project; exactly one of add_models, remove_models | | Team roster | team_members_list | read | Members and pending invitations | | Invite | team_members_add | write | 1 to 32 emails, role, optional project_ids joined on acceptance | | Roles and spend caps | team_members_update | write | member_ids 1 to 32; role and/or max_consumption | | Remove from the team | team_members_remove | delete | Also withdraws invitations; access ends immediately | | Project roster | project_members_list, _add, _update, _remove | read, write, delete | Roles admin (Owner), editor (Contributor), reader (Viewer) | | API keys | api_keys_list, api_key_get, api_key_update, api_key_delete | read, write, delete | Project scope; api_key_create returns the portal link and nothing else | | Projects | project_get, project_create, project_update, project_delete | read, write, write, delete | Create needs a team admin over OAuth and counts against the plan's project limit | | Who spent what | usage | read (default tools) | Per-user and per-model consumption in the default response |

Model access: read the mode before editing

model_access_get returns models_management and only the mode's active list; the inactive stored list is never surfaced. In blocklist mode (the default) every catalog model is available except those on the team or project blocklist, and the two lists block as a union. In allowlist mode a model is available only when it sits on both the team and the project allowlist; a project with an empty allowlist denies every model, and a project with no allowlist configured falls back to the team list.

model_access_update edits whichever list the mode makes active, so add_models blocks in blocklist mode and allows in allowlist mode: read the mode first, every time. Switching the mode is not available through MCP; it lives in the web app's team settings, so locking a team down to an approved set starts with the user flipping to allowlist there. Unattended, that switch is a stop-and-report: log that the lock waits on it and the exact calls that follow, and take the blocklist-safe partial (blocking the named unwanted models at project level), saying that other projects stay open. Narrowing a list the credential can edit is in scope when the task states the target set: remove_models runs after the adds succeed, so the list never ends empty. level: "team" needs a team admin over OAuth, and the server refuses API keys on that endpoint. level: "project" takes the projects to edit in projects (1 to 200) and needs the admin role on every one of them: one unauthorized project fails the whole request and nothing updates, and a single-project key can only edit its own project's list. project_id on the call is tenant context for OAuth sessions, never the target. In allowlist mode a project admin can add only models already on the team allowlist (a project list narrows the catalog, never widens it), removing a base model from a team allowlist cascade-removes the trained models built on it, and a team-level add validates every id, one unknown id failing the whole call. updated: false means the diff was a no-op, not an error. A blocked model disappears from what members can run, and the error a member sees when running one anyway is a restriction, not moderation (see scenario-moderation).

Members and spend caps

team_members_update takes member_ids from team_members_list and sets role (admin or member), max_consumption, or both. The cap is in Creative Units over the current billing period: a value of zero or more caps, -1 is unlimited, and null clears the per-member override so the team-wide default applies. Roles can be set by a team admin over OAuth or a team-scoped API key with the team.members.manage scope; caps need a real team admin, and a key that tries is refused per member. Demoting the last admin fails server-side. The bulk member tools process one row at a time and report an outcome per member; a response with status: "partial" is finished by calling again with its remaining list.

team_members_add invites 1 to 32 emails at role (default member) and joins them to project_ids on acceptance; outcomes are invited, failed, or skipped with the reason (already a member, already invited, seat limit reached). project_id on the call grants nothing. Like role changes, inviting takes a team admin over OAuth or a team-scoped key with team.members.manage; a project-scoped key gets a permission error. A pending invitation carries no member id, so its cap waits for acceptance. project_members_add takes people already on the team, as user ids or emails (emails need team_id to resolve), with a required project role.

Removal is the delete lane and immediate: team_members_remove ends the person's access everywhere and withdraws pending invitations, project_members_remove leaves team membership and other projects untouched. List first, confirm the exact names with the user, then remove; unattended, remove only the members the task instructions name.

API keys

api_keys_list and api_key_get are project-scoped and return each key's id, api_key_id, name, status, scope, role, projects, and creation date, plus a manage_keys_url; team-scoped keys are not attached to projects and never appear here, only in the portal. api_key_update changes a key's role to admin, editor, reader, or a custom ;-separated scope list (the reference's example is assets.read;models.run); name, status, and usage limits are portal-only, and a limit takes an Enterprise plan and a human admin. Creation is deliberately not an MCP operation: api_key_create returns the portal link, the secret is shown once there, and it never passes through the conversation (the scenario skill's rule on secrets holds here). api_key_delete takes the key as key_id (either the id or the api_key_id from the listing), cannot be undone, needs a project admin, and refuses the key the current session is authenticated with: list, confirm the exact key with the user, then delete; unattended, delete only a key the task instructions name and exactly one key matches.

Projects

projects_list (default toolset) finds what exists; create only when nothing matches. project_create takes team_id, name, and privacy_mode; a description needs a follow-up project_update. It needs a human team admin over OAuth (API keys are refused) and counts against the plan's project limit, which refuses the call once reached: report the limit, never delete a project to make room. Pass the returned project.id as project_id from then on. In a team with no projects, the API first creates a default project, which stays even when the call is refused: check projects_list afterwards and offer to rename it with project_update rather than keep two (unattended: report it, change nothing).

  • Privacy. privacy_mode: true, on project_create or project_update, limits non-admin members to the assets and models they created; project and team admins still see everything. Turning it off shows every member everything: confirm with the user first; unattended, only when the task instructions say so.
  • Rename. project_update changes only the fields passed: name, description (up to 2,000 characters), privacy_mode, avatar_asset_id. Access, model lists, and credit caps live in the tools above or the web app.
  • Delete. project_delete runs on the delete lane, is irreversible, and takes the project's models, generation records, API keys, and memory with it. Confirm the name and id from project_get first. It takes the target as project_id, and is refused while anyone but the caller holds a role on the project or a key is attached: report who remains and ask, and never remove a member or delete a key to unblock it without a separate confirmation of each. The creator joins as Admin by default (auto_join), which blocks a delete by anyone else. Unattended, delete only a project the task instructions name, when exactly one matches, and report a refusal and stop.

Who spent what

usage is in the default toolset and returns a summary by default: headline CU totals, per-user consumption, per-model CU and job counts sorted descending, and per-asset-kind counts, bounded by start_date and end_date (ISO dates); project_id filters the figures, so a single-project credential ranks spend inside that project, not across the team. An undated call returns project-lifetime figures, so always pass the range: totals and the per-user consumption rows (userId, total) fo

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars1.0k
CategoryDevelopment
Updated29d ago
Forks129

Languages

Python

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions