# Building the Platform for Agent Coordination

Tom Moor, Linear | AI Engineer World's Fair 2025 | 19:43

Source: https://www.youtube.com/watch?v=UG9IAdmi2Dg
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/building-the-platform-for-agent-coordination
Published: 2025-07-28
Tags: agents, design, tool-use, workflows

## TL;DR
- Linear began with small AI features because early model quality did not meet its bar for a general copilot.
- The company is making agents first-class users that can be assigned work, mentioned in conversations, and audited like human teammates.
- Linear's agent platform gives developers APIs, webhooks, permissions, and an SDK for building agents that work across team communication.

## Summary
Tom Moor describes Linear's shift from small AI features toward a platform where software agents work alongside engineering teams. Linear started its AI work in 2023 with summarization, embeddings, natural-language filters, and related-issue suggestions. The team avoided shipping a copilot because the quality was not good enough. Late 2024 brought better reasoning, planning, multimodal models, and larger context windows, which made more ambitious systems practical. Linear rebuilt its search foundation with hybrid search, Turbopuffer, and Cohere embeddings, then used it for product intelligence and customer-feedback analysis. Moor presents agents as cloud-based teammates that can create plans, open pull requests, investigate bugs, manage feature flags, and respond to customer reports. They have identities, permissions, histories, and audit trails in Linear. The talk also gives design guidance: agents should respond quickly, clarify their plans before acting, follow the conventions of the platform they use, and keep their output concise.

