Founding AI Product Engineer

Rowan is looking for its leading technical builder for the 0→1 phase.
You won't inherit a roadmap. You'll sit close to customers, find work that is painful enough to matter, build the first solution, and decide what earns the right to scale.
We care less about your title than the evidence.
Show us something you made that works.

What Rowan is building

Most AI products stop at generating an answer.
We're building systems that carry work across the finish line.
Our initial focus is financial-services firms, where the most valuable workflows are rarely flashy. They're consequential, fragmented, and full of edge cases:

• Catching follow-through that would otherwise be missed
• Detecting meaningful changes across clients and prospects
• Moving work safely between people and systems
• Preparing forms, records, and follow-up correctly
• Surfacing compliant growth opportunities
• Keeping the advisor in control of every consequential action

This is less like building another AI note-taker and more like building a firm-safe relationship execution layer.
The first 80% of an agent workflow is becoming cheap.
The last 20% is where the product lives.

The loop

This is the job:

• Find a real problem.
  Not a hypothetical use case. Something a customer is losing time, money, trust, or sleep over.
• Build the smallest working solution.
  Prototype in days. Put it in front of the person doing the work.
• Watch what actually happens.
  Study usage, traces, failures, overrides, and abandoned runs. Don't confuse a persuasive demo with a useful product.
• Kill or improve it.
  Delete weak ideas quickly. When something works, find out why.
• Harden the last mile.
  Handle permissions, missing information, forms, handoffs, retries, approvals, exceptions, and recovery.
• Scale what earns it.
  Turn a promising workflow into something customers can depend on.

Then run the loop again.
Whoever gets closest to the customer and learns fastest wins.

What you'll actually do

• Work directly with customers to understand how consequential work really gets done
• Turn rough problems into working AI-native products
• Build across frontend, backend, infrastructure, tools, memory, retrieval, evals, and observability
• Design token-efficient agent loops that preserve the right context without dragging the whole world into every run
• Build skills and harnesses that improve through traces, evaluation, failure attribution, and repeated use
• Start from systems such as OpenClaw or Hermes when they give us speed
• Build a custom harness when the product requires more control, reliability, or efficiency
• Decide which actions can run autonomously, which require approval, and which the agent should never take
• Make failures visible, recoverable, and useful
• Turn customer trust into product architecture—not a disclaimer at the bottom of the screen

The hard part

Making an agent look smart is easy.
Making it dependable inside a real firm is hard.
A workflow can perform beautifully nine times and still be worthless if the tenth run submits the wrong form, misses a handoff, acts on stale information, or invents certainty where none exists.
You'll need a craftsmanship mindset.
That means caring about the awkward parts:

• The field that can't be left blank
• The source that disagrees with another source
• The approval that must happen before an action
• The interrupted workflow that needs to resume safely
• The record showing what happened and why
• The moment the agent should stop and ask a person

If a general agent already handles a workflow well enough out of the box, customers won't pay Rowan to rebuild it.
Our value lives where “pretty good” isn't good enough.

Who this is for

Maybe you're a seasoned engineer who went all in on AI and can't return to the old pace.
Maybe you've never had the expected title and simply keep building things people use.
Either can work.
The pattern we're looking for is consistent:

• You've shipped real products to real users
• You can move from customer conversation to working software without waiting for a perfect specification
• You use AI coding and agent tools aggressively, but don't outsource judgment to them
• You understand that model quality is only one part of system quality
• You can reason about state, context, permissions, verification, and failure recovery
• You have strong opinions loosely held
• You move fast without leaving a pile of fragile code behind you
• You know when to extend an existing framework and when to replace it
• You're comfortable being wrong quickly and publicly
• You care about the details customers only notice when they break

You're a little allergic to how software is “supposed” to be built.
Good.

What this isn't

This isn't a research role isolated from customers.
It isn't a product-management role with engineers downstream.
It isn't a prompt-engineering role where the work ends when the output looks convincing.
And it isn't a place to build elaborate agent infrastructure before proving that anyone needs it.
You'll build the system and discover the product at the same time.

The bar

We don't need a long résumé.
We need evidence that you can:

• Find the real constraint beneath what a customer asks for
• Build a useful first version quickly
• Measure whether it worked
• Diagnose why it failed
• Improve reliability without suffocating speed
• Finish the boring final mile

Taste matters.
Speed without judgment creates more code to delete.
Judgment without speed creates documents.
We need both.

Logistics

Rowan is based in Vancouver, Canada.
This role can be fully remote. Meaningful overlap with West Coast working hours is important because you'll work closely with customers, product, and company leadership.

How to get our attention

Send us:

1. Something you built—a product, demo, repo, automation, agent, or weird little system that works.
2. A few sentences explaining the problem, what you built, and what people actually did with it.
3. One failure you encountered, how you diagnosed it, and what you changed.
4. A short note on why this shape of role pulls at you.

Working prototypes talk.
Everything else waits.