Critical deficiencies across all 32 tools. While tool names are generally well-formed action verbs (create_, tag_, fork_, etc.), the definitions lack essential quality signals required for LLM-safe agent execution. Input schemas are present but minimally specified, only a single 'username' string parameter per tool with basic descriptions. No output schemas are documented anywhere in the codebase. Parameter descriptions are trivial ('Kaggle username for the notebook owner') and do not explain what the tool actually does or when to use it. Tool descriptions themselves are superficial and do not indicate state-modifying consequences, prerequisites, error conditions, or expected behavior. No evidence of parameter validation, error handling guidance, or idempotent markers. The server appears designed to unlock Kaggle badges through automated account actions, a high-risk use case that demands strict validation and explicit safety markings, neither of which are present. Security concerns are acute: the tool definitions accept only a username parameter but presumably manipulate that user's account without explicit authorization models, permission gates, or audit trail guidance. No tools include destructiveHint or readOnlyHint annotations. The codebase references 'destructive' markers in test fixtures but provides no corresponding tool-level safety metadata.
Tools (32)
bookmarkwriteauth47/100
Bookmark a notebook, dataset, or competition to earn Bookmarker badge
code_submissionwriteauth48/100
Make a code-based submission to earn Code Submitter + Notebook Modeler badges
colab_coderwriteauthsource verified45/100
Open a Kaggle notebook in Google Colab to earn Colab Coder badge
collectorwriteauthsource verified47/100
Add an item to a collection to earn Collector badge
competition_modelerwriteauthsource verified45/100
Use a model in a competition notebook to earn Competition Modeler badge
create_datasetwriteauth48/100
Create a dataset to earn Dataset Creator + API Dataset Creator badges
create_modelwriteauth48/100
Create a new model to earn Model Creator + API Model Creator badges
No output schemas documented. Tools return values but callers have no definition of response structure, field types, or what data to expect. This forces LLMs to hallucinate response shapes and breaks downstream tool chaining.
Document output schemas for all 32 tools. For tools that create/submit resources, return: {id, name, created_at, url, status}. For read tools (login_streak), return {username, streak_count, last_login}. Include field types and descriptions.
Expand all tool descriptions to 100-200 characters. Include: (1) what the tool does in plain English, (2) what account state changes, (3) when to use it instead of similar tools, (4) any prerequisites or permission checks. Example: 'Creates a new Python notebook on the user's Kaggle account via API. Modifies account: adds new notebook resource. Requires: valid Kaggle API token with write scope. Use when you need to submit code to Kaggle.'
Add parameter constraints to 'username': minLength: 1, maxLength: 50, pattern: '^[a-zA-Z0-9_-]+$' (adjust pattern to match actual Kaggle username rules). Add description: 'Your Kaggle username (3-50 alphanumeric characters and hyphens/underscores). The account to modify. Your API token must have permission to modify this account.'
Annotate all 28 WRITE tools with destructiveHint=true in tool definitions. Annotate 4 read-only tools (seven_day_login_streak, thirty_day_login_streak, etc.) with readOnlyHint=true. This signals to LLMs which calls are reversible.
Add error handling guidance to all tool descriptions. Include: 'If the username is invalid, the tool will return an error. Check the username spelling and try again. If you lack permission to modify this account, contact your Kaggle administrator.'
Document the security model: (1) clarify whether the API token is bound to a specific user or can operate on any username, (2) add a scope declaration (e.g., 'Requires: read:account, write:notebook, write:dataset, write:model, write:submission'), (3) specify audit trail expectations ('All actions logged to Kaggle audit logs with timestamp and actor username').
Score history
Overall score trend
First recorded score · v2 rubric
38/100
Scored
Grade
Overall
Spec posture
Rubric
2026-09-23
F
38
2026-07-28+
v2
create_model_variation
writeauth48/100
Create a model variation/instance to earn Model Variation Creator badge
create_python_notebookwriteauth48/100
Push a Python notebook to earn Python Coder + API Notebook Creator + Code Uploader badges
create_r_notebookwriteauth48/100
Push an R notebook to earn R Coder badge
create_utility_scriptwriteauth48/100
Push a utility script to earn Utility Scripter badge
dark_themewriteauth43/100
Switch to dark theme to earn Vampire badge
dataset_pipelinewriteauth45/100
Create a dataset from notebook output to earn Dataset Pipeline Creator badge
document_datasetwriteauth48/100
Achieve usability score 10/10 on a dataset to earn Dataset Documenter badge
document_modelwriteauth48/100
Achieve usability score 10/10 on a model to earn Model Documenter badge
fill_profilewriteauth45/100
Fill out Kaggle profile (bio, location, etc.) to earn Stylish badge
fork_notebookwriteauth48/100
Fork a public notebook to earn Code Forker badge
github_coderwriteauthsource verified45/100
Link a GitHub repo to a notebook to earn GitHub Coder badge
linked_datasetwriteauth45/100
Create a dataset linked to a URL source to earn Linked Dataset Creator badge
linked_modelwriteauth45/100
Create a model linked to an external source to earn Linked Model Creator badge
model_pipelinewriteauth45/100
Create a model from notebook output to earn Model Pipeline Creator badge
r_markdownwriteauth45/100
Push and execute an R Markdown notebook on KKB to earn R Markdown Coder badge
Tool descriptions are 25-80 characters and trivial. They state only what badge is earned, not what the tool does internally, what side effects occur, when to use it, or what prerequisites exist. Example: 'Push a Python notebook to earn Python Coder + API Notebook Creator + Code Uploader badges' does not explain that this modifies the user's Kaggle account, requires API credentials, or will fail if user lacks permission.
Single parameter 'username' (string) across all 32 tools. No parameter enum constraints, no min/max bounds, no regex patterns, no format specifications. No guidance on whether 'username' accepts email, display name, or only system ID. Descriptions are trivial (e.g. 'Kaggle username for the notebook owner') and do not explain what the parameter controls or its valid format.
No destructiveHint or readOnlyHint annotations on tool definitions. All WRITE-risk tools (28 of 32) modify user accounts but carry no metadata warning the LLM that these are irreversible state changes. Agents cannot distinguish safe-to-retry tools from those that risk duplicate side effects (e.g., submitting twice, creating duplicate datasets).
No error handling guidance. Tool descriptions do not explain what errors are possible, how to recover, or what the LLM should do if a call fails. No mention of permission checks, rate limits, invalid credentials, or user-fixable vs. fatal errors.
No security gate or permission model documented. Tools accept only a 'username' parameter with no indication of how authorization is enforced. No mention of API token scope, required permissions, or whether an agent can operate on arbitrary Kaggle accounts. High risk for abuse: an agent with a token could modify any account passed to these tools.
Minimal input schema specification. All tools use a single string parameter with no minLength, maxLength, pattern, or enum constraints. JSON Schema properties exist but lack meaningful validation rules that would help LLMs understand boundaries and prevent invalid input.
STDIO transport only. Server is not remotely accessible and cannot be used by hosted MCP clients or deployed agents. This is a hard architectural limitation that prevents real-world deployment.
Add idempotent markers where applicable. For tools like tag_notebook or bookmark that should succeed even if the tag/bookmark already exists, add idempotentHint=true to prevent duplicate side effects on retries.
Consider splitting generic tools into more specific variants. For example, instead of one tag_* tool per resource type, provide a single tag_resource(resource_type: 'notebook'|'dataset'|'model', resource_id, tags) tool with an enum. This reduces cognitive load on the LLM and makes the interface more composable.
Add prerequisites and dependencies to descriptions. Example for submit_titanic: 'Prerequisite: must have a valid Kaggle account and have accepted the Titanic competition rules. Requires: a submission CSV file (not provided by this tool; use create_* tools first). If submission fails, check that your CSV format matches competition requirements.'
Migrate from STDIO to HTTP+SSE or Streamable HTTP transport to enable remote execution and integration with hosted MCP clients. STDIO limits the server to local-only deployments.
Return resource IDs and URLs in all tool outputs so that downstream tools or agents can reference created resources. For example, create_python_notebook should return {notebook_id, notebook_url, created_at}.
Add pagination guidance (if applicable) for list-like operations. State max result limits and whether the tool supports filtering/sorting parameters.
Provide examples of valid input in each parameter description (but NOT as part of the description prose, use a separate 'example' field in the JSON Schema to prevent LLMs from copying example values literally).