Staff AI Platform / Agent Infrastructure Engineer

Build the harness our AI-native engineering model runs on — local dev, async execution, evals, behavioral test infrastructure, agent-aware CI/CD, and the observability that doubles as our SOC 2 audit trail.

About Ellis

Ellis is building the unified data layer for private credit fund managers. We ingest, reconcile, and make sense of the financial data that fund CFOs and controllers live inside every day — NAV calculations, LP returns, reconciliation across GP records and fund administrators, SBIC compliance filings — and turn it into a trusted, queryable foundation for every decision the fund makes.

We're a seed-stage company with real customers, real data, and real financial stakes. Design partners and early clients depend on the accuracy of our platform for their fund reporting today. A silent data error costs us a customer permanently. That trust is the moat, and it's what makes this role matter.

About the role

We're making a deliberate bet that one AI-native engineer running multiple agents in parallel against a well-built harness outperforms three traditional full-stacks. We have evidence this is true. We also know the critical qualifier: only if the harness is real. Without it, you ship a house of cards.

This role exists to make the harness real.

You are the load-bearing infrastructure hire for our AI-native engineering model. Everything our product engineers ship — every agent-generated diff, every behavioral test that catches a regression, every eval that defines what "passes" — runs on infrastructure you own.

This is not DevOps in the traditional sense. It's a new category: AI engineering infrastructure. Your instincts come from platform and DevEx backgrounds, but your domain is non-deterministic systems, LLM-app observability, and the specific failure modes that emerge when agents write production code.

Here's what you're walking into: our current local dev environment cannot run a full agent iteration cycle. The background job system that LangGraph agents require doesn't exist. The eval suite doesn't exist. You're not inheriting a platform — you're building the foundation that makes the whole model work, and you'll be doing it alongside our lead product engineer from day one.

Crucially, this is a day one partnership with the Lead Product Engineer: you build the system and harness, and they ship the features against it — a tight, mutual dependency. You won't be writing day-to-day product features. Instead, you'll build the systems the engineers shipping product depend on.

Foundation (months 1-2): the work that unblocks the AI-native model

• Local dev environment — Our importers are manual CLI runs disconnected from S3 events. An agent iterating locally today cannot test against a real ingestion run. Your first deliverable is a local dev environment where an agent's diff can be run end-to-end before it touches staging.
• Async execution infrastructure — An agent orchestration framework's workflows require async execution. We have no background job system today. You'll select and ship it — a lightweight queue and worker setup on our existing AWS/ECS stack — as part of month 1-2.
• First agent workflow — Get a single workflow for an agent orchestration framework running end-to-end against our FastAPI/PostgreSQL stack. Nothing in our agent roadmap ships without this foundation.

The agent harness

• Skills and eval infrastructure — Build the skills system, prompt library, and eval suite that make agent-generated code production-grade. These are the shared tools every product engineer relies on.
• Automated review pipeline — Stand up multiple layers of automated review (Cursor bot, Claude reviewer, independent Claude agents) so that agent-generated diffs face real scrutiny before human eyes touch them.
• Behavioral test infrastructure — Build the test framework that gates product deploys. End-to-end behavioral tests catch what unit tests don't. You build the system; product engineers write the tests.

CI/CD and observability

• Agent-aware CI/CD — Extend our GitHub Actions pipeline with regression catches, schema contract tests against the data layer, and lint rules tuned to our common agent failure modes. The pipeline should catch what matters without making deploys slow.
• Agent observability — Instrument every agent run: what prompt produced what diff, what tests caught what, where humans had to intervene. This instrumentation is also our SOC 2 audit trail for AI-generated changes. Build it with compliance in mind from day one.
• Prod-like dev environments — Ensure local dev mirrors production closely enough that an agent's output can be trusted before review. This is load-bearing, not nice-to-have.

What success looks like in your first 6-12 months

• The harness is real — A product engineer can run 4-10 agents in parallel against a local environment, get behavioral test results back, and know what they're shipping before it hits staging.
• Agent runs are observable — We can answer "what prompt produced this diff?" and "what tests caught the last regression?" from logs, not from memory.
• SOC 2 audit trail is complete — Every AI-generated change in production has a logged record of the prompt, review layers, and tests that gated it. The auditor has what they need.
• CI/CD catches agent failure modes — The pipeline has caught at least one class of agent-generated bugs that would have reached production without it.
• Product engineering throughput is compounding, not collapsing — The product team is shipping fast because the infrastructure is real, not fast in ways that will become rework.

The ideal candidate

• Have 5+ years of platform, DevEx, or infrastructure engineering — you've built developer tooling that other engineers actually relied on in production, not experiments that sat unused.
• Are hands-on with AWS — we run ECS/Fargate, S3, RDS on PostgreSQL 18, SES; IaC fluency (Terraform or Pulumi) is expected.
• Have built eval harnesses or test infrastructure specifically for AI-generated or non-deterministic outputs.
• Have strong opinions about behavioral testing and evals for non-deterministic systems — you understand why golden-set test design for LLM outputs is different from traditional test engineering.
• Have experience with LLM-app observability or agent system instrumentation — you know what to log to understand why an agent produced what it produced.
• Are comfortable in Python and TypeScript — enough to read and reason about what the product engineers are shipping, even if you're not writing features yourself.
• Approach infrastructure with a "what breaks under load?" mindset — you build for the failure mode, not the happy path.

Nice to have

• Experience with an agent orchestration framework, observability stack, or equivalent tools
• Fintech or compliance context — understanding why the audit trail is load-bearing, not optional
• Multi-tenant environment isolation on AWS

Location

This role is based in New York and will work from our Soho office 3-4 days a week.

• Competitive compensation with meaningful equity
• Comprehensive medical, dental, and vision coverage
• Flexible PTO
• Company-provided laptop
• Hybrid work environment with periodic team offsites
• Chance to architect AI engineering infrastructure from the ground up at a company where it's a core competitive advantage