Linear

Linear is the first-party integration building for Linear.app — a Backlog Planner, an Issue Writer, and an Issue Resolver who share an embedded Linear web UI inside the building.

At a glance

Default agents: Backlog Planner, Issue Writer, Issue Resolver
Best for: Triaging an existing Linear backlog, writing new issues without leaving Viberia, and shipping fixes that flow back to the issue
Skills it ships with: /plan-sprint, /whats-next, /backlog-review, /add-issue, /add-issue-advanced, /resolve-issue, /status-check
Place from: Building Type Drawer → Linear
Requires: The Linear MCP server configured with an API key. See Linear integration.

How It Works

The Linear building has two parts: three agents who know your backlog, and an embedded Linear web UI rendered inside the Building Window so you can see what they’re seeing.

The agents reach Linear through the Linear MCP server, which has to be configured once at the user or project level before the building is useful. Once configured, every agent in the building inherits access. They can list issues, read details, create new issues, post comments, and update issue states the same way the Linear app would let you.

The embedded Linear web UI is rendered in the building window. It is the real Linear app inside a webview, scoped to your workspace, so you can scan the board while talking to the agents. When the Issue Writer creates an issue, the embedded view updates the same way the desktop or browser app would. The agents talk; you watch the board.

The three roles are split by what part of the issue lifecycle they own. The Backlog Planner thinks about the backlog as a whole — what’s worth doing next, how to slice a sprint, what’s stale. The Issue Writer drafts and files issues, with optional richer fields when you want them. The Issue Resolver moves issues to Done, including the actual fix when the project’s code is reachable.

This is one of the few buildings where it pays to use all three agents in the same session. Talk to the Backlog Planner about scope, hand specific items to the Issue Writer to create, and hand other items to the Issue Resolver to close out.

Default agents

Backlog Planner. The Backlog Planner is your sprint-and-triage agent. Talk to them when you want a sprint planned out of the current backlog (/plan-sprint), when you want a short answer to “what should I work on next” (/whats-next), or when you want a structured pass over what’s in the backlog now (/backlog-review). The Backlog Planner reads the backlog, proposes groupings, and explains trade-offs — they do not write issues themselves.
Issue Writer. The Issue Writer files new Linear issues. Talk to them when you have a bug to log, a feature to request, or a chunk of work to slice into issues. They ship with /add-issue for the short form (title, description, basic labels) and /add-issue-advanced when you want to specify project, milestone, priority, assignee, and custom fields. The Issue Writer reads back what they’re about to file before submitting, so you can correct it without round-tripping through the web UI.
Issue Resolver. The Issue Resolver closes out issues. Talk to them when an issue is ready to be resolved (/resolve-issue), when you want the state of one or more issues confirmed (/status-check), or when you want a fix implemented and the issue closed in one motion. The Issue Resolver can lean on a Developer (typically in CodeForge) for the actual code change, then update Linear when the change is in.

Configuration

The Linear building is more configuration-sensitive than most because it depends on an external service. Setup happens in two places.

First, configure the Linear MCP server. From either Settings → MCP Servers (user scope) or the building’s MCP section (per-building scope), install the linear MCP server. You’ll need a Linear API key with read/write scopes to your workspace. The /learn-mcp skill has the canonical install steps. The full walkthrough lives in the Linear integration page.

Second, configure the building itself. From the Linear Building Window you can:

Override agent prompts — for example, give the Backlog Planner a house ranking model, or constrain the Issue Writer to a specific issue template.
Set per-agent models. Backlog Planner often benefits from a stronger reasoner; the Writer and Resolver can run on faster models.
Scope the embedded Linear UI — by default it loads your workspace root; you can change the default URL to a team, project, or saved view.

The seven skills under At a glance are installed by default. Disable any per agent if you want to constrain the workflow.

Skill	Agent	What it does
`/plan-sprint`	Backlog Planner	Proposes a sprint from the current backlog with rationale.
`/whats-next`	Backlog Planner	Returns a short, ordered “do these next” list.
`/backlog-review`	Backlog Planner	Structured pass over the backlog flagging stale, mislabeled, and duplicate items.
`/add-issue`	Issue Writer	Files a basic issue (title, description, labels).
`/add-issue-advanced`	Issue Writer	Files an issue with full fields (project, milestone, priority, assignee, custom).
`/resolve-issue`	Issue Resolver	Moves an issue to Done, optionally implementing the fix first.
`/status-check`	Issue Resolver	Reports the state of one or more issues by ID or filter.

Typical workflow

Configure the Linear MCP server first. Without it, the agents can’t reach your workspace. See the Linear integration page for the full setup.
Place the Linear building in the relevant project’s territory. If your project is tied to a single Linear project, point the embedded UI at that project’s URL in the building settings.
Open the building. The embedded Linear web view loads on one side; the three agents are listed on the other.
Talk to the Backlog Planner first. Ask /whats-next or /plan-sprint. Read the result against what you see in the embedded UI.
For each item you decide to do, hand it to the appropriate agent: /add-issue (or /add-issue-advanced) on the Issue Writer if it doesn’t exist yet, or /resolve-issue on the Issue Resolver if it does and you’re ready to close it.
The Issue Writer drafts the issue, shows you the payload, and files on your approval. The Issue Resolver implements (if needed) and closes.
Use /status-check from the Issue Resolver to confirm state at any point. The embedded Linear UI will show the same state.

Limitations

The building does not work without the Linear MCP server configured. You will see clear errors from the agents if the MCP is missing or the API key has insufficient scopes.
The embedded Linear UI is the real Linear web app running in a webview. It needs network access. Offline use is not supported.
The agents act with the permissions of the API key you provided. If the key is read-only, the Issue Writer and Issue Resolver will fail to create or update issues. Provision the key carefully if you’re paranoid about write access.
The Issue Resolver can implement fixes only if the project’s code is reachable — typically through the project’s folder_path. For Linear projects that aren’t backed by a local repo, the Issue Resolver can update Linear state but not write code.
Sprint and “what’s next” recommendations from the Backlog Planner are advisory. They reflect the agent’s reading of the backlog at that moment and don’t account for context only you have. Use them as a starting point, not a verdict.
One Linear workspace per Linear building. If you work across multiple workspaces, you’ll want either separate MCP configurations per project or separate Viberia projects per workspace.

Linear integration — full setup of the Linear MCP server, API keys, and scopes.
MCP Servers — how MCP scoping works generally (user, building, agent).
CodeForge — pair when the Issue Resolver needs a Developer to implement a fix.
Skills (Slash Commands) — how /... commands work in general.