Founding Engineer

About Asymptote

Asymptote is building the AI Detection & Response layer for the agentic enterprise .

AI agents are becoming enterprise infrastructure, but companies have no unified system of record for what they're doing. Asymptote delivers the telemetry, detection, and response layer that makes AI agent activity observable and secure.

Beacon is our open-source foundation powering that future. It was named one of the hottest open source cybersecurity tools in June 2026.

The Role

We're looking for a Founding Engineer to build the core product and infrastructure behind Asymptote.

AI agents are rapidly becoming a new layer of enterprise infrastructure. Understanding what thousands of agents are doing across endpoints, CI pipelines, cloud environments, and developer tools creates hard systems problems around telemetry, data infrastructure, performance, reliability, and product experience.

That's what you'll build.

You’ll work directly with the founders across our entire technical stack, from the Beacon endpoint agent and telemetry pipeline to our backend infrastructure, APIs, data models, and customer-facing product.

This is a deeply technical, highly product-oriented engineering role. You’ll take ambiguous problems, design systems from first principles, and own them all the way through production.

As one of our earliest engineers, you’ll have exceptional ownership over both what we build and how we build it.

What You Will Do

Build the Core Platform

• Architect and build the backend systems powering Asymptote.
• Build services for ingesting, processing, storing, querying, and serving high-volume agent telemetry.
• Design data models for agents, users, tools, sessions, resources, and activity across heterogeneous environments.
• Build APIs and platform primitives that power our product and integrations.
• Design systems that remain fast, reliable, and simple as telemetry volume grows by orders of magnitude.

Build Our Telemetry Infrastructure

• Build infrastructure that captures AI activity across endpoints, CI/CD, cloud, and agent runtimes.
• Develop and improve Beacon, our open-source endpoint agent.
• Integrate with rapidly evolving coding agents, AI harnesses, MCP servers, and developer tooling.
• Build performant local systems that can run continuously without getting in the developer's way.
• Design reliable pipelines for moving and normalizing telemetry from thousands of distributed environments.

Build the Product

• Turn complex agent telemetry into simple, useful product experiences.
• Build the systems behind agent inventory, activity timelines, search, investigations, policies, and analytics.
• Work across backend and frontend when necessary to ship complete features.
• Build product primitives that allow customers to understand what agents exist, what they're doing, and how they're interacting with enterprise systems.
• Own features end-to-end from customer problem to production deployment.

Build for Enterprise Scale

• Design systems that operate reliably across large, heterogeneous enterprise environments.
• Solve hard problems around performance, reliability, concurrency, storage, querying, and distributed state.
• Build deployment and integration infrastructure across endpoints, cloud environments, and enterprise systems.
• Make architectural decisions that allow Asymptote to scale from early deployments to millions of agent events.

Move Fast at the Frontier

• Reverse engineer and integrate with AI tools whose interfaces and architectures are changing constantly.
• Prototype new approaches quickly, then turn the ones that work into production systems.
• Debug problems across the stack, from local processes and operating systems to distributed backend infrastructure.
• Build internal tooling that lets a small engineering team move extremely quickly.
• Contribute infrastructure and tooling back to Beacon where appropriate.

Shape the Product & Engineering Organization

• Work directly with the founders to define Asymptote's architecture and technical roadmap.
• Talk directly with customers and turn ambiguous problems into simple products.
• Make foundational decisions around our stack, infrastructure, engineering practices, and developer experience.
• Own major parts of the product from 0 → 1.
• Help recruit and build the engineering team around you.

What We're Looking For

• 5+ years of experience building production software, infrastructure, developer tools, data platforms, or distributed systems.
• Exceptional software engineering fundamentals.
• Experience designing and operating backend systems in production.
• Strong understanding of distributed systems, databases, APIs, data modeling, and system architecture.
• Ability to move comfortably between product engineering and infrastructure.
• Experience taking complex, ambiguous technical problems from first principles through production.
• Ability to learn unfamiliar systems quickly and work across abstraction layers.
• Strong product instincts and care for the experience of the people using what you build.
• High agency and excited to build foundational systems from the ground up.

Bonus

• Experience building high-volume telemetry, observability, analytics, or event-processing infrastructure.
• Experience building endpoint agents, developer tools, or local-first software.
• Experience with streaming systems, distributed data pipelines, or large-scale event ingestion.
• Experience with systems programming, eBPF, operating system internals, or runtime instrumentation.
• Experience with AI agents, LLM infrastructure, MCP, coding assistants, or agent runtimes.
• Experience building enterprise software or infrastructure deployed into complex customer environments.
• Experience with security products or security telemetry.
• Meaningful open-source contributions.
• Experience building products at an early-stage startup.

Why Join Asymptote

• Build the infrastructure for the agentic enterprise. AI agents are creating an entirely new systems layer, and you’ll help build the infrastructure enterprises use to understand and control it.
• Own foundational product. You’ll build major parts of Asymptote from scratch rather than inherit a small piece of an established system.
• Work on hard systems problems. Endpoint instrumentation, high-volume telemetry, distributed systems, data infrastructure, and rapidly evolving AI runtimes.
• Build across the stack. Work from low-level agent infrastructure through backend systems to the product customers interact with every day.
• Ship directly to real enterprises. Work closely with customers deploying AI agents in production and see your work used immediately.
• Work directly with the founders. Have enormous influence over architecture, product, hiring, and engineering culture.
• Exceptional compensation: $150,000–$300,000 base.
• Meaningful founding-stage equity for the right candidate.