A practical guide to Linear integrations with AgentKit

The idea of AI agents handling our workflows isn't some far-off sci-fi concept anymore. With tools like Linear opening up to AI, teams are rightly getting excited about automating the tedious stuff, think ticket triage, status updates, and all the other little tasks that eat up the day. The goal is simple: let an intelligent assistant handle the grunt work so humans can focus on what they do best.

OpenAI’s AgentKit is a powerful new toolkit for building custom AI agents, so it's natural to wonder if you can use it to create some slick Linear integrations with AgentKit. Can you really build a seamless bridge between these two platforms?

Well, yes and no. This guide will walk you through what’s possible, the technical reality of building it, where AgentKit falls short for support teams, and why there’s probably a much simpler way to get this done.

What are Linear and OpenAI's AgentKit?

Before we get into the weeds of an integration, let’s quickly cover what each of these tools actually does. They’re both built for modern teams, but they solve very different problems.

What is Linear?

Linear is a project management and issue-tracking tool designed for software and support teams that value speed. If you've ever found yourself fighting with the slow, clunky interface of older systems like Jira, Linear feels like a breath of fresh air. It’s fast, efficient, and has a clean user experience that helps you manage tasks and bugs without all the extra bloat.

What’s really interesting is that Linear has started opening its doors to AI agents. By providing a dedicated API, they’re clearly signaling a move toward more intelligent automation, basically inviting developers to build on top of their platform.

What is OpenAI’s AgentKit?

OpenAI’s AgentKit isn't a plug-and-play product. It’s a full-blown toolkit for developers who want to build, test, and deploy their own AI agents from scratch. Think of it less like a finished car and more like a garage full of professional-grade tools for building one yourself.

It comes with a few key parts:

• Agent Builder: A visual canvas where you can drag and drop components to design an agent's workflow and logic.

• ChatKit: Pre-built UI components so you can create a chat interface for users to interact with your agent.

• Evals Framework: A system for testing your agent to make sure it actually works reliably before you unleash it.

This workflow shows how different components of OpenAI's AgentKit, such as the Agent Builder and ChatKit, work together when considering Linear integrations with AgentKit.

The whole idea behind AgentKit is to help developers get from a rough prototype to a production-ready AI agent that can handle complex tasks.

The potential: What these integrations could do

Let's daydream for a minute. If a perfect integration between Linear and AgentKit existed, what could it actually do for a busy support or engineering team? The ideas are pretty cool.

• No more manual ticket triaging: An AI agent could scan new issues in Linear the moment they're created. Based on the ticket’s text, it could automatically add labels like "bug" or "feature-request", set the right priority, and assign it to the right team.

• Get the TL;DR on long issues: We've all seen those Linear tickets with a novel's worth of comments. An agent could read the entire thread and spit out a quick summary for a manager who just needs the highlights.

• Draft replies to user feedback: When a user leaves feedback in a Linear ticket, an agent could figure out the sentiment and draft a thoughtful, on-brand response. A team member could then give it a quick once-over and hit send.

• Flesh out vague bug reports: A user submits a ticket that just says, "the app is crashing." Instead of a developer having to chase them for details, an agent could chat with the user to get the important info, reproduction steps, browser version, console logs, and add it all to the Linear ticket.

These aren't just small improvements; they could seriously boost a team's productivity. But as you'll see, building them with AgentKit isn't as simple as connecting two apps.

The reality check: Building the integration

This is where we move from the "what if" to the "how-to," and the technical hurdles start to pop up. AgentKit is a developer toolkit, which means it expects you to do the heavy lifting.

AgentKit connects to outside tools like Linear through something called a Connector Registry. To make this work, you need to use a standard called the Model Context Protocol (MCP) or build custom API calls. Since there’s no pre-built Linear connector available, you have only one option: build it yourself.

And this is where the dream of easy automation runs into a bit of a wall.

The engineering headache

