Role overview

Rowan is looking for its leading technical builder for the 01 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 architecturenot 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 rsum.
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:

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

Working prototypes talk.
Everything else waits.