scoping
/scoping
Use when a user asks what an agent key can do, how Shuriken permissions work, or which scopes they need for a given integration.
- Author
- shurikentrade ↗
- Repository
- shuriken-skills ↗
- Licence
- MIT
- Last repository change
- 11.05.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 2
No signals detected. Repository changed on 11.05.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Use when a user asks what an agent key can do, how Shuriken permissions work, or which scopes they need for a given integration.
Original author description
Use when a user asks what an agent key can do, how Shuriken permissions work, or which scopes they need for a given integration.
How it works
- Best practice: grant the minimum scopes the agent key actually needs
- Principles
- Scope categories
- Common scope combinations
- When a call fails on scope
- Pointers
SKILL.md preview
--- name: scoping description: Use when a user asks what an agent key can do, how Shuriken permissions work, or which scopes they need for a given integration. --- # Scoping an agent key Every agent key carries a set of scopes. A scope is a capability grant — read tokens, execute trades, read positions, deliver notifications. The server enforces scopes on every tool call and API endpoint; a call outside the granted scope fails with a structured authorization error. ## Best practice: grant the minimum scopes the agent key actually needs This is the single most important rule for agent-key scoping. For every agent key, grant **only** the scopes the integration actively uses — nothing speculative, nothing "just in case," nothing broader than the job requires. Concretely: - Start from what the integration does on its hot path, and enumerate only those capabilities. - When in doubt, grant less and widen later if the integration errors on a missing scope. - Create a separate agent key per integration (or per purpose) rather than one fat key reused everywhere — that way each key's scope surface stays tight. - If a scope is required for a one-off setup step but not for steady-state operation, consider doing the setup with a broader key and then running with a narrower one. Broader scopes are a liability: a leaked key is only as dangerous as the capabilities it carries. ## Principles - **Separate read from write.** Read scopes are generally safe; write/execute scopes move money or send messages and deserve more scrutiny. - **Per-integration, not per-user-role.** A scope is a capability, not a persona. Reason about what the integration *does*, not who the user is. ## Scope categories Authoritative scope names live in the docs; these are the categories to reason about: - **Read scopes** — querying token info, positions, wallet balances, alpha signals. Safe for analytics and display use cases. - **Trading scopes** — planning trades, executing trades, cancelling orders. Required for any integration that moves funds. - **Delivery scopes** — sending notifications (Telegram, email) on behalf of the user. Rate-limited. - **Administrative scopes** — managing the user's agent keys themselves, linked wallets, etc. Typically not needed by third-party integrations. Fetch `https://docs.shuriken.trade/llms.txt` for the current authoritative scope list and the exact names to pass when minting a key. ## Common scope combinations - *Read-only analytics dashboard*: read scopes only. - *Automated trading bot*: read scopes + trading scopes. - *Notification/alert service*: read scopes + delivery scopes. - *Full-service trading + notifications*: read scopes + trading scopes + delivery scopes. ## When a call fails on scope The error response names the missing scope. Two valid responses: 1. If the scope is genuinely needed, guide the user to rotate the key with the added scope. 2. If the scope should not be needed (the call is read-only but erroring on a write scope), something in the integration is calling the wrong endpoint — investigate before granting. ## Pointers - Platform documentation (including scope reference): fetch `https://docs.shuriken.trade/llms.txt` and search for "scopes" - Related skills: `shuriken:agent-keys`, `shuriken:api-integration`
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · shurikentrade/shuriken-skills | 90 | MIT |
| milansolutionsai-ops/claude-code-scoping-kit | 90 | MIT |
| thkt/dotclaude | 90 | MIT |
Database snapshot: 13.11.2026 · package version a0bf9d685879 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 90learn-about-shuriken
Use when a user asks conceptual questions about Shuriken — what it does, what features exist, how a feature works, or "what is X on Shuriken?" Does not cover programmatic integration (that's `shuriken:api-integration`). - 90agent-keys
Use when a user asks how to authenticate as an agent, create or rotate API credentials, or understand the lifecycle of agent keys on Shuriken. - 90consent-and-scoping
Enforce granular OAuth scopes and explicit user consent in MCP servers. Use when designing, building, or reviewing MCP server permission models, scope definitions, or consent flows. - 100klaviyo-enterprise-rbac
Configure Klaviyo enterprise access control with API key scopes and OAuth. Use when implementing per-key scoping, configuring OAuth app authorization, or setting up organization-level access controls for Klaviyo. Trigger with phrases like "klaviyo scopes", "klaviyo RBAC",… - 100deepgram-enterprise-rbac
Configure enterprise role-based access control for Deepgram integrations. Use when implementing team permissions, managing API key scopes, or setting up organization-level access controls. Trigger: "deepgram RBAC", "deepgram permissions", "deepgram access control", "deepgram… - 90agent-tool-permission-review
Review AI agent and copilot tool permissions for excessive agency (OWASP LLM06:2025) — tool inventory, identity used for each tool call (user-delegated vs. service), scopes, side effects, human-in-the-loop approvals, sandboxing of code execution, rate limits, and audit logging.…