Building, hosting, and maintaining a custom connector is a real project. It’s not something you can knock out in an afternoon. You need dedicated developers to write the code, set up a server to run it, and then keep it working every time Linear or AgentKit updates their APIs. This completely goes against the whole idea of "no-code" automation and turns what should be a simple task into a full-blown software project.

Manually updating knowledge

One of the biggest operational flaws with AgentKit is how it learns. To give an agent any context, you have to manually upload files. If your team’s troubleshooting guides and support policies live in tools like Confluence or Google Docs, you'll be stuck in a frustrating cycle of exporting documents and re-uploading them just to keep your agent from giving outdated answers. For any team that moves fast, this is a non-starter.

This is a massive difference compared to platforms like eesel AI, which offers one-click integrations that automatically and continuously sync with your knowledge sources. Your agent is always up-to-date, with zero manual work needed from you.

Why workflows get messy

The visual Agent Builder looks great for mapping out simple, step-by-step processes. But the real world of customer support is rarely that clean. It's full of "if this, then that" conditions, weird edge cases, and exceptions to the rule. Trying to map all of that out in Agent Builder can create a "spaghetti diagram" of tangled branches that’s a nightmare to debug or update. The more complex your support logic, the less useful the visual builder becomes.

AgentKit's pricing and gaps

Beyond the tech side of things, there are a few other limitations that make AgentKit a tough sell for anyone focused on support automation.

Unpredictable, usage-based pricing

AgentKit itself doesn't have a monthly fee, but you pay for everything it does via OpenAI's standard API pricing. Every question a user asks and every task the agent performs chews through tokens, and you get billed for all of it.

A screenshot of the OpenAI API pricing page, which applies to usage-based costs for Linear integrations with AgentKit.

This model makes your costs completely unpredictable. A sudden jump in support tickets or a slightly inefficient agent could leave you with a surprisingly high bill at the end of the month. It makes budgeting almost impossible and basically penalizes you for growing.

That's a world away from the straightforward pricing of platforms like eesel AI. Our plans are based on a set number of interactions, with no weird per-ticket or per-resolution fees. You know exactly what you’re paying each month, so you can scale without worrying about surprise costs.

Missing key features for support teams

At its heart, AgentKit is a general-purpose toolkit for developers. It wasn't built with the specific needs of a support or ITSM team in mind. Because of that, it's missing some critical features you'd want before letting an AI handle customer interactions.

Here’s a quick comparison:

Feature	OpenAI AgentKit	eesel AI
Train on Past Tickets	No. You have to prep all the data manually.	Yes. It automatically learns your tone and solutions from your past conversations.
Risk-Free Simulation	Basic preview only. No way to test on real data at scale.	Yes. Simulate the AI on thousands of your past tickets to see how it would perform before you turn it on.
Gradual Rollout	No. You'd have to code this yourself.	Yes. Easily control which tickets the AI handles, whether by queue, topic, or customer.
Support-Specific Actions	Requires custom code for every single action.	Yes. One-click setup for common actions like tagging, triaging, and closing tickets.

The difference is pretty clear. AgentKit gives you a box of parts and tells you to get building. eesel AI gives you a solution that’s specifically designed to solve the problems you’re actually dealing with.

A powerful toolkit, but not the right tool for this job

The idea of building Linear integrations with AgentKit is genuinely exciting and shows where automation is headed. But for now, the reality is that it demands a lot of custom development, creates ongoing maintenance work, and just isn't optimized for what support and IT teams need.

AgentKit is a fantastic toolkit if you're a developer building a brand-new AI application from the ground up and have the team to manage all the infrastructure.

This video provides a comprehensive overview of the lessons learned from building AI agents, which is relevant context for anyone considering Linear integrations with AgentKit.

But for support and ITSM teams who just want to automate workflows in Linear, Zendesk, or another help desk, a purpose-built platform is a much better way to go. You need something that works right out of the box, connects to your tools in a few clicks, and comes with the safety and control features that are essential for customer-facing AI.

Ready to automate your support workflows in minutes, not months? eesel AI connects directly to your help desk and knowledge sources, letting you build powerful AI agents with no custom coding. Try it for free or book a demo to see it in action.