Install the Onplana agent skills

Once your agent is connected to Onplana, you can sharpen what it does with skills: short, portable instruction files that teach a generic agent how to work inside Onplana the way an experienced PM would. Skills are not code; they are markdown prompts you save into your client’s skills folder (or paste as Custom GPT instructions). Onplana publishes two of them, free, for any plan.

If you have not connected an agent yet, start with Connect an external AI agent; skills assume a working MCP connection.

The two skills

Skill	What it does	When to use it
Planner	Turns a one-line goal into a written plan.md, a task tree with dates and owners, milestones, test-case subtasks, and downstream-surface tasks.	At the start of a project, or when scope changes substantially.
Autonomous run	Sweeps the open tasks in a project: moves each to In Progress, does the work, verifies it (tests, build, browser check), and either marks it Done or annotates why not.	Day to day, to keep the board honest without you driving every status change.

The two compose: the planner gives you something runnable, the run skill runs it. You can install one, the other, or both, and the same MCP connection serves all of them.

Download

The files are short (one page each) and live on the public site:

• Planner skill (onplana-project-planner-skill.md)
• Autonomous run skill (onplana-autonomous-agent-skill.md)

Save them with those names; you will reference them in the install step below. They are versioned with the public site, so re-downloading later keeps you on the latest revision.

Install

The skill file is the same for every client; only how the client loads it differs. Pick yours.

Claude Code

1. Connect the MCP server (one-time):

   claude mcp add --transport http onplana \
     https://mcp.onplana.com/mcp \
     --header "Authorization: Bearer <YOUR_PAT>"

2. Drop the file into your skills folder:

   ~/.claude/skills/onplana-autonomous-agent/SKILL.md

   (For the planner, use onplana-project-planner/SKILL.md.)

3. Restart Claude Code and start a new conversation; the skill is now available.

ChatGPT (Custom GPT or connector)

1. Add Onplana as an MCP connector in your ChatGPT settings:

   Connector URL:  https://mcp.onplana.com/mcp
   Auth:           Bearer <YOUR_PAT>

2. Paste the contents of the downloaded skill file into your Custom GPT’s instructions (or attach it as a knowledge file).

Codex

1. Add an MCP server to your Codex config:

   [mcp_servers.onplana]
   url = "https://mcp.onplana.com/mcp"
   headers = { Authorization = "Bearer <YOUR_PAT>" }

2. Reference the skill in your prompt, or paste it as a system message.

claude.ai

1. Settings → Connectors → Add custom connector, then enter:

   Connector URL:  https://mcp.onplana.com/mcp
   Auth:           Bearer <YOUR_PAT>

2. In a Project, add the skill file as a project document. The agent will follow it for every conversation in that Project.

Tip

The Connect Agent screen in Onplana prints the exact setup command for the client you pick, with your token already inlined. Use it to copy-paste; the snippets above are the general shape.

Kick off either skill in one line

Once installed and connected, a single instruction starts each skill.

Plan a project

Plan [the goal] in Onplana. Create or use the project, write a plan.md and attach it, then decompose it into tasks and subtasks with start and due dates, dependencies, and owners. Add test-case subtasks for each deliverable as you go, and tasks for any downstream surfaces it touches (docs, tests, API, migrations, analytics). Set milestones, review the tree, and post a summary.

Run a project

Loop through all the remaining open tasks in [your project] and work on them autonomously. Move each task to In Progress, do the work, and verify it (run the tests and build, and for anything user-visible test it in a browser and attach a screenshot) before marking it Done, keeping each status up to date. If you are blocked or have a question, add a comment to the task and move on to the next one. If you hit a real problem, file an Issue under the same project and link it to the task. When you have been through every task, post a summary and end the session.

You can substitute names and details freely; the skill teaches the agent what to do, the prompt tells it which work to do it on.

What the planner produces

After the planner finishes you should see:

