Agents are now live in Plane

Today, we're introducing Agents in Plane.

Agents already carry a meaningful share of execution in most teams, but I think the work of coordinating them still falls almost entirely on people. Someone has to give the agent the right work, hold it within clear limits, and bring the result back into the system the team runs on. Right now the loop closes only because a person closes it by hand.

We built Plane Agents to close that loop inside Plane. An agent's instructions, its scope, what it can read, what it's allowed to change, and the state of the work it's acting on all live next to the projects themselves. So it picks up work from the system and leaves the result in the system. That's what we mean when we call them native.

From today, humans and agents in Plane work against the same projects and the same work items.

How agents are configured

You build an agent around a recurring responsibility, so you set it up once and don't re-explain the job every time work shows up. You describe how you want the work handled and add the Skills it needs. Then you choose the projects it works in, the sources it can read, and the tools it's allowed to use. Admins create and configure agents, and members can bring them into their own work. The Agents Docs cover setup.

You can start from a template or define your own. We currently ship a few ready-to-use ones:

• Triage Agent reviews incoming work items, interprets their content, sets priority, and routes them to the appropriate owner.
• Standup Summarizer reads work-item activity across a project and prepares a daily standup summary.
• Spec Writer takes a brief work-item description and develops it into a more detailed specification.

Beyond the templates, the same configuration covers other recurring work. A few examples:

Agents in the flow of work

An agent doesn't need a new chat to get started. You can assign one directly to a work item, or mention it in an existing conversation when you need its help. You can also have it run when something changes in a work item, or put it on a schedule for recurring work such as standups, reviews, checks, and follow-ups.

Everything it needs is already on the work item when it starts, so it picks up where the last person left off.

What an agent can read beyond Plane

What's in Plane is often only part of what an agent needs. Depending on the job, it can draw from several sources:

The agent combines that with the work already in Plane. Whatever the source, it works the same way: read what's relevant, make a call within its limits, take an action it's permitted to take, and know when to stop.

Boundaries for agent execution

Delegation only works when the boundary is clear before the agent begins. In Plane, that boundary has five parts:

• Objective: What the agent is responsible for accomplishing
• Scope: Where it is allowed to operate and what it can access
• Actions: What it is permitted to change or create
• Constraints: Which conditions it must respect while working
• Escalation: When the decision needs to return to a human

Inside that boundary, the agent has room to finish the work it was given, and anything outside it comes back to a human. I'm comfortable delegating a lot of execution to agents, as long as the limits stay clear and the exceptions stay visible.

Agent credits and usage

Plane separates AI usage into individual credits and Agent credits.

• Pro: 100 Agent credits per seat each month
• Business: 200 Agent credits per seat each month. A 10-seat Business workspace gets 2,000 shared Agent credits per month.
• Enterprise: Unmetered, using your own model keys

Agent credits come from the AI credits already included with each paid seat, so there is no separate subscription for Agents. Plane AI is not currently available on Free workspaces.

A typical agent run uses roughly 20 to 40 credits. Direct AI conversations draw from individual credits, and agent runs draw from the shared pool.

Where Agents go next

Today, agents take on bounded jobs: triaging a request, preparing a specification, summarizing activity, inspecting delivery risk, or handling another recurring piece of work with a clear scope.

We're working toward continuity. An agent should be able to stay with a body of work as it moves through steps, changes, and handoffs, without losing track of what it already knows. That's a bigger thing to delegate than a task, closer to an ongoing responsibility for a defined part of the workspace. We haven't shipped that yet.

As agents take on more, scope, access, escalation, and visibility have to get more explicit. Plane's job is to hold all of it in one place: the work and its state, the agent's instructions and tools, and the points where a human steps in.

One system for humans and agents

Native agents change who does what. Humans set direction, make trade-offs, review consequential changes, and own outcomes. Agents handle recurring execution within the scope and instructions they've been given. Plane keeps both working against the same work items, relationships, history, and handoffs, so an agent sees the same work a human sees and a human can pick up where the agent stopped.

As more execution moves to agents, I think the system of record has to become the system that coordinates that execution. That's what we're building Plane to be.

Try Plane Agents now