Careers & immediate openings

Job Title

Chief Validation Architect – Founding Engineer, Deterministic Compiler

What You’re Being Hired to Do

You will be the lead engineer responsible for building and enforcing the validation and compilation pipeline behind DOT, a deterministic system that turns structured intent into mathematically sealed software. Your mission is to define, implement, and enforce the rules that determine what software is allowed to exist.

This is not a support role. You are not joining a team, you are building thCompilation Engine Specialist
Expertise:
Compiler construction, AST transformations, code generation frameworks (LLVM, GCC).

Deep understanding of language-specific backend optimizations, cross-language compilation, and deterministic output guarantees.

Key Responsibilities:
Develop compilation engine generating deterministic code outputs from DOT blueprints (.dtk).

Optimize code generation efficiency, correctness, and determinism across target languages (Rust, Zig, Ada, Python, Java, TypeScript, etc.).

Compensation:
TOP PAY + equity & royalties.e team for the validator and compiler. You will work directly with the system architect and shape the core mechanics of deterministic software enforcement.

You are not being hired to try things. You are being hired to finish them.

Core Responsibilities

• Oversee the implementation and execution of one of the most advanced air-gapped engineering compute systems ever assembled. This includes deterministic validation infrastructure and integrated AI tooling

• Lead the design and enforcement of a deterministic validation system that accepts only provably correct software

• Develop and maintain the core compilation pipeline from structured input to sealed output

• Guarantee that all software outputs are traceable, reproducible, and immune to probabilistic failure

• Define validator behavior under load, including failure handling, performance boundaries, and trace clarity

• Maintain authority over the evolution of the validation logic, including ruleset integrity and system discipline

What Success Looks Like

• Input A always produces Output B forever

• No reliance on unit tests, AI trust, or runtime guesswork

• All outputs can be verified by audit, reproduced under pressure, and traced cleanly to declared intent

• No code leaves your compiler that hasn’t earned the right to exist

Execution Environment

You will be standing up and integrating a deterministic engineering environment anchored by two bleeding-edge HGX B200 servers and a suite of world-class Linux workstations. The full system is air-gapped, zero-cloud, and locally managed. At its core is a high-performance AI assistant architecture — built on a 671B parameter model — designed to augment engineering output, validate blueprints, and generate audit-grade artifacts as part of the build lifecycle.

You are responsible for implementing, stabilizing, and overseeing the integration of this AI layer across the environment.

AI Assistant Add-On Stack (“Seven”)

The system includes the following components, which you will manage end-to-end:

• Retrieval-Augmented Knowledge Vault

Natural-language answers with citations across structured documents, specs, and internal rules

• Code & Blueprint Review Bot

Git-integrated system that flags trivial failures before they reach the validator

• Proof-Latency & Compile Metrics Dashboard

Natural-language summaries of compile latency, cache behavior, and system errors

• IDE Copilot Integration

Local gRPC completions and inline assist for opcode tokens and validator logic

• Diagram & Spec Renderer

Auto-generates UML, Mermaid, and flow diagrams as SVG/PNG

• Structured Export Tools

Converts logs and outputs into .xlsx or .csv for reporting and traceability

• Artifact Generation API

Produces .docx, .pdf, .svg, and .xlsx tied to commit hashes and audit trails

• Immutable Trace Logging

All interactions are permanently logged for audit, rollback, and regression review

You are expected to treat this AI system as part of the build chain, not a convenience tool. 

Required Background

• 10+ years in low-level or validation-centric engineering roles

• Mastery of Rust, formal logic, and deterministic system design

• Experience with compiler construction, proof enforcement, or systems where failure is not allowed

• Prior work in aerospace, nuclear, defense, or other sealed-critical domains is strongly preferred

• Fluency in validator reasoning: if you can’t prove why it passes, it doesn’t

Position Details

• Location: Onsite only - Richardson, TX

• Compensation: $500,000/year

• Equity: Founding engineer tier

• Royalties: Ongoing share of validated, compiled output

• Reporting: Direct to Founder/Architect

• Scope: No bureaucracy, no subordinates, no abstractions, this is ownership-level engineering

