Founding Principal Engineer

Kā Labs | Founding Principal Engineer / Decision Substrate

KĀ LABS / FOUNDING TECHNICAL TEAM

Founding Principal Engineer

Decision Substrate for Healthcare AI

Kā Labs | Founding Substrate Architect | Reports to the CEO

Build the control plane that determines what healthcare AI can see, recommend, and do. Make every consequential decision reconstructable. Founder-level architectural agency, a small team, real decision environments, and a role that stays in the code.

Why this role exists

Healthcare decisions determine whether a person receives care and whether the people who provided it are paid. AI is beginning to influence and execute parts of those decisions. The infrastructure underneath was not built for model-mediated autonomy: provenance, authority, source state, rules, trace, and release evidence remain split across application-specific systems.

Kā is building the shared decision substrate beneath every product we launch: the durable execution, compiled policy, point-in-time state, controlled model access, decision trace, authority, and independent evaluation foundation for high-stakes AI.

The open problem is autonomy. A system should earn operational scope the way a supervised clinician does: shadow first, then bounded action, then wider scope; each expansion granted against independent evidence and revoked when performance degrades. That requires deterministic replay where possible, evidentiary reconstruction where it is not, typed authority, temporal state, tenant isolation, and certification evidence kept separate from the learning loop.

This is the founding, hands-on architect for that layer. You will own the technical contracts between named owners for runtime, platform, reasoning, and evaluation. The invariants are given. The architecture is yours to set. What you set in year one will still be load-bearing in year ten.

Why Kā

• Greenfield architecture, real-world constraints. Kā is backed by large national healthcare enterprises whose contracted data sandboxes provide governed access to production-scale decision environments and adjudication feedback. You build on real decision data without inheriting a legacy stack.
• Founder credibility. Kā’s founders built and sold a national healthcare technology company to the largest United States healthcare enterprise, led AI innovation inside it, and ran a Medicare division of a public insurer.
• A small but mighty founding team. Senior researchers and engineers, each owning a named artifact. You recruit the runtime, platform, and reasoning owners; the evaluation owner is in place on Day 1 with protected independence.
• Time to build the right system. Kā is capitalized beyond this build, with no fund clock, required exit timeline, or investor-driven sale pressure.

Your mandate

• Define the contract map. Author the interfaces and schemas that bind durable execution, compiled rules, canonical source state, model gateways, decision traces, authority, and sealed evaluation into one system.
• Ship the reference implementation. Write, deploy, and operate the first production-grade path.
• Set authority boundaries. Define where a compiled artifact, model output, or product surface stops. External clinical, legal, coverage, and payer authorities grant scope; the substrate verifies and enforces it.
• Make evolution safe. Establish compatibility rules, semantic diffs, conformance fixtures, migration windows, and deprecations that actually complete.
• Hold the architecture gate. Control access to shared substrate services, sandbox data, and production pathways for everything built on the substrate.
• Set the technical bar. Recruit and assess the founding runtime, platform, and reasoning builders. Hiring pace is an expectation of the seat.
• Scope without sprawl. Application teams build on your contracts. The founding scientist owns reasoning candidates. Integration teams activate against your interfaces. The substrate contracts, and the code behind them, are yours.

The first proof

Take one bounded healthcare decision end to end in a shadow environment on public or synthetic data. One representative shape: a claim adjudicated against a compiled plan contract. It must have idempotent execution, pinned model and rule versions, explicit failure states, deterministic replay for substrate-controlled components, captured evidence for external model calls, and an independently owned evaluation you cannot modify, inspect in advance, or approve. Milestone What success looks like

Day 1

Kā provides an internal shadow environment, approved access to at least one frontier model and one open-weight model, a pinned public rule corpus, and an independent evaluation owner.

Day 30

Publish the substrate contract map and core invariants: no authority without a typed grant; no consequential output without a trace; no promotion against developer-visible evidence; no silent fallback across versions.

Day 60

Run one bounded decision end to end under those contracts, with explicit failure states and every substrate-controlled step reconstructable from durable records.

