The AI teamyour fund doesn't have.
We build the systems that encode what generates your alpha. On your stack. Owned by you.
Across the full
investment lifecycle.
Every fund has its own way of generating alpha — the thesis, the network, the tooling and SOPs. Our work operationalises that into systems that run continuously, instead of when your team has bandwidth.
AI is uniquely shaped for this work. Investment teams spend most of their time on the same handful of bottlenecks: reading dense documents, comparing against historical precedent, drafting in a specific voice, watching for anomalies in long-running data. Agents are good at exactly these — they read in parallel, hold every prior decision in working memory, and never get tired on the fiftieth memo. The judgement still has to be human. The preparation, the synthesis, and the surfacing don't.
The next generation of funds will treat AI like infrastructure — sourcing, diligence, monitoring, and LP communications running continuously in the background. Early adopters compound a structural advantage every quarter the rest of the market doesn't. We close that gap, one build at a time — without trading the judgement that makes you the firm you are.
Sourcing
Discover opportunities earlier, research them faster, and act with confidence.
Continuous scrape of YC, Antler, EF, GitHub, LinkedIn, Crunchbase. Top of funnel of twenty thousand narrows to the two hundred that fit your thesis. Identifies the right person at each. Drafts outreach in the fund's voice with a real-time hook. Runs the sequencing.
The shape of
every system.
Every system we build has the same overall shape. Agents read the source data and write structured outputs to a database that your team can query. An interface — usually inside the tools you already use — is how the team interacts with the workflows. A dashboard makes the system's health and usage visible. Documentation and secure hosting close the loop. Each part is replaceable; together they're a real piece of software, not a chatbot.
Underneath that surface, we organise the work into five layers — data, intelligence, workflows, interfaces, enablement. Each engagement leans on a different mix, but the spine is consistent. We start at the foundation so each engagement leaves substrate the next one inherits, and finish at enablement so the team owns what we built before we leave.
Click any layer on the right for what we do at that level.
Why the system survives.
Team training, methodology transfer, documentation, ownership handover. A system the team doesn't understand is a system that dies the moment we leave. We design every engagement to end with the team operating the system without us — and extending it on their own clock.
Custom. Client-owned.
Both founders, every engagement.
Every engagement is a fixed-scope project, shaped around the way your fund actually generates alpha. The code lands in your repo and runs on your stack. There's no subscription, no multi-tenant platform, no off-the-shelf product behind the scenes — just a system built for your fund, owned by your fund.
The four attributes on the right are what that looks like in practice. Together they're also what makes the work compound: foundations from every build carry into the next, and when the next Claude or GPT ships, a custom system rewires once and every workflow benefits within days. Subscriptions don't do that.
Click any attribute to expand.
Every system we build is shaped to the way your fund actually generates alpha — your thesis, your screening criteria, your IC voice, your portfolio operating model. Nothing has to bend to fit a vendor's product surface. The methodology stays in your shape; the system bends to it. That's also what lets us go deep on the parts that matter and skip the parts that don't.
Not a Slack channel and a Loom video. Josh handles the methodology side — the work of understanding how your fund actually operates and where the leverage is. Ron handles the technical side — schemas, evals, agent design, the engineering that makes the system real. We are personally on every scoping call, every demo, every integration. The engagement ends when the system runs in your stack and your team owns it.
Every engagement is one shipped outcome. Three weeks, sometimes a little more, always bounded. You commission a project and we deliver it; the engagement ends cleanly when the system ships. No ongoing dependency, no lock-in, no monthly cost burning while you're not using us. When the next project is worth doing, you commission the next one — on your timeline, not ours.
Every line of code we write lands in your fund's GitHub. The system runs on your auth, your hosting, your data sources, your tools. There's no Routine Labs server sitting in the middle. When the engagement ends, the system stays exactly where it lives — fully owned, fully extendable, fully yours to retire on your own clock. We can't deprecate what we don't host.
Two founders.
Both on every engagement.
Routine Labs is a London-based studio building bespoke AI systems for investment teams. We're not a platform — there's no off-the-shelf product to subscribe to. We're not a wrapper — the model is substrate, not the deliverable. We're not a subcontractor — both of us are on every engagement, end-to-end. We care about the same things any serious team cares about: real systems, clean code, defensible outputs, and software the team that uses it actually owns. The work is bespoke because the methodology that generates a fund's alpha is bespoke. Every engagement leaves the team with code, documentation, evals, and a system they can run, extend, and retire on their own clock.
Josh O'Neill
Co-founder · Commercial & methodologyBackground in private equity. Leads commercial and methodology design — translating fund workflows into systems worth building. Brings the domain judgement a generic dev shop lacks, and keeps every engagement anchored to a real operational bottleneck.
Ron Schickendantz
Co-founder · Engineering & architectureBackground in tech. Leads system design and delivery — the projects Josh scopes, shipped on the fund's infrastructure and improved through eval-driven iteration. Brings outcome-driven development that turns requirements into dependable compounding systems.
Built on what fits.
Plugs into what you already run.
We don't drag our own platform into the engagement. We pick the right component for the job from the stack the fund already runs — or the stack the fund wants to be running — and wire it in.
Architecture is the
compliance story.
The strongest compliance posture is the one that has nothing to leak. We don't host your data, we don't aggregate across clients, and we don't train on what you share with us.
Code in your repo.
Every line we write lands in your fund's GitHub. We don't run infrastructure that holds your code.
Data stays at your fund.
No data flows to Routine Labs servers. Nothing trains on it; nothing aggregates across funds.
Residency where you need it.
We deploy to the regions your fund's compliance posture requires — EU, UK, US, on-prem. Wherever the data has to live, that's where the system lives.
Single-tenant by construction.
No shared database, no customer ID column. Each fund's system is structurally isolated.
Encoded methodology,
on your stack,
owned by you.
Thirty minutes. No deck. If there's a project, we scope it. If there isn't, you keep the diagnosis.
London · Project-by-project · You own everything