Unblocked
Server Details
Unblocked is the context layer for agentic software development.
- Status
- Healthy
- Uptime
- 51.7% over 39 days
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- Repository
- unblocked/skills
- GitHub Stars
- 14
TDQS
Scored across 3 tools
Each tool has a distinct, clearly stated purpose: rules retrieval, URL hydration, and broad research. Descriptions explicitly guide when to use context_get_urls versus context_research, and context_get_rules is unambiguous.
All tools share the context_ prefix and use snake_case, but two follow a get_noun pattern while the third uses a bare verb (research), a minor inconsistency.
Three tools is well-scoped for a context-retrieval server; each covers a distinct capability without redundancy, and the powerful research tool composes many underlying operations.
The surface covers rules, URL hydration, and broad research across sources. There are minor gaps (e.g., no dedicated direct code search or file-by-path tool), but workarounds exist via context_research.
Available Tools
3 toolscontext_get_rulesARead-onlyInspect
Retrieve repository coding rules and conventions. Returns all rules for a repository, or a specific rule by ID. Rules are extracted from CLAUDE.md, AGENTS.md, .cursorrules, CONTRIBUTING.md, and other convention files in the repository.
| Name | Required | Description | Default |
|---|---|---|---|
| task | No | Optional task filter: code-review, code-generation, or code-questions | |
| paths | No | Optional repo-relative file paths to scope rules to, one per line. A rule extracted from <dir>/CLAUDE.md (or similar) is returned only when at least one path is inside <dir>/. Rules from repo-root convention files always apply. Pass the files being reviewed, generated, or asked about. Omit for repo-wide. | |
| rule_id | No | Optional rule ID to retrieve a specific rule | |
| language | No | Optional language filter (e.g., 'kotlin', 'python', 'typescript') | |
| repo_name | Yes | Repository to retrieve rules for. Use 'owner/repo' form (e.g. 'unblocked/unblocked'). |
Output Schema
| Name | Required | Description |
|---|---|---|
| text | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds useful behavioral context about extraction sources (CLAUDE.md, AGENTS.md, etc.) and the all-or-specific return behavior, but it does not disclose edge cases such as empty results or behavior when no rule matches.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences with no filler. It front-loads the core purpose, then explains return modes and sources, making every sentence useful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The presence of a full input schema, output schema, and safety annotations covers much of the operational detail. The description provides the source context and return modes, making the tool sufficiently complete for an agent to select and invoke it, though it could explicitly differentiate from sibling retrieval tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal semantic value, only loosely echoing the 'specific rule by ID' concept already present in the rule_id parameter description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Retrieve') and a distinct resource ('repository coding rules and conventions'), and clearly distinguishes this tool from sibling tools like context_get_urls by focusing on rules extracted from convention files. It also specifies the two main modes: all rules or a specific rule by ID.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description makes it clear the tool is for retrieving repository coding rules and conventions, and the parameter details explain optional filters and path scoping. It does not explicitly name alternatives or state when not to use this tool, but the intended context is strongly implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
context_get_urlsARead-onlyInspect
Retrieve and hydrate content from supported URLs. Provide one URL per line. Supports the following URL patterns: - GitHub on github.com: PRs, issues, and file blobs such as https://github.com///pull/, https://github.com///issues/, and https://github.com///blob//.
Notion on app.notion.com: pages such as https://app.notion.com//, https://app.notion.com/, and https://app.notion.com/p/.
Notion on notion.com: pages such as https://notion.com//, https://notion.com/, and https://notion.com/p/.
Notion on notion.so: pages such as https://notion.so//, https://notion.so/, and https://notion.so/p/.
Unblocked on docs.getunblocked.com: documents such as https://docs.getunblocked.com/.
| Name | Required | Description | Default |
|---|---|---|---|
| urls | Yes | URLs to resolve and hydrate content from, one per line. | |
| verbose | No | Set to 'true' to include additional details like PR diffs and Jira comments regardless of URL count |
Output Schema
| Name | Required | Description |
|---|---|---|
| text | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds the 'hydrate' behavior (fetching and enriching content) and the verbose parameter's effect (including PR diffs and Jira comments). It doesn't mention rate limits or failure modes, but the annotations cover the safety profile.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear opening sentence and a bulleted list of supported URL patterns. It's a bit long but every sentence earns its place by providing specific URL examples. The front-loaded purpose statement helps the agent quickly understand the tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is complete for a read-only URL hydration tool. It covers supported URL patterns, input format, and the verbose option. The output schema exists, so return values are documented elsewhere. It could mention what happens with unsupported URLs, but that's a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters. The description adds the 'one per line' format for urls and the verbose parameter's effect (PR diffs, Jira comments), which is useful. However, it doesn't add much beyond what the schema already says, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Retrieve and hydrate content from supported URLs.' It specifies the exact URL patterns supported (GitHub, Notion, Unblocked) and the input format (one URL per line). This distinguishes it from siblings like context_get_rules and context_research, which are about rules and research respectively.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context: it lists supported URL patterns and the input format. It doesn't explicitly state when to use this tool vs alternatives, but the supported URL patterns and the sibling names (context_get_rules, context_research) make the use case clear. It could be improved by explicitly saying 'use this for URL content, not for rules or research.'
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
context_researchARead-onlyInspect
Retrieve institutional context that code search cannot provide — WHY, WHO, WHEN behind the code. Primary Unblocked research tool; reach for it first for synthesis across sources.
One call searches every indexed source: documentation, PRs, messaging (Slack/Teams), issues (Jira/Linear/GitHub), customer support tickets (Zendesk), code (semantic search + file reads), code history, incidents, public web, internal URLs. Composes semantic search, code search, file reads, PR/issue queries, messaging search, and incident lookups.
When to call
Call proactively at the start of any non-trivial task, and whenever you hit an unknown. Do not wait for the user to ask.
Planning, investigation, refactor, migration, or feature work. Fire in the same tool block as your first Explore/Grep/Read calls — complementary, zero latency cost.
"Why does this exist" or "why is it done this way" questions. Code reading cannot answer these.
Behavior doesn't match the code. Check history before assuming the code is wrong.
Unfamiliar class, service, endpoint, flag, config key, or error string while reading or editing.
Before writing new code. Check whether the pattern, bug, fix, helper, or abstraction already exists.
Incident, alert, or outage. Connect affected systems to recent changes and prior fix patterns.
Filtered activity lookups. "PRs merged last week in auth service", "open incidents tagged ingestion", "Jira epics in PROJ from Q1".
Ambiguous user requests. Find the team's prior framing before guessing.
Before recommending a solution. Verify the approach hasn't been tried, rejected, or superseded.
When NOT to call
Known URL in hand. Use
context_get_urls— faster, deterministic, returns full hydrated content. Fall back here only if the URL pattern is unsupported.
If unsure, call. Missed context is expensive; recall misses are cheap.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | What to search for — the topic, entities, urls, and any hard filters (date range, author, status) that constrain which documents match. Write a complete phrase rather than bare keywords — "How does the authentication service handle token refresh?" not "auth token refresh". | |
| effort | No | Search effort: low, medium, or high. Use "low" by default — it's the fastest and cheapest, and sufficient for targeted lookups that point at a specific entity, URL, file, or question. Use "medium" for simple research tasks, or when the query does not translate cleanly to a single entity or URL and some exploration is needed. Use "high" for broad or cross-system investigations — highly recommended during planning tasks, where wider coverage reduces the risk of missing prior work, rejected approaches, or related constraints. | |
| instruction | No | How to evaluate the matches — relevance criteria, domain priorities, or selection guidance that shapes which results surface and in what order, without changing what is searched. E.g., "Prefer architecture decision records over API reference docs". |
Output Schema
| Name | Required | Description |
|---|---|---|
| text | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (readOnlyHint, openWorldHint, destructiveHint), the description discloses that a single call searches all indexed sources and composes multiple search and lookup mechanisms. It also communicates behavioral tradeoffs such as zero latency cost, 'missed context is expensive; recall misses are cheap,' and proactive use expectations. Nothing about its behavior would surprise an agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is long but every section earns its place: purpose is front-loaded, usage guidance is organized into scannable bullets, and examples are concrete. The structure makes the length appropriate for the tool's complexity rather than bloated.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's broad scope, the description covers purpose, use cases, exclusions, source coverage, effort guidance, and fallback behavior. An output schema exists for return values, and parameters are fully documented in the schema, so nothing critical is left undocumented.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already thoroughly documents query, effort, and instruction. The main description adds no additional parameter-level meaning beyond what the schema provides, which meets the baseline but does not exceed it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states this tool retrieves institutional context (WHY, WHO, WHEN) that code search cannot provide, and identifies itself as the primary research tool. It also distinguishes itself from context_get_urls by noting that tool is faster for known URLs. No ambiguity about what the tool does or how it differs from siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides an extensive 'When to call' list covering concrete scenarios like planning, unfamiliar code, behavior mismatches, incidents, and ambiguous requests. It also gives an explicit 'When NOT to call' rule with the alternative tool (context_get_urls) and ends with a clear decision policy: 'If unsure, call.' This is exemplary routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
- First observed
context_get_rules - First observed
context_get_urls - First observed
context_research
Related MCP Connectors
UNBLOCK org-brain — shared memory and comms for human + agent teams. By Kaeva Labs.
The AI orchestration agent for modern software teams.
Intelligent context infrastructure for AI teams: knowledge graph, sessions, tasks, documents.
Your team's shipping standards, org map and delivery metrics, inside your coding agent.
Related MCP Servers
- AlicenseAqualityAmaintenanceYour agents, briefed. Not flooded. Self-hosted context compiler: git-backed team knowledge served to coding agents as token-budgeted bundles over MCP.4730Apache 2.0
- FlicenseNot gradedqualityBmaintenanceBuild, ship and think in one living agentic workspace10-
- AlicenseNot gradedqualityCmaintenanceA unified context layer that connects your local data — repositories, documents, remote machines, and notes — to LLM interfaces through the Model Context Protocol (MCP).3MIT
- FlicenseNot gradedqualityDmaintenanceTransforms AI coding assistants into context-aware developers by auto-detecting project context, remembering conversations, and executing commands safely with a multi-layer security model.-
Glama MCP Gateway
Add one secure layer between your agents and this server.