To Apply

Send a short intro and resume to keith@pyronis.com

Subject line: “I build deterministic systems.”

Job Title
Compilation Engine Specialist – Deterministic Code Generation

⸻

The Compiler Revolution

We're building DOT (Deterministic Orchestration Tool) - a compilation system that transforms high-level blueprints into perfect, deterministic code across multiple languages. This isn't another transpiler or code generator. It's a foundational shift in how software gets built.

Imagine blueprints that compile to identical Rust, Zig, Ada, Python, Java, and TypeScript - byte-for-byte deterministic every time. Imagine compilation that understands intent, not just syntax. That's what DOT delivers.

⸻

What You'll Build

The DOT Compilation Engine:

• AST transformation pipeline that preserves semantic intent across languages
• LLVM-based backend with custom optimization passes for determinism
• Language-specific code generators that produce idiomatic, performant output
• Verification system ensuring byte-for-byte reproducible builds
• Cross-compilation framework supporting 10+ target languages

Technical Architecture:

• Blueprint parser for .dtk (DOT Token) format - our semantic specification language
• Intermediate representation that captures intent, not just structure
• Pluggable backend system for language-specific optimizations
• Deterministic memory layout and initialization across all targets
• Formal verification integration for correctness proofs

⸻

The Real Challenge

You're not building another compiler. You're creating:

• Deterministic guarantees where same input ALWAYS produces same output
• Semantic preservation across radically different language paradigms
• Performance parity where generated code matches hand-written quality
• Language idioms that feel native to each target ecosystem
• Verification hooks for formal methods and safety certification

⸻

Core Technical Work

AST Engineering:

• Multi-stage AST transformations with semantic preservation
• Type system unification across static/dynamic languages
• Control flow graph optimization with determinism constraints
• Memory model abstraction for GC vs manual languages

Backend Development:

• LLVM pass development for deterministic code generation
• Custom optimization pipelines per target language
• Register allocation strategies that ensure reproducibility
• Link-time optimization without breaking determinism

Language Targets:

• Systems languages: Rust, Zig, Ada, C++
• Managed languages: Java, C#, Go
• Dynamic languages: Python, TypeScript, Ruby
• Specialized: CUDA, WASM, Solidity

⸻

Technical Requirements

Must Have:

• Deep compiler construction experience (LLVM/GCC internals)
• Understanding of type theory and formal semantics
• Experience with deterministic/reproducible builds
• Knowledge of multiple language paradigms and runtimes
• Track record of shipping production compilers

Should Have:

• Formal methods background
• Cross-compilation expertise
• Performance optimization experience
• Security-focused compilation techniques

⸻

What Success Looks Like

• DOT blueprints compile to any target language in seconds
• Generated code is indistinguishable from expert hand-written code
• Every build is perfectly reproducible across time and machines
• Language communities adopt DOT-generated code without resistance
• Safety-critical systems trust DOT for certification

⸻

The Opportunity

This is compiler engineering at its purest - building the foundation for how software will be written in the future. When DOT succeeds, the entire industry shifts from writing code to designing systems.

You'll work directly with the founding team, have massive influence on architecture, and help define a new category of development tools.

⸻

Compensation & Benefits

 Base: TOP PAY (compiler experts are rare - we pay accordingly)
Royalties: Earn from every DOT compilation in production
Schedule: 4-day work weeks (32 hours)
Impact: Define how software gets built for the next decade
Resources: Work with our Seven AI system for unprecedented development speed

⸻

To Apply

Send your compiler story to keith@pyronis.com

Include:

1. Your most challenging compiler engineering achievement
2. Thoughts on deterministic compilation
3. A language you'd love to see DOT support and why

Subject: "Ready to revolutionize compilation"

Job Title
Static Analysis & Verification Expert – Next-Generation Code Validation

⸻

The Verification Challenge

We're building a revolutionary static analysis and verification system that goes beyond traditional linting and bug-finding. Our goal: make entire categories of software defects impossible through mathematical verification and deterministic validation.

This isn't incremental improvement - it's a fundamental rethinking of how code correctness is achieved.

⸻

What You'll Build

