Roles
Open roles
We're building software and protocols for agent-native execution: identity, context, authority, orchestration, and receipts for systems that touch atoms.
Full-time roles
Backend Engineer, Agent Execution Infrastructure
Build the Rust execution harness and desktop-native paths that let agents act across services that touch atoms.
Backend Engineer, Agent Execution Infrastructure
The role
OpenMatter develops software and protocols for agent-native execution. You will build the systems behind that thesis: identity, context, policy, place, capability, storage, orchestration, and receipts — in Rust and across the desktop stack (Tauri, Chromium). The work is not a chatbot wrapper. It is the infrastructure that lets an agent carry authority, call services, coordinate physical workflows, and leave behind proof across human-built systems.
What you'll do
- Build primitives for identity, context, policy, place, capability, storage, and receipts in Rust
- Design the unified SDK for services that touch atoms: payments, logistics, access, IoT, robotics, and human operations
- Own orchestration paths from intent to authority to execution to receipt, including desktop-native execution in Tauri
- Integrate Chromium-backed browser orchestration where agents need to act inside real web surfaces
- Model failures, blocked states, retries, permissions, and audit trails as first-class system behavior
- Set the bar for reliability, latency, observability, evals, and recovery in agentic execution flows
What we're looking for
- Shipped production systems in Rust (or strong systems programming taste) that touch agents, commerce, logistics, payments, robotics, or physical-world operations
- Experience with desktop runtimes — Tauri, Electron, or Chromium embedding — and the security boundaries they impose
- Deep fluency in agent tool use, orchestration, APIs, SDK design, and protocol boundaries
- Strong taste for system design that makes authority, state, and failure visible
- Comfortable integrating with messy real-world services instead of only clean demos
- Bias toward shipping infrastructure that can be tested against real workflows
Physical Operations Lead
Operate the real-world loop where agent requests become physical execution.
Physical Operations Lead
The role
Agents fail when the next step requires presence, access, pickup, delivery, inspection, or a physical handoff. You will own the operational layer that lets OpenMatter test and scale those flows. That includes facilities, logistics partners, robotics-assisted workflows, SLAs, exception handling, and the receipts that prove what happened.
What you'll do
- Run the physical operations loop behind agent-initiated workflows
- Own SLAs, throughput, loss, cost per action, exception handling, and operational reliability
- Partner with engineering on robotics, storage, retrieval, dispatch, and last-mile handoff workflows
- Translate messy operational realities into protocol requirements, product feedback, and receipt fields
- Decide what should stay with partners, what should be automated, and where OpenMatter needs direct control
What we're looking for
- Senior operations experience in logistics, robotics, fulfillment, mobility, field operations, or physical infrastructure
- Have run live operations against real SLAs, not just designed them on paper
- Comfortable working with engineering on automation, data, instrumentation, and reliability
- Know how physical workflows break and how to turn those breaks into repeatable systems
- Fluent in both unit economics and the floor-level details that make operations work
Product Designer, Agent Control Surfaces
Design the interfaces that make agent authority, context, execution, and proof understandable.
Product Designer, Agent Control Surfaces
The role
OpenMatter needs interfaces for a world where agents act across services, physical systems, and human operations. You will design the control surfaces for that world — on the desktop (Tauri + Chromium) and across web — how users grant authority, inspect context, understand what an agent can do, see what happened, and revoke or override execution. The design language should feel calm, precise, and trustworthy, not like generic AI software.
What you'll do
- Design developer and operator surfaces for agent execution, service orchestration, permissions, and receipts
- Shape desktop-native patterns: Tauri shell chrome, Chromium in-app browser views, and human-in-the-loop controls
- Make complex flows legible without hiding risk, authority, or failure states
- Define interaction patterns for approving, revoking, replaying, and auditing agent actions
- Shape the visual system across the website, console, docs, and agent-facing tools
- Write product copy that makes the infrastructure feel clear, serious, and usable
What we're looking for
- Built polished product surfaces for technical, operational, fintech, logistics, developer, or infrastructure products
- Comfortable designing for desktop apps — Tauri, Electron, or Chromium-embedded surfaces — not only responsive web
- Strong systems thinking: you can design across flows, states, roles, and permissions
- Taste for restrained interfaces with excellent typography, spacing, and information hierarchy
- Allergic to generic AI patterns: chatbot panes, magic-wand buttons, and vague automation language
- Comfortable working directly with engineering and founders in ambiguous product territory
Commercial Lead, Agent Infrastructure
Own the first partnerships for a unified SDK across services that touch atoms.
Commercial Lead, Agent Infrastructure
The role
You will build the commercial motion for OpenMatter's agent execution infrastructure. The first partners are the platforms, operators, service providers, robotics companies, logistics networks, and commerce systems whose APIs or workflows become part of an agent-native orchestration layer. You will sell the platform vision while feeding the product team the exact constraints partners need solved.
What you'll do
- Close the first strategic partners across commerce, logistics, payments, access, robotics, IoT, and operations
- Turn partner workflows into repeatable integration, pricing, and packaging motions
- Lead technical discovery with engineering and product so deals inform the SDK and protocol roadmap
- Build the outbound motion, partner pipeline, pricing rubric, and deal process from scratch
- Represent OpenMatter with senior technical, product, and operations buyers
What we're looking for
- Closed platform or infrastructure deals with technical buyers, operations buyers, or ecosystem partners
- Fluent in APIs, SDKs, partner integrations, and the difference between a demo and a deployable system
- Comfortable selling a product category that is still emerging
- Can translate partner pain into product requirements without losing commercial urgency
- Excited to build the commercial function from zero, not inherit one
Product Engineer, Agent Surfaces
Build the desktop app and console — Tauri, Rust, Chromium, and Electron where it fits.
Product Engineer, Agent Surfaces
The role
You will build the surfaces that make OpenMatter usable: our Tauri desktop app, the developer console, SDK examples, workflow playgrounds, receipts, service configuration, and human approval interfaces. The job spans TypeScript/React and the desktop stack — Rust, Tauri, Chromium, and Electron where it fits — so agent infrastructure feels fast, native, and trustworthy on the machine.
What you'll do
- Build and extend the desktop app in Tauri: Rust core, React UI, and Chromium-backed in-app browser orchestration
- Ship the web console for configuring services, testing actions, inspecting receipts, and managing authority
- Create SDK examples and reference flows for payments, logistics, access, IoT, robotics, and storage
- Ship human-in-the-loop controls for approval, revocation, retries, and audit across desktop and web
- Partner with backend engineering on API contracts, state models, and error surfaces
- Raise the craft bar on performance, interaction details, and clarity of complex workflows
What we're looking for
- Strong TypeScript and React experience with real backend fluency
- Hands-on with Tauri, Rust, Chromium embedding, or Electron — ideally more than one
- Have shipped developer tools, dashboards, desktop apps, operational products, or polished technical interfaces
- Care about the last 10 percent of product quality: latency, empty states, copy, and interaction details
- Can reason about APIs, auth, sessions, permissions, and long-running workflows
- Early-stage experience or comfort with fast-moving ambiguity is a strong plus
Summer internships
Scoped summer projects for builders and researchers who want to make agent-native execution concrete.
Summer Intern, Agent Systems
Spend the summer building and researching primitives for agents acting beyond software.
Summer Intern, Agent Systems
The role
This internship is for someone who wants to work close to the core OpenMatter thesis. You might prototype SDK flows on the desktop (Tauri + Rust + Chromium), evaluate agent execution failures, build small console or desktop features, map service integrations, write research notes, or help test how identity, context, policy, place, capability, storage, and receipts fit together in real workflows.
What you'll do
- Prototype agent execution flows across services that interact with atoms
- Help build SDK examples, Tauri/Rust desktop features, test harnesses, or console UI
- Experiment with Chromium-backed browser tools or Electron surfaces where they accelerate a summer scope
- Map failure modes around human proxy dependency, tool use, persistence, and receipts
- Work directly with engineering, product, and operations on a tightly scoped summer project
- Present a final demo, memo, or implementation note to the team
What we're looking for
- Strong technical curiosity about agents, infrastructure, robotics, logistics, developer tools, or physical-world systems
- Comfortable writing code in TypeScript, Rust, or both — eager to learn Tauri, Chromium, or Electron integration on the job
- Clear communicator when researching systems and presenting findings
- Taste for careful thinking: you like making vague ideas concrete and testable
- Available for a summer internship and excited to work in person with a small team
- Students, recent grads, and exceptional self-taught builders are all welcome
Summer Intern, Protocol Research
Turn real agent workflow failures into protocol notes, specs, and research artifacts.
Summer Intern, Protocol Research
The role
This internship is for someone who wants to help make OpenMatter's research agenda sharper. You will study where agent workflows break across identity, inherited context, authority, service boundaries, physical handoffs, and receipts, then turn that work into clear protocol proposals, diagrams, internal memos, and public-facing research material.
What you'll do
- Map agent workflow failures across commerce, logistics, access, IoT, robotics, and human operations
- Translate research findings into protocol requirements for context, policy, capability, storage, and receipts
- Build lightweight demos, diagrams, datasets, or evaluation notes that make the findings testable
- Support the essays page, paper drafts, and internal specs with careful writing and citations
- Present a final research memo or protocol proposal to the team
What we're looking for
- Strong writing and research taste with enough technical fluency to reason about APIs, agents, and systems
- Comfortable moving between papers, product flows, field observations, and implementation details
- Interested in agency, protocol design, robotics, logistics, developer infrastructure, or human-computer interaction
- Can make ambiguous ideas precise without making them sound generic
- Available for a summer internship and excited to work with a small, fast-moving team