Keelen
Autonomous dev team steered from chat: plain-English requests in, tested merged PRs out.
| Endpoint | https://keelen.ai/mcp (streamable-http) |
|---|---|
| Registry version | 1.0.0 |
| Now | 49 tools · grade D (58) · pin ts_890855a0f862763b44ddf6b0879b403f · protocol 2025-06-18 |
| First / last listed | 2026-11-05 00:54 UTC / 2026-11-05 00:54 UTC |
| Grade over time | 2026-11-05: D (58), 49 tools |
Is this your server? Own a server? ToolFit hosted watch re-checks it every 24 h ($0.25 per 30 days) or 6 h ($0.60) and sends you an HMAC-signed webhook when its tools or grade change: POST https://api.youraitools.co/toolfit/v1/watch. To opt out, see About & opt-out.
Tools: list_projects create_project submit_request get_request_status set_product_vision set_product_goal list_roadmap reorder_roadmap cancel_roadmap_item clear_horizon_pin rollback_roblox_place project_status close_task get_product_goal get_product_vision list_escalations resolve_escalation answer_planning_question retry_blocked_task requeue_for_review rearm_roadmap_item resolve_platform_regression list_steering_rules approve_steering_rule retire_steering_rule retire_steering_rules replan_task remove_cancelled_dependency control_scheduler archive_project delete_project run_security_review run_legal_exposure_review get_legal_exposure_findings run_control_gap_review get_control_gap_findings answer_request refine_request signup verify_email get_onboarding_status open_dashboard connect_github list_github_repos import_project get_provisioning_status get_billing project_digest stop_iteration
list_projects | List the projects in this workspace, with what each one is building. params: none |
create_project | Start building something new: creates a GitHub repo and begins work on it.
For a NEW repo. Given an existing repo, import_project(repo_full_name) is
the right call — this one would create a second, empty repo beside it
(list_github_repos() browses what the workspace can see).
Scaffolds a new GitHub repo, a bootstrap-mode project, and submits
`build_description` as the project params: name*, build_description*, project_kind*, private, preview_command, org, engine, ci_runs_on, framework |
submit_request | Ask for a change in plain English: a feature, a bug fix, or a new direction.
Each call carries ONE feature or intent; a multi-feature ask belongs in
separate requests. `text` must be under 16000 characters. Returns
{thread_id, status, next_action, poll_after_seconds, next_step}; next_step
names the re-check of get_request_status after poll_after_seconds.
params: project_id*, text*, workflow_profile |
get_request_status | Check what happened to a request, and read any questions it asked back.
Intake is async (~5min cadence), so the status changes between calls.
`next_action` is one of: "wait" (still processing), "answer_questions"
(answer_request takes one answer per question), "done" (see
generated_roadmap_item_ids), "cancelled" (terminal, no items), "failed"
(see intake_failure_reason), "appr params: project_id*, thread_id* |
set_product_vision | Say what this product is for, so every run knows what it is building toward.
`vision_md` is free-form markdown and must be non-empty. Tenant-scoped: a
project not in the caller's workspace 404s. Returns {project_id,
product_vision_md, updated_at, next_step}.
params: project_id*, vision_md* |
set_product_goal | Set the outcome to aim at right now, so work is prioritised toward one thing.
`goal_md` is free-form markdown and must be non-empty. Tenant-scoped: a
project not in the caller's workspace 404s. Returns {project_id,
product_goal_md, updated_at, next_step}.
params: project_id*, goal_md* |
list_roadmap | See what is planned for a project and in what order.
Queued rows also say whether the expand picker would elect them
(`electable`) and, when not, why it skips them (`skip_reason`:
awaiting_intake_thread | awaiting_clarification | crash_capped |
noop_capped | crash_cooldown | noop_cooldown | held_on_open_pr | other).
The first reason that applies, in that order, is the one retu params: project_id*, status |
reorder_roadmap | Change what gets built first.
`ordered_ids` is the desired front-to-back order of queued roadmap-item ids
(list_roadmap returns them). The first id becomes the highest priority —
the cadence expands the lowest-priority_int queued item next. Horizon pins
still dominate: a pinned-later item stays at the back and a pinned-now item
at the front, regardless of position in `ordered_ params: project_id*, ordered_ids* |
cancel_roadmap_item | Cancel / close a single roadmap item (list_roadmap returns its id).
For a DELIVERED or duplicate item that keeps re-parking: once the work has
shipped, every expand produces no dev-ready tasks and files a recurring
`roadmap_item_parked` escalation that has to be acked. Cancelling drops the
item out of the expand queue AND resolves any open expand-lane escalation for
it. Busine params: project_id*, item_id* |
clear_horizon_pin | Clear a queued roadmap item's horizon pin (now/next/later → none).
A horizon pin dominates the queue sort, so `reorder_roadmap` cannot move a
pinned item out of its band — a stale `now` pin on a delivered/duplicate item
clogs the front of the queue. This unpins it and reprices the queue so the
item follows plain priority order again (and reorder_roadmap can then move it).
Only params: project_id*, item_id* |
rollback_roblox_place | Roll a Roblox project's place back to a previously-published version.
For a `roblox_game` project, re-publishes the RETAINED build artifact for
`version_number` (the web Roblox Publishing card lists published versions)
— it never rebuilds from source, so rollback is fast + deterministic. This
mints a NEW Roblox version pointing at the old build. Unknown version → 404;
a versio params: project_id*, version_number* |
project_status | Check how a project is doing: what is in flight, what shipped, what is stuck.
Returns lifecycle status, open task count, queued roadmap item count, runs
today, verification pass rate, open blockers, pause state, and freshness.
Zero `open_tasks` does not mean an empty roadmap: `queued_roadmap_items`
counts planned work awaiting expansion, including work held while the
scheduler params: project_id* |
close_task | Close a task that should not be built — a duplicate, or work already shipped.
For a task on the board that is obsolete: the change already landed in
another PR, a sibling task covers it, or the user changed direction. The
task is marked `cancelled` and keeps ALL of its history (acceptance
criteria, QA steps, iterations) — nothing is deleted.
`reason` is REQUIRED and is record params: project_id*, task_id*, reason*, superseded_by_task_id, superseded_by_pr_number |
get_product_goal | Read a project's current product goal (the outcome work is aimed at).
The paired setter `set_product_goal` replaces the whole document rather
than appending to it, so a write without a prior read silently discards
whatever the user already recorded; adding a line means reading the current
text, editing it, and setting the full result back.
Returns {project_id, product_goal_md params: project_id* |
get_product_vision | Read a project's current product vision (what the product is for).
The paired setter `set_product_vision` replaces the whole document rather
than appending to it, so a write without a prior read silently discards
whatever the user already recorded; adding a line means reading the current
text, editing it, and setting the full result back.
Returns {project_id, product_vision_m params: project_id* |
list_escalations | See what the work is stuck on and waiting for a human decision about.
`project_status` only COUNTS open escalations; this returns each one with its
kind, reason, detail_md, recommended_action, and (when task-scoped) the
blocked task's title + PR url. A card about a roadmap item carries its
`roadmap_item_id` (null for a task-only, project-level or synthetic row),
which matches params: project_id* |
resolve_escalation | Acknowledge a handled ask only when no blocked task becomes invisible.
`decision_md` is a required short note (why/how it was resolved), appended to
the escalation's detail_md as an audit trail. Resolving a project_pause /
orphan_pause RESUMES the project (clears the pause). A blocked task's final
task_block/operator_action cannot be acknowledged: its typed retry,
platform-pol params: escalation_id*, decision_md* |
answer_planning_question | Answer an open planning question and release its roadmap item.
Use this for a `list_escalations` row with reason
`expand_needs_clarification` (its `next_tool` names this tool). The
planner asked one or more product questions about one roadmap item; give
ONE answer that covers every question (1-4,000 characters). The answer is
stored with the item, the card is resolved, and the params: escalation_id*, answer_md* |
retry_blocked_task | Grant one fresh attempt after fixing a recovery-budget task block.
``escalation_id`` is the task_block id returned by ``list_escalations``.
Eligibility, tenant, task, failure class, task status, and competing blockers
are all derived server-side. This is distinct from ``resolve_escalation``,
which remains acknowledgement-only for task blocks. Business-level replay guard:
an al params: escalation_id*, decision_md* |
requeue_for_review | Return one blocked task's existing pull request to normal review.
Requires a personal OAuth connection of an active workspace owner;
workspace keys are refused. Pass the task id (not an escalation id), the
PR's exact 40-character head SHA, a reason (1-2000 characters) and a
request_id you choose (1-128 of letters, digits, `.`, `:`, `_`, `-`). The
task's own open keelen/iter-* params: task_id*, expected_head_sha*, reason*, request_id* |
rearm_roadmap_item | Run the dashboard's replay-guarded same-item dependency re-arm.
``escalation_id`` is an ``expand_produced_nothing`` or
``roadmap_item_parked`` escalation id. Keelen verifies delivered structural
prerequisites, grants one bounded
expand retry, preserves the roadmap item id and ``depends_on_item_ids``, and
resolves the matching cards in one transaction. A bounded live GitHub che params: escalation_id* |
resolve_platform_regression | Recover a task Keelen's own postprocessor re-broke.
``escalation_id`` is an open ``platform_policy_conflict`` card that the
server attributed to Keelen's postprocessor writer. ``decision_md`` is the
concrete recovery note recorded on the new plan section.
This is the only customer recovery while the autonomy ladder is enabled.
It records the decision, requeues the same task l params: escalation_id*, decision_md* |
list_steering_rules | List this project's active and pending steering rules.
Steering rules are prepended to every planning, development and QA prompt.
Each rule has `state` (`active` = in the prompt, `pending` = waiting for a
project member's approval, `expired` = past its expiry and no longer in the
prompt) and `origin`: `owner_request` (written from a
Request), `retro_kaizen` (a sprint retrospec params: project_id* |
approve_steering_rule | Approve one pending steering rule so it reaches the iteration prompts.
Pass the project id and the rule `id` from list_steering_rules. Only a
`pending` rule changes; an already active rule returns `changed: false`.
A retired rule is refused (409): approval never re-activates it. Your
identity comes from this connection and is recorded on the audit trail.
params: project_id*, rule_id* |
retire_steering_rule | Retire one steering rule so no later iteration prompt carries it.
Pass the project id and the rule `id` from list_steering_rules. Works for
an active or a pending rule, including a retro kaizen the automatic
curation pass protects. The rule's text and history are kept and the
retirement appears in Loop Activity. A rule that is already retired
returns `changed: false`. There is params: project_id*, rule_id* |
retire_steering_rules | Retire several steering rules in one transaction.
Pass the project id and 1-100 rule `id` values from list_steering_rules.
Works for active and pending rules, including a retro kaizen the automatic
curation pass protects. Each changed rule is retired with one audit row;
a rule that is already retired returns `changed: false`. If any requested
rule is not this project's, nothin params: project_id*, rule_ids* |
replan_task | Replace an unretryable blocked task without losing its lineage.
Creates a fresh, explicitly planned task under the same roadmap item and
attempt lineage, transfers prerequisites and downstream dependents, and
cancels the stale task with supersession provenance. The old PR, task,
failures, criteria, and evidence remain in the audit history; nothing is
marked delivered. Inputs o params: project_id*, task_id*, title*, body_md*, acceptance_criteria*, decision_md*, workspace_strategy, recovery_source_pr_number |
remove_cancelled_dependency | List or remove a dependency on a task cancelled without delivery.
``escalation_id`` is a ``prerequisite_hold_stalled`` card. A waiting task
whose dependency points at a task cancelled without proof of delivery can
never start. Without ``task_id`` and ``predecessor_task_id`` this lists
every such dependency in the card's project and changes nothing. With both,
it removes that O params: escalation_id*, task_id, predecessor_task_id |
control_scheduler | Start, pause, or resume a project's autonomous work.
`action` is one of: "enable" | "disable" | "resume" | "process_now".
- enable/disable flip scheduler_enabled (the loop dispatches only enabled,
status='active' projects).
- resume clears a pause (peak/backoff/manual) so the project dispatches again.
- process_now durably prioritizes and immediately attempts the next intake params: project_id*, action* |
archive_project | Archive a project (reversible shelve) — frees a project slot in-tool.
Stops any in-flight machine, then flips the project to `archived`: it drops
out of the per-tier project cap (freeing a slot for a new project) and the
loop stops dispatching it, but the project + its history are kept and can be
restored from the dashboard project page. Stopping a machine DESTROYS the
running params: project_id* |
delete_project | Soft-delete a project (the harder option) — frees a slot and hides it.
Stops any in-flight machine, then flips the project to `deleted`: it
disappears from `list_projects`, drops out of the project cap, and the loop
stops dispatching it. Deleting ALSO permanently purges the project's stored
review artifacts. The row is retained for audit and re-importing the repo
restores that params: project_id* |
run_security_review | Find security problems in a repository: a deep, whole-codebase review.
Spawns a one-shot audit that scans the repo across a kind-aware taxonomy
(secrets + git history, vulnerable/abandoned deps, injection, SSRF, path
traversal, deserialization, crypto, info-leak, plus web authz/session/CORS,
library API-misuse, game client-trust, or infra/CI as applicable) and posts
findings t params: project_id* |
run_legal_exposure_review | Find where a codebase creates legal exposure (privacy, consent, data handling).
Spawns a one-shot review machine that reads the checkout offline and maps
what the code DOES onto commonly cited legal obligations, filtered by the
project's saved compliance profile (jurisdictions plus eleven product
facts). Findings land on the project's Legal page for a human to triage,
readable params: project_id* |
get_legal_exposure_findings | Read a project's legal exposure findings, worst exposure first.
Returns each finding as an OBSERVATION plus the obligation commonly cited
over that pattern, its citation, the date the citation was last checked,
and whether counsel has reviewed the registry entry (`counsel_reviewed`,
false today for every entry). `exposure_order` is an ORDER, never a score:
there is no grade, n params: project_id*, limit, include_all |
run_control_gap_review | Start a source-bound security control gap review for one project.
The review records bounded engineering observations under the user's
selected Cyber Essentials or CMMC Level 1 or Level 2 context. It does not determine framework
standing, and it does not make changes. The `disclaimer_md` field must
reach the user before any observation is summarised.
The project needs a saved params: project_id* |
get_control_gap_findings | Read a project's security-control observations and review boundaries.
The result groups records by evidence class without a total or an overall
framework outcome. `not_determinable` and `outside_review_scope` qualify
every observation. An empty group does not establish that a control is in
place, and `disclaimer_md` must reach the user.
`limit` defaults to 25 (max 100). `incl params: project_id*, limit, include_all |
answer_request | Answer a thread's clarifying questions (status must be awaiting_answers).
`answers` is a list of {"idx": <int from get_request_status>, "answer_md":
<str, 1..2000 chars>}. Every question needs exactly one answer. The call
flips the thread back to intake_pending; get_request_status reports the
subsequent state.
params: project_id*, thread_id*, answers* |
refine_request | Say what is wrong with what a request produced, and have it reworked.
Status must be "done". `feedback_md` is 1..1979 chars. Moves the thread to
refine_pending; get_request_status reports the revised items. Refinement
re-plans the thread's roadmap items and can EDIT OR HARD-DELETE the task rows
it generated earlier (the machine patch-tasks endpoint deletes them
outright), so i params: project_id*, thread_id*, feedback_md* |
signup | Create a Keelen account (or start agent login) — emails a 6-digit code.
UNAUTHENTICATED — the only tool besides verify_email that works before a
bearer key is configured. `email` is where the code is sent. Flow:
signup(email) -> the user reads the 6-digit code from their inbox ->
verify_email(email, code) returns a reveal-once API key, stored as this
server's `Authorization: B params: email* |
verify_email | Redeem the emailed 6-digit code for a reveal-once workspace API key.
UNAUTHENTICATED. `email` + `code` must match a code issued by signup(email)
within the last 15 minutes (5 attempts max). The returned `api_key` is shown
exactly ONCE — store it ONLY in the MCP client config
("Authorization: Bearer <api_key>"), NEVER in a repo or a file you might
commit. Reconnecting this serv params: email*, code* |
get_onboarding_status | Check what is set up so far and what to do next to get building.
Reports engine_connected / github_connected / project_count / payment_status
and a `next_action` string whose value is authoritative, with this tool
polled between steps. `next_action` is "call_tool" (the tool named in
`next_tool`, with `next_step` describing the call) until onboarding is
complete, then "done". ( params: none |
open_dashboard | Get a one-click, pre-authenticated dashboard sign-in link for the owner.
The engine-connect step — and any dashboard task (billing card update, a
project page) — needs a signed-in browser. Because this server has already
authenticated the workspace owner, this mints a single-use magic-link login
token and returns a `/login?token=…` deep link: opening it signs the user
straight params: none |
connect_github | Get the link that connects a GitHub account, so work can reach real repos.
Returns an `install_url` that the user opens in a browser to pick the GitHub
account/org, approve the install, and land on a "connected" page;
get_onboarding_status() then reports github_connected true. The link expires
in 10 minutes; a repeat call mints a fresh one.
params: none |
list_github_repos | List the CALLER's own GitHub-visible repos (for import_project).
For an OAuth connector that is the connected member; for a static workspace
key it is an eligible active owner. Each entry has full_name,
default_branch, private, language, pushed_at. A `full_name` is what
import_project(repo_full_name) connects. A COMPLETE listing publishes an
actor-bound proof valid for 10 minu params: none |
import_project | Connect an EXISTING GitHub repo as a Keelen project.
This is the counterpart of create_project: it is for a repo that already
exists, while create_project scaffolds a brand-new one.
`repo_full_name` is "owner/repo". Import requires that the SAME caller
listed the repository with list_github_repos() within the last 10 minutes,
OR that the workspace already holds a valid reposi params: repo_full_name*, engine, build_description, project_kind, stack, preview_command |
get_provisioning_status | Check whether a new project has finished setting up and is ready to build.
Returns overall (provisioning | ready | errored), a 7-stage checklist, and a
user-facing error_kind when a stage failed. next_action is "wait" with
poll_after_seconds (~10s) while provisioning, "wait" with NO
poll_after_seconds when errored (fix the reported cause, then re-check —
polling again without params: project_id* |
get_billing | Billing status + a Stripe checkout link when a NEW subscription is needed.
`plan` is one of starter | pro | agency (default starter). When the
workspace has NO live subscription and needs one (open-signup unpaid,
churned, or converting from a free/trial tier), returns a `checkout_url`
with next_action "browser" — the user opens it in a browser (the one setup
step that can't ha params: plan |
project_digest | Read a compact progress digest for one project (delivery, activity,
holds, next decision).
Returns the closed MCP projection: delivery counts and the five newest
delivered items, a recent loop-activity count, current holds, the single
highest-priority open decision, and `more_decisions`. Two steering fields
are ALWAYS present: `next_action` is `"call_tool"` with
`next_tool params: project_id*, since |
stop_iteration | Stop one running iteration after confirmed runtime cleanup.
Requires a personal active workspace owner. Workspace keys and Portfolio
delegation cannot stop compute. The exact project iteration number binds
the runtime. Cleanup failure leaves it active; a busy subject is refused.
Confirmed cleanup finalizes unfinished runtime iterations, holds its legacy
tasks for owner close o params: project_id*, iter_n*, reason* |
Entries describe changes in tool definitions. They are not statements about a server, its quality or its author. The grade measures how the tool definitions fit model providers (token cost, schema compatibility, confusable names) as scored by the ToolFit engine at the time of the listing. JSON: append .json. Opt-out: how or hello@youraitools.co.