Technical Co-Founder — AI Systems / Agent Infrastructure

About Axiore

Axiore is building reliability infrastructure for autonomous AI agents.

As AI agents gain the ability to deploy software, modify systems, operate tools and take increasingly consequential actions, organizations need infrastructure that can independently determine:

What should this agent be allowed to do, what evidence supports that decision, and how much autonomy can it safely receive?

Our core principle is:

LLMs propose. Deterministic systems verify. Humans govern.

Our first product wedge is control and assurance for autonomous coding-agent deployments.

Axiore sits between an agent and a protected action, independently gathers evidence, evaluates the proposed action against deterministic policy, and produces:

ALLOW · BLOCK · REVIEW · DEFER

The protected capability remains outside the agent itself.

Where We Are

Axiore is beyond the idea stage and currently at technical MVP / pre-seed stage.

The current system includes:

* Assurance Ledger for temporal evidence, observations, decisions and actions

* deterministic policy evaluation

* evidence provenance and confidence

* external evidence providers

* human REVIEW/governance

* evidence-bound, expiring, single-use authorizations

* pre-execution evidence revalidation and TOCTOU protection

* protected execution where the agent does not hold the deployment capability

* auditable assurance records

* real GitHub/GitHub Actions integration

* working ALLOW, BLOCK, REVIEW and DEFER paths

We’ve also subjected earlier versions of the architecture to controlled and held-out testing, analyzed failures, and rebuilt parts of the system based on those results.

The next stage is moving from the current MVP toward stronger real-world integrations, fresh adversarial validation, independent review, design partners and production deployments.

The Role

I’m looking for a Technical Co-Founder to help build Axiore from an early technical MVP into a foundational infrastructure company for autonomous agents.

This is not a conventional engineering position.

You would work directly on the core technical thesis and have significant influence over the architecture, product, research direction and company.

You would help solve problems including:

* secure execution of autonomous-agent actions

* agent tool and capability boundaries

* authorization and identity

* distributed evidence collection

* concurrency and TOCTOU problems

* provenance and auditability

* sandboxing and isolation

* adversarial agent evaluation

* deterministic verification

* production monitoring

* failure diagnosis and reproduction

* agent qualification

* reducing human intervention without weakening safety

* translating production failures into future evaluations and regressions

You should be comfortable challenging the existing architecture rather than simply implementing it.

Who I’m Looking For

The strongest profile would sit somewhere around:

AI/Agent Systems × Distributed Systems × Security × Developer Infrastructure

You might have experience with several of the following:

* autonomous agents / tool-using LLM systems

* agent runtimes and orchestration

* MCP or tool-execution architectures

* distributed systems

* state machines / event-driven systems

* authorization or capability systems

* security engineering and threat modeling

* sandboxing / isolation

* program or static analysis

* CI/CD and deployment infrastructure

* cloud infrastructure

* provenance and audit systems

* concurrency

* agent evaluation

* adversarial testing

* observability / production reliability

* formal methods or verification

You do not need to be a foundation-model researcher.

Deep systems thinking is more important for this role than experience training large models.

What Matters Most

I’m looking for someone who:

* thinks from first principles

* challenges assumptions

* is comfortable working on unsolved problems

* can move between research and production engineering

* cares about security and correctness

* understands that a passing test isn’t necessarily evidence that a system is correct

* can design experiments that might disprove their own assumptions

* communicates technical reasoning clearly

* wants substantial ownership

* wants to build a company, not simply join a project

Most importantly:

I want a co-founder who can discover ways Axiore can fail that I haven’t discovered yet.

Long-Term Vision

Deployment control is only the starting point.

The broader Axiore architecture is intended to support the complete reliability lifecycle for autonomous agents:

Simulate → Evaluate → Detect → Diagnose → Reproduce → Improve → Control → Verify → Qualify → Deploy → Monitor → Learn

The long-term goal is infrastructure that allows organizations to safely increase agent autonomy over time.

About the Founder

I’m a software engineer and the founder of Axiore, based in Germany.

I’ve built the initial architecture, experimental infrastructure, verifier, Assurance Ledger, policy system, evidence providers, enforcement layer and current MVP.

Rather than only demonstrating successful cases, I’ve deliberately subjected the architecture to controlled failure testing. When the first architecture failed an important held-out experiment, I preserved the result, diagnosed the underlying failure mechanisms and rebuilt the system around those findings.

I’m looking for someone who wants to continue building with that engineering culture.

Stage & Compensation

Stage: Pre-seed / Technical MVP

Role: Technical Co-Founder

Location: Germany / Europe preferred; remote possible

Commitment: Intended to become full-time

Compensation: Meaningful founder equity

This is a genuine co-founder opportunity, not a standard salaried engineering vacancy.

Equity, responsibilities, vesting, salary timing and company structure will be discussed based on commitment, experience and mutual fit.

I’d prefer to work together on real Axiore technical problems before either of us makes a permanent co-founder decision.

Application

Please include:

* a short introduction

* what you’re currently building or working on

* the hardest relevant system you’ve built, researched or broken

* links to GitHub, technical writing, research or open-source work if applicable

* why autonomous-agent reliability/control interests you

* one thing about the Axiore thesis you would immediately question or challenge

You don’t need to agree with the architecture.

In fact, I’d rather you didn’t agree with all of it.

I’m looking for someone who can help determine where the thesis is right, discover where it’s wrong, and build what comes next.