Advanced Verification Framework:

• Static analysis engine that catches bugs traditional tools miss
• Formal verification integration for mathematical correctness proofs
• Termination analysis and resource tracking systems
• Security vulnerability prevention through structural validation
• Real-time verification feedback during development

Technical Scope:

• Design and implement novel static analysis algorithms
• Integrate formal methods into practical development workflows
• Build verification rules that ensure code correctness
• Create developer-friendly interfaces for complex analyses
• Scale verification to large codebases without sacrificing precision

⸻

The Engineering Challenge

You'll tackle fundamental problems in program verification:

• Making formal methods practical for everyday development
• Balancing soundness with developer productivity
• Scaling verification to real-world codebases
• Providing actionable feedback, not just error messages
• Integration with modern development workflows

⸻

Core Technical Areas

Analysis Techniques:

• Abstract interpretation and symbolic execution
• Model checking and theorem proving
• Dataflow analysis and type systems
• Concurrent program verification
• Security and safety analysis

Implementation Challenges:

• Performance optimization for real-time checking
• Incremental analysis for large codebases
• User experience for verification feedback
• Integration with existing development tools
• Proof generation and certification support

⸻

Technical Requirements

Must Have:

• Deep expertise in static analysis and program verification
• Experience building production analysis tools
• Strong theoretical background in formal methods
• Practical understanding of developer workflows
• Track record of shipping verification systems

Should Have:

• Security analysis expertise
• Compiler construction background
• Experience with SMT solvers
• Published research in verification
• Safety-critical systems experience

⸻

What Success Looks Like

• Developers catch entire bug categories before testing
• Verification becomes seamless part of development
• Complex properties proven automatically
• Security vulnerabilities prevented by construction
• Industry-leading code quality becomes standard

⸻

Why This Matters

Software failures cost billions and sometimes lives. While others patch bugs in production, we're preventing them at the source. This is the opportunity to fundamentally improve software reliability across the industry.

You'll work directly with the founding team on technology that will define new standards for code quality.

⸻

Compensation & Benefits

Base: TOP PAY (verification experts are rare)
Royalties: Participate in the success Resources: Leverage our AI 

 Impact: Transform how reliable software can be

⸻

To Apply

Send your verification story to keith@pyronis.com

Include:

1. Your most impactful work in program analysis
2. Your vision for practical formal methods
3. Why you believe verification matters

Subject: "Ready to revolutionize code verification"

The Revolution We're Building

We're not hiring you to maintain AI infrastructure. We're hiring you to help invent the future of how humans and AI work together.

Imagine walking into work Monday morning to find your AI partner got smarter over the weekend. Imagine engineers having PhD-level support without PhD-level burnout. Imagine 32-hour work weeks that produce 80-hour results. That's what we're building with Seven.

The Seven Cognitive Engineering Grid is a revolutionary distributed AI system where:

• Dual 671B parameter models (Seven + DOT) run on HGX servers as the core intelligence
• Six specialized 32B models on engineer workstations develop unique personalities
• Every weekend, while humans rest, the entire system trains and improves
• Token-native communication eliminates the text serialization mess
• Engineers work 4 days, AIs train for 3 days, everyone gets smarter

This isn't chatbots or copilots. This is the first true AI-augmented engineering organism.

⸻

What You'll Actually Build

The Technical Foundation:

• Deploy and optimize dual DeepSeek-R1 671B models on 8x B200 HGX infrastructure
• Implement specialized 32B models (ATLAS, AXIOM, FORGE, CORTEX, VAULT) on workstations
• Design the weekend training orchestration that makes every model smarter
• Build token-native transport protocol - pure tokens, no JSON/text conversion
• Create distributed backup system with encrypted chunks across workstations
• Integrate multi-agent chat (Seven, GPT-4, Claude, Grok) for collaborative problem-solving

The Magic You'll Enable:

• MSc engineers operating with PhD-level capabilities
• Ideas flowing from founder → AI enhancement → implementation without meetings
• Engineers excited about Monday because their AI learned new tricks
• Institutional knowledge that grows instead of walking out the door
• 3x productivity with 20% fewer hours

