Agents Without Overhead: How herdr-linear Accelerates the Workflow

There are two ways to build software projects: with an IDE as the command bridge, or with agents working in parallel on multiple tasks — whilst you yourself maintain the overview. I have been working with the second method for quite some time. And it looks like this:

The Status Quo: The IDE as a Bottleneck

Classic development with VS Code, JetBrains, or similar IDEs stops scaling at a certain problem: agents. When you run several AI agents in parallel — each on a different project or task — you are quickly slowed down by two problems:

Context Switching: An IDE is oriented towards a single focus. Multiple agents, multiple projects? You need multiple windows, workspaces, and mental models.
Monitoring Overhead: How do you know what your agents are doing at any given moment? One terminal window per agent is not a scalable solution.

The Solution: herdr + Moshi + Linear

My setup looks like this:

herdr: A modern agent runner that differs from the classic terminal. Instead of editing code in an IDE, you define agent panels — each agent runs independently, and the outputs are organised and visible at a glance.
Moshi: A monitoring and intervention tool. With it, you can observe your agents from anywhere and respond reactively to their requests without having to return to the IDE.
Linear: Your single source of truth for tasks, issues, and roadmap.

The combination is powerful: your agents work, you watch via Moshi, and when a decision is needed, you consult Linear — directly from herdr.

The only catch: that was still a context switch. The browser opens, Linear loads, you read the issue, make a decision, and return to herdr. That can be faster.

The Problem Solved: The herdr-linear Plugin

That is why I built a Rust plugin for herdr: herdr-linear.

The plugin does one thing very well: it brings your Linear issues directly into your herdr panels. You get:

View: Linear issues in the panel, without opening the browser.
Execute: Select one or more issues with <Enter> and run them in dedicated agent panels.
No Context Switch: Everything stays within the herdr workflow.

That may sound like a small feature. But it is a significant productivity leap when you are working with multiple agents.

The Use Case: ExamCraftAI

At the moment, we are actively putting this into practice with ExamCraftAI. This is a project that automatically generates learning questions and assessments from training materials — with a focus on complex visual content (technical drawings, floor plans, diagrams).

The workflow looks like this:

Planning in Linear: We define the work: Agent A generates questions from Material X, Agent B validates visual content, Agent C optimises difficulty.
View in herdr: All issues are visible within herdr — in the Linear panel.
Execute in parallel: We select three issues and start three agents. Each agent has its own panel.
Monitor via Moshi: Whilst they work, we watch via Moshi. If an agent needs input, we respond immediately.

This saves not only time — it also saves mental energy. No IDE windows to juggle, no constant tab-switching.

Why Open Source?

The plugin is open source (MIT licence), because the workflow itself is the point. It is not proprietary knowledge, but rather a practical answer to a problem that many developers working with agents will encounter.

If you work with herdr and use Linear, you can integrate the plugin directly into your environment. The code is on GitHub. Further details on installation and features can be found in the repository.

What Comes Next?

For ExamCraftAI, we are currently experimenting with even more integrations: trigger-based agent starts, automatic issue updates based on agent output, and feedback loops directly from Moshi.

But the plugin is finished and working. It demonstrates what the workflow looks like when you take agents seriously and align your toolchain accordingly.

If you are working with multiple agents in parallel and use Linear: give it a try. And if you need other integrations — the Rust plugin is a solid starting point to build upon.