Systems that run themselves, and prove they did it right.
The work that quietly fills your week (matching records, chasing intake, drafting the same email for the fortieth time) is work a system should be doing.
I design AI automation where the logic is deterministic and the AI is kept to the judgment, so the whole thing stays verifiable, safe to re-run, and audited from input to result.
Not task execution. Systems that hold up.
Wiring two tools together is the easy part. The hard part (the part worth paying for) is designing the whole so it stays trustworthy as it grows: safe to re-run, simple to audit, and built so a change in one place doesn't quietly break three others.
High-touch engagements, built whole-loop.
The deep work: I design and build the system end to end (database, automation, AI layer, output), then document it so it's yours to own.
AI Automation & Workflow Design
The headline service. I map a manual process, then rebuild it as an automated flow with an AI layer making the drafting, routing, and matching decisions in the middle, so a form submission becomes a matched, filed, followed-up record without anyone touching it.
Data & Systems Architecture
The structural decisions that make a database filterable instead of just full: schema, taxonomy, and the relationships between records, done right the first time so it stays fast and trustworthy as it grows.
Member Platforms & Tooling
Member-facing apps, directories, and resource libraries with role-based visibility done per field, not per page. Intake-to-onboarding flows, criteria-based access, and curated content that stays navigable as it scales.
Fixed-scope answers, days not weeks.
The same discipline aimed at a question rather than a decision: source-verified, confidence-rated work, scoped to a single brief and priced before it starts. Not a lighter tier than the engagements below: a different shape of work.
Research Synthesis
A pile of sources (papers, reports, threads) turned into one decision-ready brief. Every claim source-linked and confidence-rated, with disagreements surfaced instead of averaged away. The read, and the receipts.
Ask about Research SynthesisCompetitive Landscape Scan
A market or competitor set mapped into a structured scan (who's doing what, where the gaps are, signal versus noise), so a positioning or build decision rests on evidence, not vibes.
Ask about a Landscape ScanAI Readiness Assessment
Where AI actually fits your team, and where it doesn't yet. Reads how your people already work (via Composa) and returns a concrete plan, not a maturity score, so adoption sticks.
Ask about a Readiness AssessmentPrompts? The Architect's, Sage's & Catalyst's Toolkits: eleven guardrailed prompts each, from $49 · or a library built to your own voice and guardrails, scoped on the same call.
When the call has to hold up.
Fixed-scope engagements, priced before any work begins, where I apply the method to your real material by hand, and hand back a finished artifact you can defend.
Decision & Spec
When the cost of being wrong is high. A confidence-rated decision brief, a vision turned into a buildable spec, a documentation sprint, or the executive report leadership actually reads.
Explore Decision & SpecNarrative, Change & Buy-In
When you need people to believe you, and move. A pitch narrative that lands, a change story that names what each audience fears, or an onboarding sprint that leaves a team running AI without you.
Explore Narrative & Buy-InNot sure which fits? Start with a 30-minute discovery call →
Why deterministic holds when everything else drifts.
Most automation fails the same quiet way: it works in the demo, then drifts. A record matches one day and not the next, and no one notices until it matters. The fix is to keep AI where judgment lives and rules where correctness does.
A deterministic AI system is one that produces the same correct result every time it runs on the same inputs. The AI handles judgment (drafting, summarizing, classifying) while the core logic, like record matching and routing, runs on fixed rules. This makes the system verifiable, safe to re-run, and auditable end to end.
That line is the whole discipline. Variation is welcome where judgment lives (the draft, the summary, the edge-case flag) and banished from the places that have to be right every time: which record matches which, who gets paired with whom, what counts as a duplicate. Those run on rules you can read, not a model's best guess.
That distinction is what lets a team re-run a flow without holding their breath, audit it without a forensic dig, and trust it at scale, the conditions operations-heavy and compliance-sensitive teams need before they'll hand a process over. It's the difference between automation you have to watch and automation you can leave running.
| Property | Typical | Ousios |
|---|---|---|
| Re-running a flow | Risky: may duplicate or skip | Idempotent & safe |
| When a match fails | Fails silently | Flagged with an error note |
| Record matching | Fuzzy / AI-guessed | Deterministic rules |
| Auditability | Scattered across tools | One trail, input to result |
| Ownership | Split between vendors | Whole-loop, one architect |
From the first map to the handoff.
Every engagement runs the same path, designed against how your work actually happens, then documented so you can own it.
Map
I map the manual process end to end (every input, decision, and hand-off), so the system is built against how the work actually runs, not how it's assumed to.
Model
The data and the deterministic rules: normalized match keys, idempotent intake, and the structural decisions that keep the system trustworthy as it scales.
Build
The automation and the AI layer: AI on the judgment calls, rules on the matching, error capture so a failure is flagged instead of written silently.
Document
The whole loop, written down so the system is auditable and yours to hand off, a single trail from input to result, with no vendor seams.
A live system, end to end.
A private membership network for senior marketing and sustainability leaders in the naturals industry. I own the operational backbone end to end, and over the past year I rebuilt it off its off-the-shelf tooling onto a stack I control: two production Next.js applications on Postgres, with a custom admin studio, a member portal that reads the admin database directly, and fifteen guided workflows covering the recurring operational work.
Correctness is structural, not careful. Record writes are transactional, schema changes ship as sequence-guarded migrations, and nine quality gates run from one command before a release. The matching logic is deterministic by design, and any AI layer is built to handle the writing only, never a decision about where a record goes.
The data has moved; the behaviour layer is moving next. Thirty-one automations, three intake forms, and a third Airtable base remain outstanding, and nothing is retired until its replacement has been watched doing the job.
One architect. The whole loop.
Ousios is one person, not an agency. I design and build the entire system myself (database, intake, automation, AI layer, and output), so there's a single audit trail from input to result, and no seams where responsibility slips between vendors.
Nearly a decade in operations taught me the work I automate. An engineering foundation taught me to build it so it holds. The combination is the whole point.
More about meA recurring-engagement engine, built deterministic.
Cycle Conductor generates no-repeat member pairings, drafts brand-voice outreach, and renders on-brand connection pages, re-theming live across any number of tenants from a single config file.
The matching engine is fully deterministic: same cost weights, seeded randomness, odd-count handling, and mid-cycle dropout repair, producing zero repeats every run. It's the clearest proof of the ethos (AI for the voice, rules for the matching) and the same discipline behind every system I build, whatever the workflow.
See the live engine →The same rigor, in your browser.
The fastest way to judge the work is to use a piece of it. The Cycle Conductor engine above runs live, and here's a free tool you can put to work right now. No signup, and nothing is sent anywhere unless you ask for the AI pass.
What people ask before starting a project.
What does a deterministic AI system mean?
It produces the same correct result every time it runs on the same inputs. AI handles the judgment (drafting, summarizing, classifying), but the core logic, like record matching and routing, runs on deterministic rules. That makes the work verifiable, safe to re-run, and auditable.
What kind of businesses do you work with?
Operations-heavy and compliance-sensitive organizations that run on structured data: membership networks, directories, agencies, and teams buried under repetitive intake, matching, and reporting. The common thread is a manual process that should run itself but has to stay trustworthy as it scales.
What is whole-loop ownership?
One architect designs the full chain (database, intake, automation, AI layer, and member-facing output), so the whole system is consistent and there's a single audit trail from input to result, with no seams where responsibility gets dropped between vendors.
Which tools do you build on?
Postgres as the system of record, Claude as the AI layer, and Apps Script, Zapier, and Make for automation. Member platforms run on Next.js with Clerk for auth. Reporting runs through Looker Studio, intake through Tally. A lot of this work starts in Airtable or another no-code base, and migrating off one without losing anything is part of the job.
How is a fixed-scope deliverable different from a custom build?
Custom builds are bespoke systems designed end to end for how your operation runs. Research and analysis work (synthesis, landscape scans, readiness assessments) is a fixed-scope deliverable scoped to a single brief, with the same source-verified, confidence-rated discipline, turned around in days. It is often the cleanest way to start: each is designed to hand off cleanly into a build if the work warrants it.
How do we start working together?
A 30-minute discovery call, no slides, no pitch. You bring the decision or process you're weighing; you leave knowing which deliverable or engagement fits, what it costs, and when it lands. If none fits, I'll say so and point you somewhere better.
Have a process that
should run itself?
If a process is running on your attention instead of on its own, or if you're sitting on data that should be doing more than sitting, that's the kind of problem I build for. Thirty minutes, no pitch: tell me where the work piles up, and you'll leave knowing what fits.
How I keep AI honest: occasional notes.
Short, infrequent writing on building AI you can actually verify. No spam; unsubscribe anytime.
By subscribing you agree to the privacy policy. Your email goes to MailerLite, our newsletter processor, nowhere else. One-click unsubscribe in every issue.