Day 90

Freeze the candidate and hand it to independent, sealed evaluation.

Two quarters

Operate the system in shadow at the first autonomy level and pass sealed internal evaluation. In parallel, recruit the founding runtime, platform, and reasoning builders.

Technical terrain

The bar is deep production ownership in several of these domains and the systems judgment to connect the rest. Few candidates will have done every item.

• Durable and distributed execution. Idempotent operations, exactly-once effects over at-least-once delivery, compensation for partial failure, and explicit failure states designed before happy paths.
• Replay and reproducibility. Pinned dependencies, hermetic execution, deterministic fixtures, and record-and-replay capture for external calls that cannot be re-executed.
• Contracts, schemas, and versioning. Contract-first design, compatibility guarantees, semantic diffing, generated conformance tests, and migrations across years of consumers.
• Rules as compiled artifacts. Typed intermediate representations, compilation from policy or contract language, static verification, and generated coverage. Compiler or DSL work transfers directly.
• Temporal state. Bitemporal modeling, point-in-time reconstruction over incomplete or late-arriving data, and corrections that preserve history.
• Authority and multi-tenant isolation. Typed grants, capability scoping, revocation, retry-safe verification, and hard separation across data, compute, and evidence for competing enterprises.
• Model-mediated execution and evaluation. Controlled context assembly, pinned model and prompt versions, typed output validation, sealed test sets, contamination controls, and evidence-driven promotion gates.

Evidence that will get our attention

The strongest signal is a platform you personally architected and coded that teams outside your reporting line adopted, with the contract discipline to prevent bypasses without becoming the bottleneck.

• Production authorship. Recent hands-on code in at least one of Rust, Go, Java, or C++, plus working fluency in Python or TypeScript for tooling.
• Migrations and incidents. Versioning decisions that survived consumers, compatibility failures you owned, pager duty, and postmortems that changed the design.
• Precise interface writing. Contracts, invariants, and decision records clear enough that other teams can build without a meeting.
• Technical hiring judgment. A track record of evaluating senior builders on shipped evidence and closing people who raise the bar.
• Candor. A consequential architecture decision that proved wrong, what it cost, and how your judgment changed.
• Healthcare experience is optional. Strong evidence can come from payments, identity, cloud control planes, databases, compilers, security, safety-critical infrastructure, or any system where errors are costly and hard to reverse.

You will thrive here if

• You want decade-scale architectural ownership. The work is a control plane and a set of technical laws.
• You make hard constraints legible. You turn authority, failure, compatibility, and evidence requirements into contracts other teams can use.
• You are principled without being precious. You can defend an invariant, delete an elegant abstraction, and ship the thinnest proof that resolves the real uncertainty.
• You still build. Founder-level agency appeals to you, but so do code review, migrations, and on-call.
• You want the consequences to matter. Most of this generation’s best systems engineers are spending their peak years making advertising more efficient. The decisions here affect access to care, payment, and trust.

How we work

• Decision rights attach to artifacts. You own substrate contracts; each founding builder owns their runtime, platform, or reasoning artifacts.
• Evaluation is independent by design. The evaluation owner controls sealed tests and can block promotion. Failed gates clear only through recorded remediation and re-test.
• Release authority is multidisciplinary. Technical, evaluation, clinical, and compliance owners participate. No one at Kā can independently grant clinical, legal, coverage, or payment authority.
• Builders operate what they design. You stay in the code, review critical changes, respond to incidents, and carry the pager for the first deployment. That does not taper after the first quarter.

How we hire

The interview loop is evidence-led: shipped systems, migrations, incidents, architecture tradeoffs, and technical writing.

Compensation and ownership

Compensation targets the top decile for Principal- and Distinguished-level engineering roles in the United States, structured as cash compensation, and top-tier founding equity. Level and grant size are calibrated to demonstrated scope.

The chance . Define the technical laws of a new healthcare decision layer before the industry standard hardens, with enough real-world access to prove the architecture and enough independence to build it correctly.

Kā Labs is an equal opportunity employer.