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.

Claude Code users can skip this section. The plugin bundles both skills and keeps them in step with the copies above, so there is nothing to download or place by hand.

Install

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

Claude Code

Install the plugin. It carries both skills, the MCP server, and two commands, and there is no token to paste anywhere.

1. Add the marketplace and install the plugin:

   /plugin marketplace add Onplana/onplana-claude-plugin
   /plugin install onplana@onplana

2. Sign in once:

   /mcp

   Select onplana and complete the browser sign-in.

That is the whole setup. Both skills are now available, and Claude picks the right one up on its own when a request matches, so you do not have to name them. The plugin also adds /onplana:status, which confirms the connection and lists what is assigned to you, and /onplana:plan, which plans a goal into Onplana.

Note

Why there is no token. The plugin ships no Authorization header on purpose. Claude Code offers a browser sign-in when the server answers 401, which is how the OAuth flow starts. If you add a header yourself and Onplana rejects it, Claude Code reports the connection as failed rather than falling back to OAuth, so leave it out.

Sign-in needs an interactive session, so it cannot run inside claude -p. Authenticate once from an interactive session, or run claude mcp login onplana.

If /plugin is not recognised, update Claude Code; plugin support arrived in a later release than the MCP client itself.

Installing by hand instead

Use this if you want only one of the two skills, or if you keep your skills folder under your own version control.

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

   claude mcp add --transport http onplana https://mcp.onplana.com/mcp

   Then run /mcp, select onplana, and sign in. Passing a --header "Authorization: Bearer <YOUR_PAT>" also works, but it opts you out of the OAuth flow and puts a long-lived token in your shell history.

2. Place the downloaded file in your skills folder:

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

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

   Keep the frontmatter at the very top of the file. The published copies open with an HTML comment naming their source; delete it, or the --- block is no longer the first thing in the file and the skill loads without its name or description.

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. Ask it to fetch the skill. No download and no paste:

   Call get_agent_skill with skill "planner" and follow it.

   ChatGPT reads MCP tools but not MCP prompts or resources, so the skill is served as a tool result. get_agent_skill with no argument lists both and returns neither body, if you want to see the options first.

Note

For a Custom GPT, which is not connector-based, paste the downloaded file into its instructions or attach it as a knowledge file instead.

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. Ask it to fetch the skill, rather than pasting it:

   Call get_agent_skill with skill "autonomous" and follow it.

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. Or skip the file and ask it to get_agent_skill in the conversation, which is the same text fetched from the connector.

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:

• On Claude Code, run /plugin marketplace update onplana. The plugin’s bundled copies are checked against the published files, so updating the marketplace is all that is needed; there is nothing to download or overwrite.
• Everywhere else, 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.
• Customize 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.

Best practices

1. Install both Planner and Run skills. They serve different phases. Planner = project kickoff; Run = day-to-day. Most teams end up using both.
2. Customize the skill with house rules. Add your team’s preferences (test commands, branch naming, definition-of- done) to the top. The skill is markdown.
3. Re-install when skills update. Onplana publishes skill improvements periodically. Update the plugin, or re-download, to get the latest.
4. Document which skill a project uses. Different agents may run different skills. Track in project description.
5. Pair with task threads. The [Agent] thread is where the skill-driven agent listens.

Troubleshooting / common pitfalls

• Agent ignores the skill. Skill not loaded into agent context. Verify install step for the client.
• Skill outdated. Update the plugin, or re-download.
• Agent makes wrong choices. Skill too generic for your team’s pattern. Customize the skill file.
• Skill works in chat but not in background. Some agents (Claude Desktop) load skills only at conversation start.
• Custom skill not picked up. Wrong folder or filename. Match client’s skills folder convention.

How this combines with other features

• Skills + MCP tools. Skills are playbooks; MCP is the toolset. See Connect an external agent.
• Skills + Agent personas. Skill- driven agents act as their persona.
• Skills + Task threads. Agent reads + replies in the Agent thread. See Talk to agents in task threads.
• Skills + Review. Skill-driven deliverables route to review inbox. See Review agent output.

Related

• Connect an external agent, the MCP side
• Assign work to an agent, delegate tasks
• Talk to agents in task threads, Agent thread