At JetBrains, we build developer tools that help engineers stay focused on solving hard problems instead of fighting routine work.
Within JetBrains AI, we are collaborating with Zed on the Agent Client Protocol (ACP), an open protocol that lets AI coding agents work inside editors and IDEs. ACP is already supported in JetBrains AI Assistant, and the project is jointly governed by JetBrains and Zed. We see ACP as a long-term investment in interoperability, developer choice, and durable AI-powered workflows across the JetBrains ecosystem. (The JetBrains Blog).
ACP evolves in the open. Real-time coordination happens in Zulip, actionable work is tracked in GitHub Issues, longer-form discussion happens in GitHub Discussions, and substantial protocol changes move through the RFD process. We need someone who can help JetBrains shape that work from the product side: define the right developer scenarios, align internal and external stakeholders, and turn ecosystem needs into clear priorities for JetBrains and for the protocol. (Agent Client Protocol).
This is not a generalist product management role. It is also not a pure protocol engineering role. It sits between developer-experience product work and protocol evolution.
This role is often a strong fit for someone who has spent several years as a software engineer – ideally on APIs, SDKs, web/backend systems, libraries, frameworks, or platform integrations – and then moved into product management or a hybrid product or engineering role.
This will be an exciting opportunity if you:
- Want to shape an open interoperability layer for AI-native software development.
- Enjoy turning messy cross-team technical discussions into clear product direction.
- Like working with engineers, agent developers, and external partners to make complex systems usable and durable.
In this role, you will:
- Identify and prioritize the developer scenarios JetBrains should support through ACP in JetBrains IDEs.
- Study how those scenarios are already handled in CLIs and agents, and define coherent IDE-native flows that JetBrains should support.
- Work on examples such as plan mode, sub-agent workflows, or agent-to-agent communication, and turn them into clear scenario definitions and product requirements.
- Talk to JetBrains product and engineering teams, external agent developers, and partners to collect requirements, constraints, and compatibility concerns.
- Turn those inputs into crisp problem statements, GitHub Issues, success criteria, and roadmap priorities.
- Partner closely with protocol engineers and ACP maintainers to translate validated scenarios into protocol proposals, implementation requirements, and delivery plans.
- Represent JetBrains in regular protocol conversations with Zed and the broader ACP community, helping drive alignment on what belongs in the protocol, what should remain implementation-specific, and what should wait.
- Balance immediate JetBrains product needs against long-term protocol design concerns such as extensibility, backward compatibility, clarity, and ecosystem fit.
- Define and monitor the right telemetry and product metrics for ACP-related surfaces, including agent installation success, authentication success, protocol feature adoption, task completion, reliability, and developer satisfaction.
- Help JetBrains make long-term, product-quality decisions about supporting ACP across multiple IDE experiences.
- Communicate decisions, trade-offs, and priorities clearly to highly technical stakeholders inside and outside JetBrains.
We’ll be happy to have you on our team if you:
- Have 1-4 years of product management experience, or equivalent end-to-end ownership in a hybrid engineering/product role.
- Have a substantial software engineering background and hands-on production coding experience in real systems.
- Understand how modern web and integration primitives work in practice, including OAuth, WebSockets, HTTP, JSON-RPC, and service-to-service communication.
- Are comfortable reasoning about APIs, protocols, payload schemas, event-driven systems, authentication flows, local/remote execution, and backward compatibility.
- Can discuss technical details credibly with engineers and agent developers, even when the conversation goes deep into protocol behavior, edge cases, or extensibility.
- Can take raw technical feedback and turn it into clear user scenarios, requirements, issue tickets, and written decisions.
- Have strong product judgment and can distinguish between a JetBrains-specific UX choice and a protocol-level capability that should be standardized.
- Have a data-driven mindset and know how to combine telemetry, qualitative feedback, and ecosystem signals in product decisions.
- Have strong spoken and written English.
We’d be especially thrilled if you:
- Previously worked as a senior software engineer, staff engineer, library/framework maintainer, SDK owner, or platform/integration engineer before moving closer to product work.
- Have experience with developer tools, IDEs, AI coding agents, CLI workflows, or interoperability layers such as LSP, MCP, or ACP.
- Have contributed to open-source projects or standards-like processes.
- Are comfortable working in public GitHub workflows with Issues, Discussions, pull requests, and proposal documents.
- Have built or supported products where compatibility, extensibility, and future-proofing mattered.
- Use JetBrains IDEs regularly.
#LI-KL1