## Key ideas
### Linear treated AI as a search problem before treating it as an agent problem
[01:21](https://www.youtube.com/watch?v=UG9IAdmi2Dg&t=81s)
Linear's internal AI team began in early 2023 with summarization, similarity, and embeddings. The team quickly found that many useful features first needed to find the relevant information. Linear had been using Elasticsearch, then tested several vector databases and found trade-offs in each. It settled on OpenAI embeddings stored with pgvector on GCP, a pragmatic choice that fit the existing stack. This supported related-issue suggestions, natural-language filters such as "bugs assigned to me in the last two weeks that are closed," and automatic issue creation from Slack threads.

### Linear did not ship a copilot because the quality was below its bar
[03:39](https://www.youtube.com/watch?v=UG9IAdmi2Dg&t=219s)
During the early copilot wave, Linear tried building one and decided against releasing it. Moor says the quality did not meet Linear's standard, with both early model capability and the team's limited AI experience contributing. Instead, the company shipped small features that added value without forcing users to interact with an AI surface. Examples included natural-language filters and turning a Slack thread into a properly formed issue. Moor says users appreciated that these features were quiet and practical rather than putting AI into every part of the product.

### Better models made larger AI workflows less brittle
[04:33](https://www.youtube.com/watch?v=UG9IAdmi2Dg&t=273s)
Moor describes the end of 2024 as a turning point. Planning and reasoning models, multimodal APIs, much larger context windows, and DeepSeek changed what Linear's experiments could do. The team found that its systems felt smarter and were less fragile than earlier attempts. Linear rebuilt its search index around hybrid search and moved embeddings from OpenAI to Cohere after comparing the results for its domain. The new index used Turbopuffer and took weeks to backfill, but it gave the company a stronger base for features that needed to connect information across a workspace.

### Product intelligence combines retrieval with explicit reasoning steps
[06:13](https://www.youtube.com/watch?v=UG9IAdmi2Dg&t=373s)
Linear's product intelligence feature is a more advanced version of similar-issue matching. Its pipeline rewrites the query, searches with the hybrid engine, reranks the results, and applies deterministic rules. It produces a map of relationships from one issue to related issues, including an explanation of why they are related. Linear can use those relationships to suggest labels, assignees, possible duplicates, and projects. For a project or issue, the product can explain why a particular person or project may fit. Moor connects this to large workspaces where thousands of tickets need help before reaching engineers.

### Agents can work through Linear as members of the same team
[09:49](https://www.youtube.com/watch?v=UG9IAdmi2Dg&t=589s)
Linear's agent platform treats agents as infinitely scalable, cloud-based teammates. Agents can be assigned issues or mentioned in Linear like other users, then produce plans and pull requests. Codegen can also be reached through Slack or another communication tool, where a user can tell it to fix a Linear issue. Bucket's agent can create a feature flag and roll it out to a percentage of users without requiring every step to be issued as a separate command. Charlie can inspect an attached Sentry issue, recent commits, and the codebase to suggest a bug's cause and possible regression reasons.

### Agent activity needs its own workspace surfaces
[12:54](https://www.youtube.com/watch?v=UG9IAdmi2Dg&t=774s)
Moor says putting agents in the regular issue conversation is only an early version of the interface. Linear is building surfaces where users can inspect an agent's observations and tool calls, see what it is doing behind the scenes, and interrupt it. The same workspace could contain coding agents, product-management agents, and customer-support agents. Moor gives Intercom's Finn agent as an example: a user could say that a bug is fixed and ask Finn to reply to the customers who reported it. Agents would share a consistent interface while taking on different kinds of work.

### First-class agents need identity, permissions, and an audit trail
[14:44](https://www.youtube.com/watch?v=UG9IAdmi2Dg&t=884s)
In Linear, agents have identities and histories, and users can see everything they do through a complete audit trail. They are installed with OAuth, and administrators can manage an agent's access. Linear's GraphQL API lets agents do anything a human could do in the product, with granular scopes controlling access. New agent-specific webhooks notify developers when an agent is triggered or someone replies to it. Developers can also choose whether an agent is mentionable or assignable. Linear was working on an SDK to make these integrations easier than using the existing API directly.

### Good agents clarify their plan and behave like teammates
[16:25](https://www.youtube.com/watch?v=UG9IAdmi2Dg&t=985s)
Moor's guidance for agent builders starts with fast, precise responses when users trigger an agent. The first reply should confirm what the agent understood and what it will do. Agents should use the language and conventions of the platform where they appear, such as Slack or Linear. In Linear, an agent working on an issue should move it to in progress, and a reply in the thread should trigger a response without requiring another mention. Moor also advises agents to clarify their intent before acting, communicate a plan, ask for clarification, and avoid dumping large amounts of model-generated text into comments or issues.

## Notable quotes
- "We never shipped a co-pilot. We tried. It was like it was co-pilot season and we just the quality wasn't there." (03:39)
- "The way we're thinking about agents is as infinitely scalable cloud-based teammates." (09:49)
- "In Linear agents are first class users. They have identity, they have history, you can see everything they do, there's a full audit trail of those events." (14:44)
- "Don't be clever. A lot clarify your intent before acting." (18:30)
- "Be concise, be useful, be like a good teammate would be." (19:16)

## Tools & references mentioned
- Linear
- OpenAI
- GPT-3
- Elasticsearch
- Pinecone
- pgvector
- Google Cloud Platform
- Turbopuffer
- Cohere
- DeepSeek
- Codegen
- Bucket
- Charlie
- Sentry
- Intercom
- Finn
- Slack
- GraphQL
- OAuth

## Who should watch
- You are building AI features in a collaboration or project-management product and need an example of starting with search and small workflow improvements.
- Your team wants to expose coding or support agents through the same tools where people already assign work and communicate.
- You are designing agent integrations and need practical guidance on permissions, auditability, plans, interruptions, and response behavior.

## Related talks

- [Platforms for Humans and Machines: Engineering for the Age of Agents](https://aietalks.com/talks/platforms-for-humans-and-machines-engineering-for-the-age-of-agents) (Juan Herreros Elorza, Banking Circle, 21:15)
- [Building LinkedIn's GenAI Platform](https://aietalks.com/talks/building-linkedins-genai-platform) (Xiaofeng Wang, LinkedIn, 17:53)
- [Agents for Everything Else](https://aietalks.com/talks/agents-for-everything-else) (swyx, AI Engineer, 14:10)
- [How Building with AI Can Double the Throughput of Your Engineering Team](https://aietalks.com/talks/how-building-with-ai-can-double-the-throughput-of-your-engineering-team) (Brian Scanlan, Intercom, 21:49)
- [Building an Autonomous Engineering Org](https://aietalks.com/talks/building-an-autonomous-engineering-org) (Angie Jones, Agentic AI Foundation, 17:36)