• A new plan.md document attached to the project, capturing scope, approach, non-goals, and assumptions.
• A task tree with status, priority, dates, dependencies, and an assignee per task.
• Milestones for the dates that matter (kickoff, beta, GA, hand-off).
• Test-case subtasks under any deliverable that ships.
• Cross-cutting tasks for the surfaces the change ripples to (docs, API, integrations, analytics).
• A summary comment with the headline numbers (task count, estimated hours, critical-path length, risks flagged).

If a piece is missing, you can ask the agent to fill it in (for example, “add test cases under the build epic”) and it will use the same skill conventions.

What the autonomous run looks like

A non-blocking sweep: the agent gets through every open task once, leaving each one advanced, done, or clearly annotated. No single task stalls the whole run. Concretely:

• Pick up the open work in priority order.
• Do it in its own environment. The agent edits files, runs commands, opens browsers, whatever the work calls for, then records the result back in Onplana.
• Keep the board honest. Status moves to In Progress when work starts and to Done only after verification; every step leaves a comment trail.
• Verify before Done. Tests, build, and for anything user-visible a browser check with a screenshot attached.
• Surface problems. If blocked, the agent comments and moves on. If it hits a real problem, it files an Issue and links it to the task.

When the sweep finishes, the agent posts a summary comment on the project: what shipped, what moved, what stalled, and what is still open.

Guardrails (autonomous, not unsupervised)

The skills bake in a small set of rules so an agent does not run unchecked:

• Token-bounded reach: an agent can only see and touch projects its personal access token allows.
• No silent claims of done: the run skill explicitly forbids marking a task Done without verification evidence.
• No self-talk: the agent does not approve its own pull requests or reviews; human-review steps stay human.
• Pause before irreversible or outward-facing actions (deletes, customer notifications, force pushes). The agent asks first.

If you want a slower posture, run the skill in guided mode (specify it in the kickoff prompt). The agent then stops and waits for your go-ahead at each major step instead of sweeping continuously.

For the review side of this, see Review and approve agent output.

Keep the skills up to date

The skill files are versioned with the public site. To stay current:

• Re-download from the links above every few weeks (or whenever you see the skill behave oddly). The same connection serves the new file; just overwrite the old one.
• Watch the What’s New entries for skill changes; meaningful updates are noted there.
• Customise locally by editing your copy. The downloads are a starting point, not a contract. Many teams add house rules (preferred test command, branch naming, definition-of-done) at the top of their own copy.

Curious how the autonomous workflow fits with Onplana’s review and delegation features? The agents overview on the main site shows the bigger picture.

FAQs

Are these the same as the MCP tools? No. The MCP server gives the agent the tools (find a task, post a comment, create a sprint). The skill gives the agent the playbook for when and how to use them. Tools without a skill works, the agent just has to figure each project out from scratch; skill without tools does not work at all.

Do I need both skills? No. Install whichever you use. The planner is a one-shot at the start of a project; the run skill is the day-to-day driver. Most teams end up using both, but you can start with just one.

Will the skill work with my own agent or framework? Yes. The file is plain markdown with no proprietary syntax, so any agent that supports prompt-style instructions can load it. The client-specific install steps above cover the common ones; for anything else, paste the file contents into your system prompt.

Does the skill consume my AI tokens? The skill itself is just text in the agent’s context. The work the agent does on your behalf uses the agent client’s own model and tokens, not Onplana’s, so it does not draw down your Onplana AI budget. (Onplana’s AI budget covers the in-app assistant and the docs Ask-AI assistant.)

What if I want to write my own skill? You can. Use the published skills as templates: a one-page brief that defines the role, the goal, the steps, the guardrails, and how to report. Drop yours into the same skills folder under a different name and reference it the same way.

Which plan is required? None. Skills run on top of an agent MCP connection, which is available on every plan including Free (see Connect an external AI agent; the connection count scales with your plan). The skill files themselves are free for anyone to download.