The short story is that our agents are now the ones coding and shipping our features. Since the software factory is autonomous, we need an engineer who ensures the pipeline beneath them never breaks.

This is a new kind of engineering role - one that exists because AI agents have moved from "experiment" to "production" in modern development teams.

Once real work runs through autonomous agents, a new class of problem emerges: they get stuck, lose context, hallucinate about time, drop work silently, or quietly succeed without reporting back.

These are not problems you can solve by writing better feature code.

We're looking for the person who owns the agents themselves - making sure the multi-agent pipeline that ships our code is reliable, observable, cost-aware, and continuously improving.

What we're really looking for

We're not looking for a traditional senior developer. We're looking for someone whose mindset matches a problem that didn't exist 18 months ago.

You think in systems, not features.

Your instinct on a failure isn't "let me add a try/except" - it's "what monitoring should have caught this 10 minutes earlier?" You see workflows, queues, deadlines, escalation paths.

You're deeply skeptical of LLM self-reports.

You've worked with language models long enough to know they have no clock, no memory of last Tuesday, and will confidently lie about both. Your default detection signal is filesystem mtime, not asking another model.

You're comfortable in the operational layer.

Cron jobs, shell scripts, log parsing, subprocess management, REST APIs - these are your daily tools, not exotic territory. Linux is your living room.

You write narrow, deterministic code.

You resist over-engineering. You prefer a 30-line cron script that does one thing well over a 500-line "monitoring framework." You don't build abstractions for hypothetical future needs.

You're a debugger by temperament.

Reading raw agent transcripts to figure out what went wrong is interesting to you, not tedious. You'd rather understand a strange failure than work around it.

You see prompt engineering as engineering.

Rewriting agent behavior is a code change to you - versioned, reviewed, tested in production. Not a side activity.

You can be a one-person SRE.

You build it, you ship it, you wake up when it breaks. You're comfortable owning a small but critical system end-to-end.

Experience we expect

• 5+ years writing production software, ideally including time owning systems in production (not just shipping features).

• Comfort with Python and Bash at a level where you can write a working watchdog or monitor without looking up syntax. We don't need framework-level expertise - we need fluency.

• Hands-on experience with LLM APIs (any major provider). You should have opinions on token costs, caching, context windows, and where models fail in practice.

• A background that touches reliability / observability / DevOps / platform engineering. SRE veterans transfer naturally. So do platform engineers and infrastructure folks who've spent time keeping production systems running.

• Track record of operational ownership - at least one production system where you were the person who got paged.

Bonus

• Experience with multi-agent orchestration platforms or autonomous agent frameworks.

• Familiarity with workflow tooling (CI/CD, queue systems, distributed cron).

• Comfort designing for non-deterministic systems - anything from ML pipelines to flaky distributed systems counts.

What makes this role different

• You're not on the feature rotation. Building features is what the agents do now. Your tickets are about the agents.

• You're early in a new specialty. AgentOps as a discipline is forming right now - the patterns are not yet textbook, and the people doing this work well will define them.

• You own your impact metrics. Throughput, stuck-task incidents, cost-per-task - these move directly in response to your work.

• You decide what to automate next. Anything humans still do in the loop is fair game.

Who this role is not for

• People who want to write feature code all day - you won't.

• People who think AI agents are a fad - you'll be miserable.

• People who need a fully-built playbook - this discipline is still being written.

• Pure researchers - this is hands-on engineering, not just paper-reading.