How We Work
Fern Strategy designs and ships production-grade agentic AI systems for regulated and quasi-regulated industries. We don't pitch transformation. We diagnose workflows, redesign them for autonomous execution, and build the infrastructure that lets your team run the new system after we leave.
This is the operating model behind that work.
Guiding Principles
Map the shadow workflow, not the official one
The process diagram in the employee handbook is not the workflow. The workflow is the undocumented workarounds, the spreadsheet that catches what the system doesn't, the Slack thread where the real decision gets made. We map that one, because that's the one the agent will replace.
Hunt the promising zone, not the simple zone
Simple, repetitive tasks are macros, not agents. The work that earns an agent is the complex but stable zone: workflows where the rules are explicit and durable, but the data is messy enough that humans bottleneck and rule-based automation breaks. Reconciling clinical signals across protocols. Pricing structured deals against changing inputs. That's the zone agents hold up in. That's the zone we hunt.
Don't pave the cow path
Most failed AI engagements take a broken human process and make it 10% faster. The 2 to 10x gains live elsewhere, in workflows redesigned from scratch for agent-first execution. Every handoff gets questioned. Every approval step gets challenged. Decision logic becomes explicit. Data becomes machine-readable. The human-shaped process gets retired, not optimized.
Track capability expansion, not vanity metrics
"Number of emails drafted" is not a return. Capability expansion is. Did the agent let the team do something they couldn't do before, screen the entire database instead of a sample, evaluate every contract instead of the top 20%, run analyses every night instead of every quarter? That's what we track. That's what scales.
Ship small. Unlock value early.
The fastest way to ruin an agentic engagement is to scope it like an enterprise transformation. We ship the smallest viable version of the system that produces real value, then expand from a working baseline. Three months to first production deployment is the default. Anything longer needs a defensible reason.
How we choose what to work on
Most AI use cases get picked the wrong way. Whatever the vendor demoed. Whatever leadership saw at a conference. Whatever had the most internal momentum. None of those tell you where an agent creates measurable value.
We start with the value chain.
We map your operations stage by stage. Inputs, outputs, handoffs. Then we hunt for steps that are time-consuming, error-prone, or compliance-sensitive. Those are the workflows worth targeting. Everything else is a distraction.
Two zones to avoid
Copy-paste into a CRM. Form filling. Boring, repetitive, simple. A macro can handle this. Don't waste an LLM on it.
Final medical diagnoses. Closing seven-figure deals. High-stakes judgment with real consequences. Unconstrained AI here is a liability. Humans stay in the loop.
The sweet spot
Complex yet stable. Stable rules, where boundaries are rigid and don't shift randomly. Complex data, messy, unstructured, voluminous, requiring real cognitive reasoning to interpret. Reconciling handwritten clinical notes against varying lab panels. Pricing structured contracts against shifting market inputs. Triaging compliance signals across hundreds of active protocols.
Standard automation breaks when data gets messy.
Humans break when data gets voluminous.
Agents hold up on both.
Where do you sit on the scale?
Most organizations are somewhere on the journey from a tool-first operating model, where humans run workflows and AI assists, to an agent-first operating model, where agents run workflows and humans supervise. The transition is gradual, and the productivity payoff lives at the far end.
We work with companies in the middle three stages of this scale.
Tool-First, Curious
AI is used by individuals informally. ChatGPT in browsers. No production AI in the org. No structured strategy.
Tool-First, Active
Enterprise AI tools are deployed. Copilots, Gemini, and bots are in use across teams. Workflows are still human-shaped. No production agentic systems yet.
Transitioning
Agentic POCs are running. Specific workflows are being redesigned. Internal teams are exploring what agent-first looks like, but the operating model hasn't shifted yet.
Agent-First, Active
Production agents handle real workflows. Internal capability is emerging. The organization is hunting for architectural maturity and looking to scale agentic operations across more domains.
Agent-Native
Agent-first operations are the default. The organization architects and ships agentic systems internally. External help is rarely needed.
If you're at Tool-First Curious, the gap is foundational. Get enterprise AI tools deployed and let teams build literacy before bringing in an architect. We'll be here when you're ready.
If you're at Agent-Native, you don't need us. You've already built the operating model and the internal capability. Hire from your own bench.
If you're somewhere in the middle three stages, that's where the audit-and-build model creates the most leverage. The audit phase is designed to meet you where you are.
Not sure where you sit? That's what the first conversation is for.
Agent OS
We design organizations as if agents were the primary actors and humans were the supervisors. Not the other way around.
Most companies bolt copilots onto human-shaped workflows and ceiling out at 20 to 40% incremental gains. The Agent OS removes that ceiling by treating four pillars as load-bearing.
When all four pillars are in place, step-change productivity gains, often 2 to 10x in the workflows we redesign, become the default outcome rather than the stretch case.
AGENT
Five phases. Every engagement.
Audit
Two weeks, fixed fee. We map the shadow workflow as it actually runs today. Triggers, handoffs, failure modes, undocumented workarounds. Quantified baseline. We separate the business outcome from the manual tasks currently used to achieve it.
Gauge
We grade every candidate workflow on impact, repeatability, and complexity, then test for the promising zone. Most engagements surface a clear top one or two candidates and a prioritized backlog of adjacent workflows for follow-on consideration.
Engineer
We refactor the process for straight-through, agent-first execution. Every handoff gets questioned. Every approval gets challenged. Decision logic is made explicit. Data is made machine-readable. The output is a redesigned workflow with a named agent architecture, not a chatbot bolted onto the old one.
Navigate
We design the human-agent relationship deliberately. Where does the agent act autonomously? Where does it escalate? What confidence signals does it surface? What's the off-ramp if rollout struggles? Trust is engineered through transparent intervention paths, audit logs, and graduated autonomy. Not asserted in a slide.
Track
We measure capability expansion against the baseline, not vanity metrics. We track adoption signals from week one. We tune the human-agent split based on real failure modes, not predicted ones. The engagement ships when the metrics hold and the team can run the system without us.
Five Agent Roles
Working in concert.
Every agentic system we build separates concerns across five roles.
Assistant
Read-only. Drafts, summarizes, answers. Talks to humans.
Analyst
Read-only. Reasons over data. Bounded scope, fewer hallucinations.
Tasker
Writes. The only role that actually does anything. Tools are strict contracts, not suggestions.
Orchestrator
Manages state, sequencing, timeouts.
Guardian
Immutable audit log, output validation, anomaly detection, escalation before irreversible actions.
The boundary between the read-only roles and the Tasker is where most production incidents come from. We design that boundary first, not last.
What we won't do
We won't deliver AI when non-AI tools work.
If your workflow can be solved with Make, n8n, Zapier, or a SaaS automation, that's the right answer. Agents earn their place when no existing tool fits. The audit phase explicitly tests this before any architecture gets proposed.
We won't design custom when turnkey is better.
Most workflows that look agentic at first glance are solved by the AI features already built into HubSpot, Apollo, Fathom, or Microsoft Copilot. The right question isn't "what can we build?" It's "what specific workflow does this solve that an existing tool can't?" We test that question first, every time.
We won't attempt massive system rewiring all at once.
We start with minimally invasive architecture. Decoupled services, event-driven integration patterns, rather than forcing an 18-month IT overhaul.
We won't lock you into our tools.
Anything we build runs on infrastructure your team owns and patterns your engineers can read. No proprietary runtimes, no closed model wrappers, no integrations only we can maintain. If we leave tomorrow, the system keeps working.
We won't stall projects with theoretical policy debates.
Governance emerges from practice. We start with a practical framework, build trust through controlled rollouts, and co-design guardrails as we learn.
We won't promise returns we haven't quantified.
Every engagement ties to a measurable business outcome. If the math doesn't work, the project doesn't ship.
Working together
Audit
Diagnostic plus build-phase roadmap. Designed as an off-ramp: if the math doesn't justify a build, the engagement ends with a clean handoff, no further commitment.
Build
Production deployment of the agent system surfaced in the audit. Anything we build is designed to outlast the engagement: production patterns, audit trails, observability, documented architecture. Your team owns it from day one.
Fractional Architect
Capability stays in-house. We stay accessible.
The first conversation is always free, scoped, and honest about whether we're the right fit.
How we engineer
Ten principles that guide how we architect systems and write code.
Anything we ship runs against ten engineering principles. They guide how we build software and how we work with each other on the team.
Build For Humans
We value code that is readable, and software systems that are easy to understand, extend, and maintain. We value consistency over novelty in our code style.
Solve Real Problems
We build products that solve real human problems. Perfectly architected systems are useless if they aren't helping our users.
Ship Small
We ship code in the smallest possible increments. We solve complex problems as simply as possible by breaking them down into smaller pieces.
Move Fast, With Care
We move fast, but are never careless. We think carefully about the problem space, and look for the fastest path to solve user problems without incurring risky technical debt and compromising quality.
Always Test
Thoroughly testing our code is as important as writing it. We write unit tests to ensure stability long term, and we don't shy away from manual end-to-end testing when needed.
Take Ownership
We take responsibility for all parts of the products we build. We don't expect others to catch our mistakes, but are also always willing to help solve problems that we didn't make.
Contribute to Quality
We are collectively responsible for codebase quality. If you find dead code, even if it isn't yours, clean it up. Remove that old useless comment. Rename a confusing method. We value code hygiene habits that make development easier for all.
Propose New Paths
We call out legacy patterns that aren't working, and propose new, better paths. We do this through proofs of concept, RFCs, and group discussion.
Build Together
We lean on our peers to refine our thinking and improve our work, and we provide the same support in return. We give feedback fairly, and receive it openly.
Share Knowledge
We strive to avoid single points of failure. We persist important knowledge about our software systems in documentation, and we take the time to train our peers how to use and maintain the systems we know best.