{"jobs":[{"id":"06defc75-e0d5-4326-875f-87a8e2f96c92","title":"Software Engineer, Apps & Agents","department":"Engineering","team":"Engineering","employmentType":"FullTime","location":"Palo Alto","secondaryLocations":[],"publishedAt":"2026-07-09T05:35:52.433+00:00","isListed":true,"isRemote":false,"workplaceType":"OnSite","address":{"postalAddress":{"addressRegion":"California","addressCountry":"United States","addressLocality":"Palo Alto"}},"jobUrl":"https://jobs.ashbyhq.com/ollama/06defc75-e0d5-4326-875f-87a8e2f96c92","applyUrl":"https://jobs.ashbyhq.com/ollama/06defc75-e0d5-4326-875f-87a8e2f96c92/application","descriptionHtml":"
Ollama is the most popular way for developers to access open models. What started as an open-source, local-first runtime is now the largest developer network in the open-model ecosystem, with 8.9 million monthly active developers and more than 67,000 community-built integrations. We're backed by Y Combinator, Benchmark, 8VC, and Theory Ventures.
Our team is small and talent-dense. We're flat, low-ego, and fast-moving. We like people who think from first principles, have strong product instincts, and care deeply about making software feel simple and delightful.
You'll shape how people use Ollama across the desktop app, CLI, and tools they already use. A major part of the role is making open models work well with existing agent harnesses, coding tools, IDEs, and desktop applications.
This is a product engineering role with broad ownership. You'll design interfaces, build native and backend systems, create integrations, and test complete user journeys across local and cloud models.
Build and refine Ollama's desktop app, CLI, onboarding, and more.
Make agents and developer tools easy to connect to Ollama.
Build first-class integrations while developing reusable systems that let others create and maintain their own.
Ensure local and cloud models work reliably across different tools and agent harnesses.
Test integrations through real workflows and turn recurring failures into durable compatibility improvements.
Work across native applications, Go services and APIs, and web product surfaces.
Partner with model and inference engineers to ship new models with appropriate capabilities, defaults, and integration support.
You've built a thoughtful developer product that real people use.
You combine strong engineering fundamentals with product judgment and visual attention.
You're comfortable owning ambiguous work from exploration through implementation and polish.
You enjoy debugging behavior across processes, configuration files, APIs, native applications, and third-party tools.
You can simplify complex systems without hiding important behavior from users.
You care about state preservation, recovery, compatibility, and the details that make integrations trustworthy.
You're comfortable working across several parts of the stack. Experience with Go, TypeScript, React, or similar technologies is useful.
You test your work hands-on and recognize when technically correct behavior still produces a poor experience.
You make good decisions in gray areas by weighing user needs, technical constraints, data, and product taste.
You use agents to help you prototype, iterate, and ship to production fast.
Partner with model and inference engineers to ship new models with appropriate capabilities, defaults, and integration support.
You've built an agent, contributed to an agent harness, or modified one enough to understand how models, tools, context, permissions, and configuration interact.
You have experience building developer tools, native desktop applications, IDE extensions, or integrations with third-party software.
You've worked with local inference, hosted models, or products that must behave consistently across both.
You've built something with Ollama!
Ollama is the most popular way for developers to access open models. What started as an open-source, local-first runtime is now the largest developer network in the open-model ecosystem: 8.9 million monthly active developers and over 67,000+ community-built integrations. We're backed by Y Combinator, Benchmark, 8VC, and Theory Ventures.
Our team is small and talent dense. We're flat, low-ego, and fast-moving. We like people who are truth-seeking, passionate, design-driven, and who enjoy shipping code.
You'll work on the heart of Ollama — the local runtime that runs open models on developers' own machines. It loads models, manages memory, drives GPU acceleration across NVIDIA, AMD, Intel, Qualcomm, and Apple Silicon (including our MLX integration), and makes all of it feel instant. You'll work in Go and C/C++ and touch the model formats and inference engines underneath, shipping to macOS, Linux, and Windows across an enormous range of hardware.
Make open models run fast and reliably on consumer and enterprise hardware — from a MacBook Pro to server-grade NVIDIA GPUs.
Own pieces of the runtime: model loading & scheduling memory management, quantization, GPU hardware backends.
Integrate new model architectures and quantization formats so the latest open models work on day one.
Improve cold-start, time-to-first-token, and throughput
Partner with model labs and hardware vendors on early access and deep integrations.
Ship in the open: Ollama is open source, and you'll work with the community
Add support for a new model family end-to-end — format parsing, weights loading, and the defaults that make it useful out of the box.
Cut cold-start for a popular model in half by streaming weights and lazy-loading layers.
Land a new quantization format so a 70B model runs on a single consumer GPU.
Wire up a new GPU backend and find a 2x throughput win with kernel selection and memory tuning.
Improve the \"Auto\" experience — picking the right model and settings for a machine's hardware without the user thinking about it.
You have strong systems fundamentals and are comfortable in Go, C, or C++
You've worked close to the metal — GPU compute, inference, game engines, databases, OS, or networking.
You care about performance and have profiled and optimized real workloads.
You're comfortable shipping to millions of users and handling the long tail of hardware and OS combinations.
Bonus: experience with model quantization, GPU programming (CUDA/Metal/SYCL), Apple MLX
Ollama is the most popular way for developers to access open models. What started as an open-source, local-first runtime is now the largest developer network in the open-model ecosystem: 8.9 million monthly active developers and over 67,000+ community-built integrations. We're backed by Y Combinator, Benchmark, 8VC, and Theory Ventures.
Our team is small and talent dense. We're flat, low-ego, and fast-moving. We like people who are truth-seeking, passionate, design-driven, and who enjoy shipping code.
You'll build Ollama’s cloud, a scalable inference platform that lets developers run large, capable open models in their workflow. You'll work on high-throughput, low-latency distributed systems — inference serving, GPU fleet management, routing, metering, and the platform that Pro, Max, Team, and Enterprise customers rely on to process trillions of tokens.
Build and scale the inference platform that serves every request from ollama.com.
Design the routing and capacity layer that places workloads across GPUs and regions for cost, latency, and availability.
Own multi-tenant infrastructure: isolation, quotas, usage metering, billing, and Pro/Max/team/enterprise tiering.
Build the reliability, observability, and cost controls for our team and customers
You have deep experience with high-throughput, low-latency distributed systems — inference serving, traffic routing, real-time data pipelines, or large-scale APIs.
You're comfortable with cost/performance tradeoffs at scale and have owned a production service end-to-end.
You've worked with Kubernetes, GPU scheduling, or inference infrastructure.
You think in terms of reliability, SLOs, and honest capacity planning.
Bonus: experience building an inference platform, GPU fleet management, or billing/metering for an AI service.
Ollama is the most popular way for developers to access open models. What started as an open-source, local-first runtime is now the largest developer network in the open-model ecosystem: 8.9 million monthly active developers and over 67,000+ community-built integrations. We're backed by Y Combinator, Benchmark, 8VC, and Theory Ventures.
Our team is small and talent dense. We're flat, low-ego, and fast-moving. We like people who are truth-seeking, passionate, design-driven, and who enjoy shipping code.
You'll be a founding account executive at Ollama. You'll work directly with company’s founders to help growing teams be successful with the product.
Help customers looking to grow with Ollama’s team and enterprise plans be successful
Be the voice of the customer inside Ollama.
Partner with product and engineering on ROI cases, and feed field signal back into pricing, packaging, and features.
Build the sales playbook, collateral, and CRM process from scratch
You've been an account executive at a developer-tools, open-source, infrastructure, or product-led company and closed real enterprise deals.
You're helpful to technical buyers and comfortable in the details of how engineers adopt and deploy software.
You can layer an enterprise motion on bottoms-up adoption while keeping what developers love.
You thrive in ambiguity and move fast — you'd rather ship a v1 motion and iterate.
Ollama is the most popular way for developers to access open models. What started as an open-source, local-first runtime is now the largest developer network in the open-model ecosystem: 8.9 million monthly active developers and over 67,000+ community-built integrations. We're backed by Y Combinator, Benchmark, 8VC, and Theory Ventures.
Our team is small and talent dense. We're flat, low-ego, and fast-moving. We like people who are truth-seeking, passionate, design-driven, and who enjoy shipping code.
You'll build the systems and automation that power Ollama's go-to-market — the connective tissue between product, sales, and customer engineering. This is a hybrid engineering role for someone who thinks like a builder and cares about go-to-market. You'll instrument Ollama’s sales funnel, wire product-usage signals into the sales motion, automate Ollama’s customer funnel, and build the internal tools to help map out customer use cases better.
Instrument the customer funnel from first local install to cloud, team, and enterprise
Wire CRM, product analytics, billing, and communication tools into one coherent GTM stack
Build internal tools and workflows that let GTM move fast without a big team
Run experiments on conversion across the funnel and decide with data
Partner with sales, customer engineering, product, and PMM
You're an engineer who wants to work on revenue, or a GTM-leaning builder who can code
You've built internal tools, data pipelines, or revenue growth systems
You have strong full-stack and data skills
You think in funnels, experiments, and measurement
You're comfortable in ambiguity and ship fast
Ollama is the most popular way for developers to access open models. What started as an open-source, local-first runtime is now the largest developer network in the open-model ecosystem: 8.9 million monthly active developers and over 67,000+ community-built integrations. We're backed by Y Combinator, Benchmark, 8VC, and Theory Ventures.
Our team is small and talent dense. We're flat, low-ego, and fast-moving. We like people who are truth-seeking, passionate, design-driven, and who enjoy shipping code.
You'll own the experience of the developers who rely on Ollama every day. You'll be the connective tissue between our users and the product: spotting patterns in where developers get stuck and turning them into fixes, better error messages, docs, and product improvements. You'll ship code to Ollama and its supporting systems, with the support queue as your lens on what matters most to users.
Build and automate Ollama's support systems
Own the support queue: triage, reproduce, and resolve issues from developers running Ollama across every platform and environment
Engage with Ollama's open-source community on GitHub and Discord — triaging issues, answering questions, and representing the team in public
Fix bugs in Ollama itself — you're an engineer, not an escalation layer
Design and build automation for our support systems: triage tooling, diagnostics, self-serve debugging, and internal dashboards
Identify patterns in user issues and communicate them clearly to product and engineering — be the voice of the customer inside Ollama
Work directly with users, from individual developers to large teams, to unblock them and make them successful
Improve docs, error messages, and diagnostics so the next user never hits the same problem
You're a software engineer who genuinely enjoys helping users — maybe you've done support engineering, developer experience, or you're the person on your team who answers questions and files the fix
You're hands-on — you can reproduce an unfamiliar environment, read a stack trace, run models, and debug a real setup
You are comfortable diving into a large open-source codebase (Go experience is a plus)
You'd rather build a system that eliminates a class of problems than close the same ticket twice
You communicate clearly and with empathy, and can simplify complex setups for developers
You're comfortable in ambiguity and move fast
Bonus: experience with model deployment, GPU/ML infrastructure, or developer tools
Ollama is the most popular way for developers to access open models. What started as an open-source, local-first runtime is now the largest developer network in the open-model ecosystem: 8.9 million monthly active developers and over 67,000+ community-built integrations. We're backed by Y Combinator, Benchmark, 8VC, and Theory Ventures. Our team is small and talent dense. We're flat, low-ego, and fast-moving. We like people who are truth-seeking, passionate, design-driven, and who enjoy shipping code.
About the role
We're looking for a Developer Relations Engineer to own the strategy, execution, and outcomes for Ollama. You will work directly with developers, model labs, 3rd party integrations, hardware companies, and industry partners to drive adoption, accelerate development, and build long-term ecosystem relationships.
This role is a highly outward-facing, high-impact role where you will be the public face of Ollama. You won't just talk about Ollama, you will build engineering content, including short demos on Ollama’s socials, deep-dive technical blog posts, videos, and tutorials using open models.
What you’ll do
Actively champion Ollama in existing communities, and nurture the developer ecosystem.
Partner with model labs and hardware companies to showcase user and business benefits
Conceptualize and execute on external content, ensuring it will land with engineers
Be the voice of the community of users to our internal team, filtering through the noise to bring back valuable feedback and insight
Build and give demos, participate in developer meet-ups and conferences
You may be a fit if
You have deep technical intuition and are an engineer at heart, comfortably writing clean code You have hands-on experience building with LLMs, framework integrations (like LangChain or LlamaIndex), and managing model configurations
You have exceptional communication skills, with a public portfolio of technical writing, recorded talks, or developer community programs
You have high ownership: you can take a complex engineering workflow from idea to a public-facing demonstration
You find comfort in a flat, fast-moving, and design-driven environment where shipping code in public is the default