Operant AI
We are building the delegation layer for software delivery.
Copilots made builders faster. Agents made them supervisors. We make them decision-makers — by giving delivery to a pipeline accountable enough to own it, and disciplined enough to only interrupt when it has earned the right.
YOUWe need a referral flow on the dashboard — unique invite links, a credit when an invitee activates, and a small leaderboard for the team plan.
OPERANTUnderstood. Should credits apply automatically at activation, or pend until the invitee's first payment?
YOUFirst payment. I have to run — handle the rest.
OPERANTDone. Spec for your approval by 10:30 on WhatsApp. I will only call again if I am blocked. Your walkthrough is on Meet this afternoon.
The pitch, in one paragraph
Product people lose the majority of their week not to deciding what to build, but to shepherding it through delivery — writing specs, chasing implementation, re-explaining context, and checking that what shipped matches what was asked. Operant AI takes ownership of that entire chain. Describe the feature in a short call; our pipeline writes the specification, builds the code, visually verifies every requirement against the running application, and brings you a live walkthrough to approve. You make decisions at a handful of gates — by voice or WhatsApp — and nothing else. The phone is not the product. It is the proof: when a system can genuinely be trusted with delivery, a phone is all the interface you need.
This is working in market today: $10K in revenue in our first two months, four paying companies, and a $60K first pilot — every feature delivered through the pipeline, with us embedded as the PM at each customer. This is not SaaS that assists. It is software that operates.
Why we started
Eight hundred conversations, one sentence
This company did not begin as a product idea. It began as a pattern. We were a part of PMs in AI — a community of more than nine hundred product leaders from companies like AWS, Salesforce, and Walmart, and from dozens of AI-first startups — and across thirteen events in New York, Boston, and San Francisco, we kept hearing the same sentence in different accents:
"I know exactly what to build. I just need someone — or something — to build it."
Our own community survey put a number on it: respondents estimated roughly 60% of their week goes to delivery logistics rather than product thinking. The striking part was not the figure. It was that the new generation of AI tools had barely moved it. Copilots and chat assistants made each delivery task faster — and left every task, every handoff, and all of the accountability exactly where it was: on the product person's plate.
We concluded that the industry has been optimizing the wrong variable. The bottleneck is not the speed of the work. It is the ownership of the work.
The category shift
From assistance to supervision to delegation
Every generation of AI tooling has changed the human's job title without changing the human's burden.
Era one
Copilots
AI assists. You do the work, slightly faster. Every keystroke, decision, and check is still yours.
Era two
Agents
AI does the work — while you watch. You babysit a terminal, review diffs, and carry all the risk of unverified output.
Era three — ours
Delegates
AI owns the outcome. It specifies, builds, verifies, and demonstrates — and interrupts you only at decisions that are genuinely yours.
Delegation is not a smarter model. It is a contract: the system commits to a process, proves its work, and respects your attention. That contract cannot be prompted into existence. It has to be engineered. That is what we have built.
The industry has a name for this transition — SaaS to SaiS. We take it literally: the most valuable companies of this cycle will not sell software that helps a profession work faster. They will sit at the centre of how the next generation of that profession gets built — and for product people, that centre is the system that takes responsibility for delivery itself.
What we built
A delivery pipeline that earns trust the way a good team does
A feature delegated to Operant moves through a fixed sequence. The creative work inside each phase is done by AI agents; the transitions between phases are deterministic code — eighteen states, twenty-three events, hardcoded. The AI never gets to decide whether it is finished. The pipeline does.
Three properties make this delegation rather than automation:
Deterministic process. Phase transitions are code, not model judgment. The pipeline behaves like CI/CD, not like a demo — crash-resumable, file-based, inspectable, and trackable in Git.
Verified outcomes. We do not report that the work is done; we prove it, requirement by requirement, against the running application — with screenshots a human can audit after the fact.
Accountable interruptions. Simple decisions arrive on WhatsApp; consequential ones arrive as a call; everything escalates on timeout. Your attention is treated as the scarcest resource in the system — because it is.
Who reaches for this first
Four people we built this for
These are composite scenes, drawn directly from conversations in our community. Each one represents a budget line or a backlog that exists today.
The founder without a CTO
The agency quote on a Friday evening
A solo founder with paying users needs a billing migration and two dashboard features. The agency quote arrives: five figures and six weeks, with a kickoff call to schedule the kickoff call. Her alternative until now was learning to supervise a coding agent herself — becoming the engineering manager she founded a company to avoid being.
With Operant, she describes all three pieces of work on her commute. The specs arrive for approval by mid-morning; the walkthroughs land over the following two days. She competes with funded teams on shipping cadence, without hiring or supervising anyone. For her, we do not replace a tool. We replace the agency invoice.
The fractional product leader
Three clients, one phone
A fractional PM runs roadmaps for three early-stage clients. His value is judgment — knowing what to build and why — but his weeks disappear into three different Jira boards, three standups, and three flavors of "quick sync." He cannot scale his judgment because every client purchase comes bundled with his delivery labor.
With Operant, each client's features run as parallel pipelines. He answers gates between meetings and reviews demos in scheduled blocks. His deliverable shifts from hours to outcomes — and his practice scales for the first time.
The enterprise PM with an unstaffable backlog
The tools no engineer will ever be assigned to
Inside every large company sits a graveyard backlog: the internal dashboard, the ops console, the workflow glue — work that is genuinely valuable and will never win a headcount argument against the core product. Today that backlog is either ignored or smuggled through as shadow IT with no review, no audit trail, and no owner.
Operant gives this lane something it has never had: a delivery process with specifications, decision records, verified requirements, and screenshot evidence — more documented accountability than most staffed projects produce. We are not asking enterprises to bypass engineering. We are giving the unstaffed lane a governed path to done.
The growth PM
Experiments that die in the queue
A growth PM's best ideas are small: a reworked onboarding step, a pricing-page variant, a re-engagement email trigger. Individually none justifies an engineer's sprint, so they queue, decay, and die — and the learning they would have produced dies with them.
When a verified experiment costs one phone call instead of one sprint negotiation, the economics of experimentation invert: the team runs ten times the tests and lets the metrics, not the queue, decide what matters.
Why this is defensible
The labs build engines. We build the harness.
The obvious question deserves a direct answer: why is this not simply a future feature of the frontier models, or a thin wrapper any team could replicate? Because the product's value comes from deep non-AI infrastructure that the AI operates within — three layers of it.
The process layer. A hardcoded state machine — eighteen states, twenty-three events, deterministic TypeScript. Strip the AI out entirely and a complete delivery pipeline remains: file-based state, multi-channel gates with timeout escalation, audit loops, revision stacking, crash-resumable architecture. The process enforcement is pure product engineering, as reliable as CI/CD.
The interface layer. Incumbents are constrained by what they already are — IDEs, chat windows, ticket boards. "Call in, hang up, approve on WhatsApp, demo on Meet" cannot be retrofitted onto those architectures; it has to be the architecture. We are AI-native from the ground up, built for a customer who never touches a keyboard.
The orchestration layer. Coordinating spec-writing agents, a three-agent build team — Maintainer, Builder, Police — and visual auditors, each with scoped skills and handoff protocols, is an engineering problem, not a prompting problem. And it compounds: every pipeline run yields data on blocker patterns, revision frequency, and agent performance that tightens the system, while every customer accumulates a library of approved specs and decision records — their delivery memory — inside our harness.
If the underlying models improve tenfold tomorrow, Operant gets better — it does not get displaced. The pipeline is the product. The AI is the workforce.
| Copilots & IDE agents | Chat assistants | Agencies | Operant AI | |
|---|---|---|---|---|
| Who owns delivery | You | You | Shared, slowly | The pipeline |
| Verification | Manual review | None | Manual QA | Visual audit, evidence attached |
| Process guarantee | None | None | Contractual | Deterministic state machine |
| Your interface | IDE | Chat window | Email threads | A phone |
| Your role | Operator | Prompter | Account manager | Decision-maker |
Others make people faster at delivery. We remove them from delivery — and hand back only the decisions.
Why now
Four doors opened at once
Models crossed the capability threshold. Frontier models now reliably write production code, hold a specification, and follow multi-step instructions. Eighteen months ago, a pipeline like ours was a research project; today it is an engineering project.
Voice became production infrastructure. Modern voice and telephony APIs make a phone-first interface viable at startup cost — the channel our customers already live on is finally programmable.
Incumbents are structurally stuck. Jira, Linear, and Notion are bolting AI onto architectures designed for human operators. The window for AI-native entrants exists precisely because the paradigm cannot be retrofitted.
The customer is primed. The vibe-coding wave proved product people will use AI to ship. But they do not want to learn an IDE — they want to stay in their lane. We meet them on a phone call.
How we make money
Do the job, prove the pipeline, then productize
Our go-to-market is deliberately unglamorous: we embed as the product manager at real companies and deliver real features through the pipeline. The customer buys a shipped, verified outcome — priced against the agency invoice or the contractor day-rate it replaces, not against a seat license — and every engagement hardens the product and generates the run data that compounds our orchestration layer. As the gates and verification mature, the same pipeline sells as a self-serve product: flat plans by parallel-pipeline capacity, no per-seat fees, and an enterprise tier for the governed internal-tools lane. The wedge is the individual builder; the expansion is the team, where accumulated delivery memory makes every additional feature cheaper than the last — and harder to walk away from.
Proof in market
Early revenue, paying companies, and the community that started it
We did not build this in a vacuum, and we are not pitching a prototype. In our first two months: $10K in revenue across four paying companies, with a further $25K in pipeline. Our first pilot — Extuitive — proved the system end to end and stands at a $60K pipeline. Active trials run at Second Axis, StudyOracle, and PeggApp, spanning a product OS, a complex multi-phase training-material workflow, and consumer app features — each delivered through the pipeline with us embedded as the PM. Customer references are available for all four.
Behind the revenue sits our distribution: PMs in AI, a community of more than nine hundred product leaders built through thirteen curated events across New York, Boston, and San Francisco — the source of the original demand signal, our design-partner pool, and our earliest funnel. We are supported by a compute partnership with GPTNB, and deploy through OpenDeploy — the agent-native deployment platform co-founded by our own team, completing the path from phone call to deployed feature.
The team
Australian-built. Globally deployed.
Each of us has independently built one piece of this system at production scale — Pranav the AI pipeline, Jeff the delivery infrastructure, Purple the product layer. Operant is the convergence: an end-to-end system from phone call to deployed feature.
Pranav Dhoolia
Founder & CEO — AI agent systems
Building AI agents since before ChatGPT. GPT-3 thesis with CSIRO (UQ, Dean's Global Scholar) shipped as a Slack meeting assistant. Founded Godel, an AI agent that reached $60K revenue in three months. His open-source LangGraph + MCP integration was featured by LangChain; built the MCP client for Relevance AI's core stack. Embedded as the PM at our trial companies, dogfooding Operant from the inside.
Jeff Zhu
CTO — Delivery systems
Eight-plus years of engineering. Built an LLM routing platform that scaled to ~$2M ARR; led DevOps and Kubernetes infrastructure across APAC at SIG. Co-founded OpenDeploy, architecting its entire deployment pipeline end to end.
Ziyan (Purple) He
Chief Product Officer
Nearly two years at AWS (RDS & Networking) building infrastructure Fortune 500s run on; 2.5 years shipping backend systems at Telstra, Australia's largest telco. Co-founded OpenDeploy, the agent-native deployment platform that serves as Operant's deployment layer.
Tanmay Kumar
Software Engineering Intern
2 patents in machine intelligence and signal processing. Published at AAAI on brain-computer interfaces — decoding imagined speech from EEG signals using deep learning. Smart India Hackathon national winner. Built AI-driven supply chain optimisation for TCS using custom genetic algorithms. UNSW Computer Engineering (Honours).
Let's talk
Where we are, and who we are looking for
We are pre-seed with early revenue, paying customers, and a nine-hundred-member community behind us. We are in conversations with a small number of funds and are looking for a lead investor who shares our view of the category: the future of product work is not faster tools — it is fewer tools, and a system trustworthy enough to be delegated to. Capital goes to hardening the verification layer, expanding pipeline parallelism, and converting embedded engagements into self-serve product revenue, with completion-rate and usage data as the milestones for the next raise.
We would also welcome continued design partners — founders, fractional product leaders, and enterprise internal-tools owners ready to run their next ten features through the pipeline.
References
| Name | Role | Context |
|---|---|---|
| Chong | Founder, Extuitive | First pilot customer — $60K pipeline |
| Aakash Bhatnagar | Founder, Second Axis | Active trial — embedded PM delivery |
| India and Jamie | Founders, PeggApp | Active trial — consumer app delivery |
| Jugandeep Singh | Investor, StudyOracle | Investor perspective on an Operant-delivered product |
The vision
From delegated features to a delegated roadmap
Today, you decide what to build and we deliver it. The same harness — verified outcomes, accountable gates, accumulated delivery memory — extends naturally upstream: a system that watches your product metrics, proposes what to build next, delivers it, proves it, and books the walkthrough. The destination is not a faster product team. It is a product organization where human attention is spent exclusively on judgment — and everything downstream of a decision simply happens.
The last tool a product leader adopts is the one that makes them the decision-maker — and nothing else.