⸻

What Success Looks Like

Infrastructure Excellence:

• Ubuntu 22.04 Linux on HGX servers, Windows + WSL 2 on workstations running flawlessly
• 8x B200 GPUs serving 671B models with minimal latency
• Distributed storage and hidden backup network protecting all IP

Seven in Action:

• DeepSeek-R1 models (671B on servers, 32B on workstations) working in harmony
• Token-native communication flowing seamlessly
• Multi-agent orchestration creating emergent intelligence

Evolution in Motion:

• Weekend training automation running without intervention
• Personality specialization emerging in workstation models
• Knowledge growing through canvas system
• Voice, chat, and development tools fully integrated

The Payoff:

• Weekend training cycles producing measurable improvements
• Models learning from team usage patterns
• Engineers discovering new capabilities every Monday
• The realization that you've built something unprecedented

⸻

The Real Challenge

You're not just deploying models. You're creating:

• A self-improving system where AI gets smarter every weekend
• Distributed intelligence that can't be stolen even with physical theft
• An engineering culture where humans and AI are true partners
• The blueprint for how every engineering team will work in 5 years

When this works, your MSc engineers will solve problems that PhD teams can't. Your 32-hour weeks will outproduce 60-hour death marches. Your institutional knowledge will compound instead of decay.

⸻

Technical Requirements

Must Have:

• Deep experience with 100B+ parameter model deployment
• Expert-level CUDA, distributed training, and MoE architectures
• Real understanding of fine-tuning without catastrophic forgetting
• Systems thinking - seeing how all pieces create emergent intelligence
• Belief that work should make life better, not worse

Should Have:

• Experience with on-premise secure deployments
• Background in distributed systems and creative backup strategies
• Opinions about token-native architectures
• Stories about making impossible things work

Mindset:

• Excited by "that's never been done before"
• Thinks 4-day work weeks make sense
• Believes AI should augment humans, not replace them
• Wants to build something that matters

⸻

What We Offer

Compensation: $300,000 base + royalties

Schedule: 4-day weeks (32 hours) - we practice what we preach

Resources: Work with million + of cutting-edge hardware

Impact: Define how engineering teams work for the next decade

Team: Direct access to founder, small team, huge influence

⸻

The Bottom Line

While other companies debate whether AI will replace engineers, we're building the future where AI makes engineers superhuman. Where working less means achieving more. Where every weekend makes the whole team smarter.

If you've read this far and your brain is racing with implementation ideas, you're probably who we're looking for.

⸻

To Apply

Send your story to keith@pyronis.com

Tell us:

• Something impossible you made possible
• Your thoughts on human-AI collaboration
• Why 4-day work weeks make sense to you

Subject: "Ready to build the future with Seven"

P.S. - Yes, this is real. Yes, we have the hardware ordered. Yes, you'll actually get Fridays off. And yes, watching Seven get smarter every weekend is as cool as it sounds.

Vault & Token System Expert

Expertise:

Secure storage systems, cryptographic validation/signatures, content-addressed storage, distributed consensus systems.

Familiarity with deterministic routing mechanisms (Token Router), tokenization, and Vaultoken implementation.

Key Responsibilities:

Develop and maintain the Vault System ensuring deterministic artifact storage, cryptographic verification, and secure retrieval.

Implement Token Router functionality explicitly tracking token logic and metadata deterministically.

Compensation:

TOP PAY + equity & royalties.

Security & Operations

Expertise:

Military, federal agent, or national security background.

Proven track record in operational execution, physical and information security, legal coordination, and mission discipline.

Key Responsibilities:

Coordinate physical security and OPSEC practices.

Operational cohesion, and personnel alignment to mission goals.

Handle external stakeholder and regulatory interactions smoothly.

Ideal Background:

Retired military officer, former federal agent, national security professional.

Compensation:

TOP PAY + equity.

Additional Qualities for all Team Members:

Comfortable with innovation, pushing boundaries of traditional software development methods.

Familiarity with high-reliability environments (aerospace, nuclear, military systems preferred).

Understanding and respect for the strict deterministic principles that Pyronis and DOT demand.