Founding Security Software Engineer

$200k - $330k + equity

Location
San Francisco
Workplace
On-site
Employment
Full-time
Visa
Visa Sponsorship Available

About this role

You’ll own and build Cosmon’s enterprise agent security foundation, the architecture that makes autonomous agents usable in demanding environments, including regulated engineering and defense.

You’ll report directly to the CTO as a senior, hands-on individual contributor. You’ll design, write, review, test, and ship production code across the agent runtime, desktop application, backend services, and engineering integrations, personally implementing core security controls and staying an active IC as the product and team grow. You’ll own the security architecture, technical priorities, and implementation quality of the enterprise security roadmap, working with platform, desktop, and engineering-tool engineers to deliver it and making clear calls on scope, dependencies, and release readiness.

Full-time, in-person work at our San Francisco office is a requirement.

What You’ll Do

Architecture & Agent Runtime Security

  • Own the threat model and roadmap. Map trust boundaries and data flows, prioritize risks, resolve open design questions, and define testable acceptance criteria for each supported deployment.
  • Secure agent execution. Integrate and validate Codex’s sandboxing and approval controls, and build the Cosmon policy and execution layers that constrain generated code, privileged tools, native application actions, and extensions.
  • Authorize engineering actions. Implement scoped capabilities, resource permissions, and approvals tied to specific operations and artifact versions, so an agent can never exceed the initiating user’s or organization’s authority.

Identity, Data & Evidence

  • Protect identity, credentials, and data. Build secure service boundaries, short-lived credential handling, enterprise identity integrations, and tenant isolation. Govern inference endpoints, network egress, local storage, retention, and deletion.
  • Make failure safe and auditable. Build customer-controlled action records, approval receipts, and audit exports. Ensure sensitive operations stop safely when policy, identity, or required evidence services are unavailable.

Deployment & Operational Readiness

  • Harden desktop and enterprise deployment. Secure privileged integration paths, packaging, updates, and releases. Design customer-hosted and restricted-network profiles, including independently trusted execution where the threat model requires it.
  • Validate and respond. Write adversarial and integration tests, investigate vulnerabilities, enforce release security checks, and drive incident-response engineering. Produce clear security documentation and support customer reviews with demonstrated controls.

What We’re Looking For

  • A strong production software engineer with a track record of taking complex systems from design through implementation, rollout, and maintenance. You can point to substantial code and security controls you personally shipped.
  • Strong CS fundamentals. Data structures and algorithms, concurrency, operating systems, and systems design. You reason rigorously about correctness, isolation, and failure modes, and you can design a system and defend its guarantees.
  • Hands-on security engineering experience. Authorization, secrets, process isolation, permissions, network boundaries, or secure execution. You can translate a threat model into enforceable code and meaningful tests.
  • Comfort across backend and OS boundaries. You can inspect an unfamiliar codebase, trace privileged behavior, and debug failures across multiple processes.
  • Clear thinking about AI-specific threats. Untrusted model output, hostile tool inputs, prompt injection, compromised endpoints, and third-party extensions. You understand the limits of local controls and design around them.
  • Pragmatic technical ownership. You can prioritize an ambiguous roadmap, explain tradeoffs and security guarantees clearly, and work directly with product engineers and enterprise customers.
  • Ready to write production code every week, full-time and in person with the team.

Nice to Have

  • Python backend and runtime development, TypeScript desktop applications, or Rust systems development, plus willingness to work across Cosmon’s stack.
  • Windows or native desktop security, sandboxing, process supervision, signed releases, and software supply-chain controls.
  • AI agent runtimes, developer tools, MCP or other tool protocols, and safe execution of generated programs.
  • Enterprise identity and credential brokering, customer-hosted deployments, restricted networks, or disconnected environments.
  • CAD, CAE, or PLM integrations, or security engineering for products handling sensitive commercial IP and regulated workflows.

Your First Milestones

  • Establish the real release baseline. Inventory privileged execution and data paths, validate the Codex integration assumptions, and turn the highest-risk gaps into an executable delivery plan.
  • Ship enforceable controls. Deliver a first set of controls with tests that demonstrate both permitted behavior and resistance to bypass.
  • Deliver a governed workflow. With partner engineers, ship an engineering workflow with scoped authority, consequential-action approval, controlled data destinations, and customer-owned evidence.
  • Make it repeatable. Give the team a security release process, explicit limits for supported deployments, and a credible plan for the rest of the roadmap.

Our Interview Process

We test CS fundamentals directly. Expect at least one data structures and algorithms round and one systems design round, plus a security-focused round where you’ll threat-model a system and design enforceable controls for it. This is a builder role, so we’re looking for a strong engineer first and a strong security thinker second, not a policy or compliance specialist.

Why This Role

  • Security is the product unlock. Enterprise and defense customers adopt Argus only if its agents are provably constrained. You own what makes that possible.
  • Novel problems, real stakes. Securing autonomous agents that act inside native desktop software on locked-down enterprise workstations is largely unsolved, and the IP involved is some of the most valuable our customers have.
  • Founding ownership. You’ll set the security architecture and engineering standards that the rest of the company builds on.
  • Early-stage leverage. Small team, Series A, Fortune 100 customers, direct line to the CTO.

Apply to Cosmon

They hire through Clera: your intro goes straight to the hiring team.

How it works

Confirm the fit

A few questions to make sure this role is the right shape for you. Two minutes.

Clera pitches you to the company

Clera writes the intro, sends it to the founder, and handles the back-and-forth.

A meeting lands on your calendar

When the company wants to meet, Clera gets the call on your calendar. You just show up.

Not the right role?

Ask your AI about this role

It knows you. Clera gives it the role.

Does this role fit my profile?

First time? Connect Clera once, about a minute.
One click above pre-fills the connector. Or by hand: Settings > Connectors > Add custom connector, paste https://mcp.getclera.com. Either way, sign in with the account you use on Clera and approve the consent screen.
https://mcp.getclera.com

Sign in with your Clera account. MCP docs

About Cosmon

Cosmon is an AI company developing intelligent solutions for computer-aided engineering, CAD, and product lifecycle management to transform engineering simulation and design workflows.

Stage
Series A
Team size
11-50 people
Founded
2025
Industry
AI
Workplace
On-site
Locations
San Francisco, United States
Open roles
1

Know someone who'd fit?

Earn $5,000 per hire

Culture & values

  • Work alongside experts in engineering and applied AI
  • Collaborative environment integrating machine learning directly into simulation pipelines
  • Opportunity to make foundational impact at early-stage company
  • Focus on pushing boundaries and innovation in AI-powered engineering