TNS Agents Livestream: Tom Moor (Linear) and Andrew Milich (Cursor AI)

Key Concepts

• AI Agents: Software entities designed to automate tasks, particularly in coding and software development.
• Cursor: An AI-powered code editor and development tool.
• Linear: An issue tracking and project management platform.
• Agent API: A dedicated API for enabling agents to interact with Linear.
• MCP (Machine Communication Protocol): A protocol for agents to access and utilize data from various sources.
• Background Agent: An AI agent that runs autonomously in the background, performing tasks without direct user intervention.
• Code Review Agents: AI agents designed to automate and improve the code review process.
• Product Intelligence: An agentic system within Linear that researches and triages incoming issues.

Cursor and Linear Partnership

• Partnership Goal: To integrate AI agents into the software development workflow, allowing agents to handle tasks assigned through Linear.
• Integration Functionality:
  • Assigning issues in Linear to Cursor, triggering the agent to start working on the task.
  • Dedicated thread for conversation and feedback between the user and the agent.
  • Cursor provides updates on its progress, including files being examined and questions that arise.
  • Aims to automate tasks from issue creation to pull request.
• Linear's Agent API: Facilitates seamless integration by providing a dedicated API for agents to interact with Linear's features.
• First-Class Citizen: Linear aims to make agents first-class citizens within their platform.
• Shared Slack Channel: Used for exchanging ideas, bugs, and feedback between Cursor and Linear.

Building with AI Tools Today

• Andrew Milik's Background: Previously worked on Skiff (privacy-focused email) which was acquired by Notion. Now Head of Product Engineering at Cursor.
• Cursor's Growth: Experienced organic growth, attracting users across different roles (engineers, PMs, data scientists).
• Cursor's Focus: Building a planning-focused mode and improving agent performance, including terminal usage.
• Tom Moore's Background: Works at Linear since 2021, also runs Outline (open-source team documentation product).
• Linear's Mission: To provide an excellent issue tracking tool and a platform for building products end-to-end.
• Linear's Customers: Primarily software companies, but also companies with software components (e.g., car companies, aerospace).

The Power of the Terminal

• Terminal Access: Giving agents access to the terminal significantly improves their capabilities.
• Complexity: Terminals are messy due to different shells (Zsh, Bash, PowerShell) and custom configurations.
• Reliability: The main motivation for terminal access was to improve the reliability of running common commands like Git.
• Use Cases: Agents can test APIs, start dev servers, and inspect program output using the terminal.

Agent API Deep Dive

• Evolution: Linear initially used its existing GraphQL API for agents, but later developed a dedicated Agent API.
• Agent Session: The Agent API introduces the concept of an "agent session" to manage interactions and context.
• Functionality: The API allows agents to access various Linear surfaces, handle comments and threads, and abstract away the user interface.
• Benefits: Simplifies integration for agent providers and provides a consistent way for agents to interact with Linear.

Background Agents: Capabilities and Challenges

• Functionality: Background agents can clone repositories and run tasks autonomously in the cloud.
• Transparency: Users can see the agent's progress in real-time through a conversation interface.
• Developer-Centric Approach: Designed for professional engineers who review the agent's output and iterate on it.
• Adoption: Enterprises are adopting background agents to provide engineers with AI-powered assistance.
• Context is Key: Linear provides valuable context to agents, such as stack traces, support tickets, and debugging conversations.
• Improving Ticket Quality: Teams are learning to write better tickets to provide agents with the necessary information.

Best Practices for Using AI Agents

• Clear Prompts: Provide well-specified prompts to guide the agent's work.
• Team Setup Context: Provide agents with information about the codebase and team-specific instructions.
• MCP Integration: Connect agents to MCP servers to access documentation and other resources.
• Chunking Work: Break down complex tasks into smaller, manageable chunks.
• Leveraging Existing Pull Requests: Point agents to similar pull requests as templates.
• Instruction Files: Use markdown files in the codebase to provide instructions for common tasks.
• Custom Environments: Set up custom base images and environments for background agents.
• Focus on Speed: Optimize development processes to enable faster iterations.

Cost Considerations

• Cost-Effectiveness: Using AI agents is generally inexpensive compared to the cost of engineers' time and salaries.
• Prioritization: Focus on the value provided by agents rather than optimizing token usage.
• Product Intelligence: Linear's product intelligence system runs agents on every incoming issue, demonstrating the value of AI-powered research.

The Future of AI Agents

• Agent Interaction: Exploring how agents can interact with each other and coordinate on complex tasks.
• User Interface Evolution: Moving away from right sidebar agents to more front-and-center interfaces.
• Planning-Focused Mode: Agents assisting with planning and scoping tasks, potentially generating markdown files for team collaboration.
• Seamless Integration: Connecting agents across different platforms (Linear, Slack, GitHub) to maintain context and knowledge.
• Linear Agent: Developing a Linear agent to personify the platform and enhance user interaction.
• AI Email: Addressing the unsolved problem of AI-powered email assistance.
• Home Assistants: Integrating AI into home assistants to improve their capabilities.

Challenges and Limitations

• Agent Performance: The quality of code generated by agents can still be improved.
• User Input: Agents require clear and well-specified prompts to perform effectively.
• Attention Spans: People may not naturally gravitate towards running multiple agents simultaneously.
• Tooling: The tooling for AI agents is still evolving, particularly in terms of integration and interaction.

Notable Quotes

• Andrew Milik: "I loved just the day-to-day of using the product and then also found it really creative where it can let you build things that were inaccessible before."
• Tom Moore: "Linear is a place where you kind of decide and plan what work gets done."
• Tom Moore: "We've seen like teams start to kind of get better at writing tickets because they know that they're going to be consumed by AI."
• Andrew Milik: "I think the results from the cursor agent could get better and better and better."
• Tom Moore: "It's not unusual even on our own team to see an issue that has just a title and then someone says at cursor fix this and it's like what did you expect to happen exactly here?"

Technical Terms

• CLI (Command Line Interface): A text-based interface for interacting with a computer system.
• IDE (Integrated Development Environment): A software application that provides comprehensive facilities to computer programmers for software development.
• WSL (Windows Subsystem for Linux): A compatibility layer for running Linux binary executables natively on Windows.
• GraphQL: A query language for APIs and a server-side runtime for executing queries.
• Sentry: An error tracking and performance monitoring platform.
• DataDog: A monitoring and analytics platform for cloud-scale applications.

Synthesis/Conclusion

The conversation highlights the growing integration of AI agents into software development workflows, particularly through the partnership between Cursor and Linear. The integration aims to automate tasks, improve developer productivity, and enhance collaboration. While AI agents offer significant potential, challenges remain in terms of agent performance, user input, and tooling. The speakers emphasize the importance of clear prompts, team context, and a developer-centric approach to ensure successful adoption. The future of AI agents involves seamless integration across platforms, improved user interfaces, and the ability for agents to interact and coordinate on complex tasks. Despite the challenges, the speakers are optimistic about the future of AI in software development and its potential to transform the way teams work.