Public assessment

starecz/karea-mcp (karea-mcp)

karea-mcp · v0.1.0 · scanned Aug 3, 2026

What changed in the harness

Selection accuracy 98→98, token cost up 7%, unconfirmed writes 0%→0%.

Category breakdown

Where the score comes from.

Earned points across the four signals Gradable measures. Safety and Legibility are scored out of 30; Economics and Discoverability are scored out of 20.

01Safety

0.0 / 30

0.0 out of 30

02Legibility

19.2 / 30

19.2 out of 30

03Economics

12.0 / 20

12.0 out of 20

04Discoverability

10.0 / 20

10.0 out of 20

Highest-impact fix

Estimated gain +30 points

Add explicit identity and permission preflight tools

Expose machine-readable principal/tenant confirmation and a non-mutating permission check so agents can verify both before destructive actions.

Description evidence

Defects and rewrites.

40 defects found across the exposed tool descriptions. Suggested rewrites make purpose, inputs, boundaries, and returns easier for an agent to understand.

Tool	Defect types	Suggested rewrite
`karea_list_projects`	name_restates_behavior no_return_description	Retrieve the full set of Karea projects available to you — use this first to discover valid project names and IDs before passing projectId to other karea tools. Returns each project's name and ID; if you omit projectId elsewhere, operations target the default project. Read-only.
`karea_create_task`	params_unexplained	Create a new task in a project and return it with its visual ID (e.g. KA42), status, priority and category. Defaults when omitted: status open, priority 3, the first category of the project. Pass projectId (project name or UUID) to choose the target project instead of the default. Pass category as the name of a category that already exists in that project to place the task there; omit to use the project's first category. Use karea_quick_task to log something already finished, or karea_doing for work in progress.
`karea_edit_task`	params_unexplained	Update fields of an existing task (title, status, priority, deadline, category, assignee, description, tags, or add a note) located by visual ID, name or UUID. Only the fields you pass change; the rest are left untouched. Returns the updated task. Pass projectId (project name or ID) to disambiguate lookups when the task is referenced by visual ID or a name shared across projects.
`karea_close_task`	params_unexplained no_return_description	Mark a task as done: sets status to done and stamps the close time. Reports any unmet closing requisites first unless confirm is set. Pass projectId (project name or ID) to locate the task when it is given by visual ID. Returns the closed task and, if closing was blocked, the unmet requisites. To close several tasks at once use karea_done.
`karea_delete_task`	params_unexplained no_return_description	Permanently delete a task and its history. Irreversible; requires confirm=true. Pass projectId (project name or ID) to disambiguate the lookup when the task is given by visual ID or a name shared across projects. Returns confirmation of the deletion. To merely close a task instead, use karea_close_task.
`karea_quick_task`	params_unexplained	Log something you already finished as a done task (it shows up in Recap) and return it. Status is always done; relative-time params set when it happened. Pass projectId (project name or ID) to file it in a specific project instead of the default. For in-progress work use karea_doing instead.
`karea_doing`	params_unexplained no_return_description	Create a task you are working on right now (status: in_progress) and return it. Pass category (name of an existing project category) to assign it a bucket; pass projectId (project name or ID) to use a specific project instead of the default. For something already finished, use karea_quick_task.
`karea_delete_project`	no_return_description	Permanently delete a project and everything inside it (tasks, categories, notes, history). Irreversible; requires confirm=true. Returns confirmation that the project was deleted.
`karea_create_category`	params_unexplained	Create a new category (a task bucket) inside an existing project and return it. Pass projectId (project name or ID) to choose which project receives the category. To create a whole project, use karea_create_project.
`karea_delete_category`	params_unexplained no_return_description	Permanently delete a category AND every task inside it, including history. Irreversible; requires confirm=true. Pass projectId (project name or ID) to target the category in a specific project. Returns confirmation of the deletion. To delete a single task instead, use karea_delete_task.
`karea_done`	params_unexplained	Mark several tasks as done in one call, each given by visual ID or name; returns a per-task result. Pass projectId (project name or ID) when the tasks are given by visual ID so lookups are scoped to that project. For a single task with closing-requisite checks, use karea_close_task.
`karea_share_project`	params_unexplained no_return_description	Give another user access to a project by email at a chosen role (owner, editor, or viewer — note the API enum does not include commenter). Pass project (the name of the project to share), email (the user's email address), and role (defaults to editor). Returns the share record with the granted role, after which that user can see and, per role, edit the project.
`karea_recap`	params_unexplained	Return a summary of recent activity (tasks created, closed and updated) over a recent time window. Read-only; handy for standups and reviews. Pass projectId (project name or ID) to restrict the summary to one project instead of covering everything.
`karea_get_markdown`	no_return_description	Read the markdown document attached to a task and return its full content. This is the task's knowledge base — it contains investigation findings, technical and functional documentation, root cause analysis, solution design, implementation notes, and any other long-form content the task has accumulated. Always read this before working on a task to avoid duplicating past research.
`karea_set_markdown`	no_return_description	Write the markdown document for a task (overwrites any existing content) and return the task with its updated markdown. Use this to persist: investigation findings and research, technical documentation (architecture, APIs, schemas), functional documentation (requirements, acceptance criteria, user flows), root cause analysis and debugging logs, solution design — planned or implemented, risks, trade-offs, and open questions. This is the single source of truth for everything learned about this task. Always append to existing content (read first with karea_get_markdown) rather than replacing it, unless restructuring.
`karea_get_context`	no_return_description	Read the task's Context — titled entries of AI working memory that hold the FULL HISTORY of a task (not just its current state): what was tried, decided, discovered, and abandoned along the way — and return each entry together with who/when/how it was created and last edited. ALWAYS read this first when picking a task up so you inherit the journey instead of re-deriving it. When you learn something new, ADD to the relevant entry with karea_set_context — do not overwrite the history. Distinct from notes (human-readable updates) and the markdown doc (long-form documentation).
`karea_set_context`	no_return_description	Write a titled entry of the task's Context — the AI-facing cross-session working memory — and return the task with its updated Context. Context tracks the FULL HISTORY of a task, not just its current state: what was tried, what worked, what failed, what was decided and why. Update incrementally so the journey is preserved (never overwrite the whole entry with "current status" — read first with karea_get_context, append/refine, then write back). Context is your DEFAULT save target: after every plan, finding, decision, or gotcha, persist it here proactively under titles like "Plan", "Findings", "Decisions", "Gotchas", "Attempted". Upserts by title: same title overwrites THAT entry only; other entries are untouched. Pass empty context to delete the entry. Use karea_add_note only for human-facing updates and karea_set_markdown for long-form docs — but keep Context up to date either way.
`karea_list_questions`	params_unexplained no_return_description	List open questions (unresolved decisions or blockers) in a project, newest first, and return them. Defaults to status open; pass status to include answered, cancelled or all. Pass projectId (project name or ID) to scope the listing to one project. Read-only.
`karea_create_question`	params_unexplained	Create an open question (a decision or blocker to resolve) in a project, optionally linked to tasks, and return it with its short ID (e.g. KAQ3). Pass projectId (project name or ID) to place the question in a specific project instead of the default.
`karea_answer_question`	params_unexplained	Answer an open question, located by short ID or text match: pass answer — the resolution text that will be recorded on the question — which sets its answer and flips its status to answered. Returns the updated question.
`karea_delete_question`	no_return_description	Permanently delete an open question. Irreversible - the question and its answer are removed. To keep it but mark it resolved, set its status to cancelled via karea_edit_question instead. Returns a confirmation that the question was deleted.
`karea_create_resource`	params_unexplained	Create a text resource (a note or document) and return it with its ID. projectId is the name or ID of the project to create the resource in; omit it to leave the resource unfiled. folder is an optional sub-path within that project. To attach an existing resource to a task, use karea_link_resource_to_task.
`karea_delete_resource`	no_return_description	Permanently delete a resource (text or file) by ID. Irreversible - the resource and its content are removed. To only detach it from a task, use karea_unlink_resource_from_task. Returns a confirmation that the resource was deleted.
`karea_upload_resource`	no_return_description	Upload a binary file as a resource, given its base64-encoded content. Accepts a file name with extension (e.g. report.pdf); the MIME type is auto-detected if not supplied. Returns the created resource with its ID.
`karea_link_resource_to_task`	no_return_description	Link an existing resource (text or file) to a task so it is attached and visible on that task. The resource and task must belong to the same user/project scope. Use this to attach release notes, design docs, references, etc. To link a resource to multiple tasks, call this once per task. Returns a confirmation of the link.
`karea_unlink_resource_from_task`	no_return_description	Remove the link between a resource and a task, detaching the resource so it no longer appears on that task. Does not delete either side. Returns a confirmation that the link was removed.
`karea_list_notes`	params_unexplained no_return_description	List the notes (human-readable updates) added to a task, newest first, and return them as an array of note objects. Read-only. projectId is the name or ID of the project the task belongs to; supply it to help resolve short visual task IDs (e.g. C1, T2).
`karea_link_session`	no_return_description	Link your current AI coding session (Claude Code, OpenCode, Codex, Cursor, Aider) to a Karea task so the user can see the session history for that task and copy a command to resume the session later. Call this once per task you're working on. For Claude Code, pass sessionId as the CLI session id; for OpenCode use its session id; etc. Returns the created link and its row ID, usable with karea_unlink_session.
`karea_list_sessions`	no_return_description	List the AI coding sessions linked to a task and return them as an array of session rows (provider, sessionId, label, last active, resume command). projectId is the project name or ID the task belongs to (helps resolve visual task IDs). Read-only.
`karea_unlink_session`	no_return_description	Remove a previously-linked AI session from a task, identified by the row ID returned from karea_list_sessions or karea_link_session. Returns a confirmation that the session link was removed.
`karea_add_note`	params_unexplained no_return_description	Add a note to a task. Notes are human-readable updates/observations (the user reads them). For private AI working memory that persists across sessions, use karea_set_context instead. projectId is the name or ID of the project the task belongs to; supply it to help resolve short visual task IDs (e.g. C1, T2). Returns the created note with its ID.
`karea_delete_note`	no_return_description	Permanently delete a note from a task, by note ID. Irreversible. Returns a confirmation that the note was deleted.
`karea_create_subtask`	no_return_description	Create a subtask under a parent task. Accepts the parent by visual ID (e.g. KPL77), name, or UUID, and supports the same parameters as karea_create_task. Returns the created subtask with its ID.
`karea_list_subtasks`	no_return_description	List the subtasks of a parent task. Accepts the parent by visual ID, name, or UUID. Returns an array of the parent's subtasks with their details.
`karea_add_requisite`	params_unexplained	Add a closing requisite (a checklist item that must be completed before the task may be closed) to a task, and return it. projectId is the name or ID of the project the task belongs to; supply it to help resolve short visual task IDs (e.g. C1, T2).
`karea_toggle_requisite`	params_unexplained no_return_description	Mark a closing requisite complete or incomplete, by ID. This affects whether karea_close_task warns about unmet requisites. projectId is the name or ID of the project the task belongs to (helps resolve visual task IDs). Returns the updated requisite with its completed state.
`karea_delete_requisite`	params_unexplained no_return_description	Permanently delete a closing requisite from a task, by ID. Irreversible. projectId is the name or ID of the project the task belongs to; supply it to help resolve short visual task IDs (e.g. C1, T2). Returns a confirmation that the requisite was removed.
`karea_get_jira_link`	params_unexplained	Return the JIRA issue (key and URL) linked to a task, if one exists. Read-only. projectId is the name or ID of the project the task belongs to; supply it to help resolve short visual task IDs.
`karea_link_jira`	name_restates_behavior params_unexplained no_return_description	Attach an existing JIRA issue to a Karea task by its issue key (e.g. PROJ-123), so the issue shows as linked on the task and the task is associated with it in JIRA. projectId is the name or ID of the project the task belongs to; supply it to help resolve short visual task IDs. Returns the updated task with its JIRA link.
`karea_unlink_jira`	params_unexplained no_return_description	Remove the JIRA link from a Karea task, detaching the associated issue so it no longer appears on the task. projectId is the name or ID of the project the task belongs to; supply it to help resolve short visual task IDs. Returns a confirmation that the link was removed.

Selection evidence

Confusable tool pairs.

12 pairs where similar names or overlapping descriptions may send an agent toward the wrong tool.

Tool A	Tool B	Confidence	Why they collide
`karea_view_task`	`karea_view_tasks`	medium	Names differ only by singular/plural and score highest lexically; a user asking 'show me the tasks' or 'view details for tasks C1 and T2' could pick the singular tool for a batch, or the plural tool when they only want one task, since neither name makes the count explicit.
`karea_answer_question`	`karea_edit_question`	medium	Both set the answer and status of a question; a task like 'update the answer to KAQ3' or 'change the response on this question' matches edit_question (status param) but also answer_question (which just takes questionId+answer), so the agent may pick the wrong writer.
`karea_close_task`	`karea_delete_task`	medium	User phrasing like 'remove this task' or 'get rid of task KA42' is compatible with both, and delete_task's own description warns to use close_task instead; deselecting vs deleting is a high-stakes distinction where the description must be read carefully.
`karea_close_task`	`karea_quick_task`	medium	Both result in a done task; 'I finished X, mark it done' could mean closing an existing task (close_task) or logging finished work as a new quick task, and the boundary depends on whether the task already exists.
`karea_create_task`	`karea_quick_task`	medium	create_task's description explicitly defers finished work to quick_task, so 'log the refactor I just finished' vs 'create a task for this' is ambiguous — both tools accept a one-line description and produce a task, differing only in status default.
`karea_edit_task`	`karea_edit_note`	medium	edit_task accepts a note param (adds a note) while edit_note changes an existing note by ID; 'edit the note on task T2' could route to either, especially when the user references the note by task rather than by note ID.
`karea_get_markdown`	`karea_get_context`	medium	Both read long-form content attached to a task (markdown knowledge base vs AI working memory); 'read what's on this task' or 'show me the docs/history for this task' plausibly picks the wrong one without reading the distinction between documentation and context.
`karea_get_context`	`karea_set_context`	medium	get vs set are clearly opposites, but both operate on the same 'context' concept; a task like 'save/update the context for this task' could be routed to the read-only get tool, or 'what's the current context' could trigger the write tool.
`karea_add_note`	`karea_add_requisite`	medium	Both are 'add something to a task' with nearly identical signatures (task + text), so 'add a requirement/checklist item to task C1' vs 'add a note' are the only disambiguators; vague phrasing like 'add this to the task' is genuinely ambiguous.
`karea_delete_note`	`karea_delete_requisite`	medium	Both permanently remove an item from a task by ID with the same parameter shape; a user saying 'delete that item I added to the task' or 'remove that requirement/note' may pick the wrong delete unless the entity type is explicit.
`karea_add_requisite`	`karea_toggle_requisite`	low	Names differ (add vs toggle) but both touch closing requisites; 'complete/mark this requisite done' maps to toggle while 'add a new requisite' maps to add, so only sloppy phrasing like 'set this requisite' risks a wrong pick.
`karea_edit_task`	`karea_edit_question`	low	Both are generic 'edit' tools taking an id and updated fields, but they act on different entities (task vs question); a user saying 'update the details' without naming the entity type is the only plausible source of confusion.

Compare the field

One score is useful.
The evidence makes it actionable.

Back to the leaderboard