StateLode
Server Details
Shared task layer for AI coding agents. One MCP surface: task_search, task_get, task_mutate.
- Status
- Healthy
- Uptime
- 3.8% over 82 days
- OAuth
- Works in Glama
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- Repository
- Statelode/statelode-bridge
- GitHub Stars
- 0
- ChatGPT
- –
- Claude
- –
TDQS
Scored across 3 tools
With only three tools the read/write split is clear: task_search for lightweight discovery, task_get for a full record, task_mutate for any write. However, task_mutate's boundary is fuzzy—it also creates projects, manages sprints, publishes project policy, and negotiates cross-squad requests, so an agent looking to 'create a squad request' or 'complete a sprint' may not think to reach for a tool named task_mutate.
All three tools follow the identical noun_verb snake_case convention (task_get, task_search, task_mutate), which is predictable and readable. There is no mixing of casing or verb styles anywhere in the surface.
Three tools is a defensible minimal surface for a task system, but the domain here spans tasks, sprints, projects, policy versioning, and inter-squad requests—all funneled into a single 12-action task_mutate. That much consolidation forces agents to parse a very long action/payload spec before any write, where a small number of focused write tools would be safer.
Coverage is broad: create/read/update/move/block/comment on tasks, full sprint lifecycle, policy publishing, and request create/respond, with optimistic locking throughout. The main gap is that there is no delete or archive operation for tasks (only status/category changes) and no way to fetch or list sprints or projects directly—agents must infer them through task_search.
Available Tools
3 toolstask_getARead-onlyInspect
Fetch one task in full, including description, acceptanceCriteria, notes, blocker, dependencies, and updatedAt. For multi-workspace OAuth connections, pass workspaceId from statelode://workspace to target a non-default workspace; ungranted ids are rejected. The returned updatedAt is REQUIRED for any subsequent task_mutate on this task (optimistic lock).
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | ||
| workspaceId | No | A workspace id from statelode://workspace. Explicit input overrides every default. For repository work, pass the workspaceId pinned in statelode.json. Project-creating mutations require this when a multi-workspace grant has no human-selected default. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only declare this is a safe, closed read. The description adds behavior an agent could not infer: ungranted workspace ids are rejected, and the returned updatedAt is a mandatory optimistic-lock token for later task_mutate calls. That is exactly the cross-tool constraint that prevents failed writes.
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?
Three tightly packed sentences: what it returns first, then the workspace targeting rule, then the lock requirement. No filler and the most consequential constraint is not buried.
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?
There is no output schema, so the enumeration of returned fields carries real weight, and the optimistic-lock dependency is stated. For a two-parameter read tool, nothing an agent needs in order to call it correctly and reuse its result is missing.
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 coverage is 50%, with workspaceId documented in the schema and id undocumented. The description compensates by explaining when and why workspaceId is needed, though it partly restates the schema's own workspaceId text and never explicitly defines id as the task identifier.
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?
States a specific verb and resource ('Fetch one task in full') and immediately enumerates the returned fields, which distinguishes it from task_search (listing) and task_mutate (writing). An agent can tell what this tool is for and what it returns without opening a schema.
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?
Gives a clear usage rule for workspaceId ('pass workspaceId from statelode://workspace to target a non-default workspace') and a hard prerequisite for calling task_mutate afterwards. It does not explicitly route discovery-style needs to task_search, so 4 rather than 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
task_mutateAInspect
Mutate a task or sprint. Input is { action, payload, workspaceId? }; payload fields depend on action. Actions (→ marks required payload fields; the rest are optional). dueAt is ISO-8601, e.g. 2026-09-20T17:00:00Z:
create → projectId, title; optional: description, priority, status, owner, worker, assignee, tags[], acceptanceCriteria[], dueAt. A new projectId is created by this call (see Projects).
update → id, updatedAt; optional: title, description, priority, worker (your agent name claims the work; null releases it), owner (member email = the responsible human; null clears), assignee (legacy), tags[], acceptanceCriteria[], dependsOn[] (task ids; replaces, [] clears), dueAt (null clears it).
move → id, updatedAt, status (a key from task_search workflow.statuses, or a category).
comment → id, note; optional: notify=true for a meaningful agent progress update. Routine comments do not notify.
block → id, updatedAt, reason (sets status=blocked).
sprint_create → name and projectId; or scope:"workspace" (+ optional projectIds[], default every project) for a cross-project sprint; optional: goal. A new projectId is created too (see Projects).
sprint_assign → id, updatedAt, sprintId (sprintId=null removes the task from its sprint).
sprint_activate → sprintId (one active sprint per project, plus one workspace sprint).
sprint_complete → sprintId (closes it).
project_policy_update → projectId, expectedVersion, content, changeSummary (publishes a new policy version; requires projects:write). Projects: there is no project_create action and none is needed — create and sprint_create auto-create the project when given a projectId this workspace lacks, echoing projectCreated: true. A statelode.json slug missing from statelode://workspace is a forward declaration, not an error: just create the task, and never ask a human to pre-create it in the dashboard. (Only task_search rejects an unknown projectId; reads must not mint projects.) If implicit creation returns project_workspace_collision, this slug already exists in another readable granted workspace. No write occurred. Resolve the intended project with the human and persist workspaceId in the repository pin; do not blindly retry using the default workspace. An explicit workspaceId permits intentionally separate projects with the same slug. Project creation workspace precedence: explicitly named workspaceId, then the repository-pinned workspaceId in statelode.json, then the human-selected default from statelode://workspace. One accessible workspace needs no prompt. If multiple workspaces have no explicit or pinned/default signal, ASK the human and retry with workspaceId; the server rejects silent guesses. Before create/sprint_create, state the selected workspace and offer a quick switch. Explicit input always overrides defaults. Ungranted ids are rejected. Attribution comes from the bearer token. Scheduling: dueAt is the only forward-looking field — createdAt/updatedAt both record the past. An unscheduled task is not the same as one due now, so set dueAt only when a real deadline exists. Enums: priority = urgent|high|medium|low. status = a workflow key from task_search workflow.statuses[].key (projects define their own columns; keys are stable, names are labels and are rejected) or a category backlog|active|in_progress|review|done|archive|blocked, which lands in that category's first column. Owner and worker are separate: owner is the responsible human (a member email from statelode://workspace), worker is the agent doing the work. Claiming sets worker and never replaces the owner; an unowned task you claim or create is owned by your human supervisor. Legacy assignee still works: a member email/name sets owner, any other string (for example "codex") sets worker. Optimistic locks: update/move/block/sprint_assign require the task's last-seen updatedAt; on mismatch STALE_WRITE carries the fresh task. project_policy_update requires the last-seen expectedVersion; on mismatch STALE_PROJECT_POLICY carries the fresh policy. Sprints and project policy are managed through this existing tool, never extra tools. Responsibility guidance: Team lead, Contributor, and Observer describe how an agent should collaborate on behalf of its human supervisor; they do not authorize or forbid actions. The credential scopes returned in delegation.capabilities are the permission boundary. Any Delegate with the required scope may search, update, create, assign, review, manage sprints, or publish policy. Planning: represent a plan as a sprint goal plus concrete tasks. Call sprint_create, create each task with a human member email from statelode://workspace, then sprint_assign each task. There is no separate plan tool. Squads (only where the workspace uses them; repeated in the server instructions): a write in another squad's lane returns SQUAD_BOUNDARY (or, in advisory mode, a warning) carrying suggestedRequest — send it unchanged as request_create and let that squad decide.
request_create → toSquad (slug), projectId, title; optional: description, acceptanceCriteria[], priority, neededBy, blockingTaskId (your task that waits: accepting wires the dependency, and finishing the work unblocks it).
request_respond → id, decision: accept | decline | needs_info (the receiving squad's leads) or answer | cancel (the requester); note is required to decline, ask or answer; on accept, optional owner, priority, dueAt. task_search with requests:"incoming"|"outgoing" lists requests instead of tasks.
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | ||
| payload | Yes | Action-specific fields — see the tool description for each action's required/optional payload. | |
| workspaceId | No | Granted workspace id. Explicit input overrides the repo pin/default. Required for project creation when a multi-workspace grant has no human-selected default. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Goes far beyond the annotations, which only declare readOnly=false, destructive=false, idempotent=false. It documents optimistic-lock contract (updatedAt/expectedVersion, STALE_WRITE/STALE_PROJECT_POLICY carrying fresh state), null-clears semantics (dependsOn [], dueAt null, worker/owner null), project auto-creation and projectCreated:true, project_workspace_collision with no-write guarantee, SQUAD_BOUNDARY with suggestedRequest, and that attribution comes from the bearer token. No claim conflicts with destructiveHint=false since clearing is disclosed as explicit null input.
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?
Front-loaded with the { action, payload, workspaceId } shape and a bulleted action table where every bullet earns its place. It is still very long, and the Responsibility guidance paragraph (Team lead/Contributor/Observer) plus the self-referential note that squads are 'repeated in the server instructions' dilute focus without adding invocation value.
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?
No output schema exists, yet the description supplies the return signal an agent needs: projectCreated, STALE_WRITE/STALE_PROJECT_POLICY error payloads, project_workspace_collision meaning, and suggestedRequest. For a 12-action, nested-payload mutation tool spanning tasks, sprints, policy and squad requests, little is missing.
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 coverage is only 67% and the payload is a freeform additionalProperties object with a single pointer back to the description, so the description carries the full burden — and it does, enumerating required vs optional payload fields for all twelve actions. It also disambiguates owner vs worker vs legacy assignee and constrains status to workflow keys or categories.
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?
A specific verb (
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?
Explicit per-action routing plus negative guidance: no project_create exists, no separate plan tool, task_search with requests:"incoming"|"outgoing" is named as the read counterpart for squad requests. Workspace precedence rules spell out exactly when to ask the human versus proceed, which is real when-to-use guidance rather than inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
task_searchARead-onlyInspect
Search tasks in a project (lightweight summaries). Always pass projectId. Every successful response includes delegation (your human supervisor, advisory responsibility role, and credential-authorized capabilities) plus projectPolicy; follow both. Responsibility roles never filter results. For multi-workspace OAuth connections, pass workspaceId from statelode://workspace to target a non-default workspace; ungranted ids are rejected. Never guess a projectId: searching never creates anything, and an unknown projectId returns an unknown_project error listing the selected workspace's real slugs (knownProjects) — pick one of those and retry. Every response also includes workflow: this project's statuses as { key, name, category, hidden } — projects define their own columns, so use a key (stable) or a category for status, never a display name. With NO status, results are limited to 'active' tasks only — so an empty result does NOT prove a task is absent; pass an explicit status (or an array, e.g. backlog+active+in_progress+review+done+blocked) before concluding nothing matches. Default limit is 10 (max 50). The response echoes appliedStatus and appliedLimit, and sets hasMore:true when the limit truncated the results. Optional sprint filter: a sprint id, 'active' (the project's active sprint), or 'none' (unsprinted). Use this FIRST; only call task_get when you need a full body.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| owner | No | ||
| query | No | ||
| sprint | No | ||
| status | No | ||
| worker | No | ||
| assignee | No | ||
| priority | No | ||
| requests | No | ||
| projectId | Yes | ||
| workspaceId | No | A workspace id from statelode://workspace. Explicit input overrides every default. For repository work, pass the workspaceId pinned in statelode.json. Project-creating mutations require this when a multi-workspace grant has no human-selected default. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description details behavioral traits far beyond the minimal annotations, including response structure (e.g., 'delegation', 'projectPolicy'), error handling logic (unknown_project error), and multi-workspace OAuth requirements.
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 dense, but every sentence is highly intentional, addressing a specific operational or behavioral requirement. It is logically structured to guide complex tool usage.
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 high operational complexity, involving multi-workspace contexts, defined project policies, and explicit filtering rules, this description is exceptionally complete.
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?
Given the extremely low schema coverage (9%), the description provides crucial context for complex parameters like 'projectId' (error handling if missing) and 'status' (how it affects result scope), effectively compensating for the missing schema detail.
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 defines the purpose as a 'lightweight' search for tasks, setting it apart from the full body retrieval of task_get and the mutation function of task_mutate.
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?
It provides explicit hierarchy instructions ('Use this FIRST'), detailed rules for filtering (e.g., 'NO status' = 'active' only), and necessary operational constraints (e.g., 'Always pass projectId').
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
task_get - First observed
task_mutate - First observed
task_search
Related MCP Connectors
Shared task layer for AI agents: tasks, handoffs and decisions that persist across tools.
Task tracking built for coding agents. Work is leased, so two agents never take the same SubTask.
Task management your AI agents can actually run. One line becomes a context-ready task over MCP.
Project management MCP for AI agents with safe task reads and writes.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceA file-based task manager operated through an MCP server, enabling agents to create, search, and manage tasks with git versioning and hybrid semantic+keyword search.-
- AlicenseNot gradedqualityCmaintenanceTask spine + searched dead-ends + mobile approvals for AI coding agents — one shared brain across every session, machine, and device. Local SQLite or remote streamable-HTTP MCP, MIT.74 npm2MIT
- AlicenseNot gradedqualityCmaintenanceProvides persistent memory and task management for coding agents via MCP tools, enabling mid-session recall and capture of durable knowledge.67 npm11MIT
- AlicenseNot gradedqualityNot gradedmaintenanceEnables AI coding providers to run structured multi-agent workflows with documents, tracked tasks, handoffs, and health-gated task lifecycle management over MCP.29 npmMIT
Glama MCP Gateway
Add one secure layer between your agents and this server.