Staff Software Engineer

Latent Defense; New York (NY); On-site; USD 110,000 - 170,000; Full time

Job summary

Latent Defense is building a world model for cybersecurity, starting with threat modeling. We’re a small team crafting an autonomous threat modeling system that reasons about attack paths, validates them with agents, and remediates vulnerabilities across the attack chain.

We seek engineers who think in systems, learn by building, and can operate across the stack from model inference to APIs. You’ll contribute to a secure, scalable product and join a team focused on proactive defense in

Qualifications

• Natural systems thinker who reasons about data flow, failure modes, and architecture.
• Learns quickly by building with new SDKs, protocols, or deployment targets.
• Able to operate across the stack from model inference to container networking and API design.

Responsibilities

• Wire MCP servers shared across agent swarms; bridge SSE transports with STDIO proxies for a fast orchestration layer.
• Extend agent workflows inside our bespoke agent SDK to shape how agents reason, collaborate, and act on threat models.
• Design integrations that trigger on git changes, cloud deployments, or ticketing events and close the loop with autonomous remediation.
• Package and deploy models as hardened, IP-safe containers; wrap them in Docker and ship without exposing weights.
• Tune high-throughput inference pipelines that generate structured training data at scale.
• Build the observability and telemetry layer to measure, grade, and improve threat-modeling efficacy.
• Harden the product itself, ensuring security is robust and auditable.

Skills

TypeScript

Python

PostgreSQL

Docker

Kubernetes

Distributed systems

API design

Tools

Docker

Kubernetes

Job description

We’re Building the World Model for Cybersecurity. Come Join Us!

We’re a small team building something ambitious: a world model for cybersecurity, starting with threat modeling. We’re building an autonomous threat modeling system that rigorously models attack paths against large-scale infrastructures, orchestrates agents to validate each path, and remediates confirmed vulnerabilities at every step of the attack chain.

We’re hiring a team of engineers to help us scale this from a sharp early product into something that runs autonomously across real-world environments: from git repos to cloud deployments to bug bounty programs.

What the Work Looks Like

The surface area is wide, and that’s the point. On any given week, you might be:

• Wiring up MCP servers shared across agent swarms, bridging SSE transports with STDIO proxies so our orchestration layer stays fast and composable
• Building and extending agent workflows inside our bespoke agent SDK, shaping how agents reason, collaborate, and act on the threat models our world model produces
• Designing integrations that trigger on git changes, cloud deployments, or ticketing events and close the loop with autonomous remediation
• Packaging and deploying our models as hardened, IP-safe containers, compiling models down to optimized machine code, wrapping them in Docker, and shipping them without exposing weights
• Tuning high-throughput inference pipelines that generate structured training data at scale
• Building the observability and telemetry layer that lets us measure, grade, and improve everything, from proof-of-concept triage to system-wide efficacy
• Hardening the product itself, because if you’re selling security, your own house has to be airtight

The stack leans heavily on TypeScript , Python , and PostgreSQL , with a healthy dose of Docker / Kubernetes networking and hybrid deployment patterns.

Who We’re Looking For

We’re not expecting you to walk in the door knowing all of this. We’re looking for people who think the right way : the kind of engineer who sees a new domain and instinctively starts building a mental model of how the pieces fit together.

You’re probably a good fit if:

• You’re a natural systems thinker. You reason about data flow, failure modes, and architecture before you reason about syntax.
• You learn by building. Hand you a new SDK, protocol, or deployment target, and you’ll have a working prototype before you’ve finished reading the docs.
• You’re comfortable operating across the stack, from model inference to container networking to API design, without needing someone to draw the boundaries for you.
• You care about the lifecycle of what you build: not just “does it work” but “can it be observed, tested, scaled, and trusted.”
• Security isn’t just a checkbox for you. You think adversarially by default.

Why This Matters

Cybersecurity is stuck in a reactive loop: scan, alert, patch, repeat. We’re building something that breaks that cycle by reasoning proactively about how systems fail. If that sounds like a problem worth your time, we’d love to talk.