Garrett Amaru — AI Operating Layers

About

Most AI leaders come from one side of the problem: strategy or engineering. I came up doing both — and learned to connect business value, system design, and adoption in the same motion.

I started in finance and value-creation consulting, where the work wasn't "AI" yet — but the discipline is exactly what serious AI transformation now needs: start with where a business makes and loses money, diagnose the workflow and data reality, isolate the operating levers that matter, quantify the opportunity, and make the case credible to executives. Across nearly six years at Galt & Company (now AlixPartners), I led teams on Fortune 200 strategy and value-creation work across consumer, retail, pharma, infrastructure, and industrial clients.

That taught me to understand businesses at a level most technologists never see: where profit pools sit, which products, channels, and processes create or destroy value, and how executives decide what's worth funding. Then I moved from diagnosing and shaping business strategy to building technology products myself — as CTO / Head of AI & Product Strategy / Co-Founder at Granulytix, and as CTO / Head of Product & AI at Enterprise Neo — designing and building the first versions of core platforms before hiring and directing the teams that scaled them: multi-agent financial analytics, RAG and vector retrieval, deterministic rule engines, cloud infrastructure, and client-facing product workflows.

The through-line is applied AI that survives contact with real work. I help organizations move from broad AI ambition to governed implementation — identify where AI is worth building, define the value hypothesis, pressure-test data readiness and feasibility, design the architecture and operating model, and build the delivery rhythm that makes adoption measurable. The goal isn't a better demo; it's a governed workflow with clear owners, traceable outputs, measurable value, and a team that can run it.

At a glance

Business ContextFortune 200 value creation · middle-market operators · early-stage startups · PE-adjacent workflows · insurance & financial-services · client-facing delivery

Technical GroundingPython · LLM applications · agentic workflows · RAG · vector retrieval · Azure · AWS · APIs · PostgreSQL · Redis · Terraform

Delivery Motionexecutive discovery · opportunity scoring · architecture · implementation · validation · runbooks · training · handoff

What I add

The rare combination isn't strategy or engineering — it's carrying the work from value thesis through architecture, build, governance, and adoption without a handoff in the middle.

Strategy that's accountable to the build

The plan and the system stay connected.

I help decide what AI is worth building, then pressure-test whether the architecture, data, team, and adoption path can actually support it — so the plan and the system never drift apart.

Technical depth that starts from value

The model is never the starting point.

I've built end-to-end AI systems myself, but I don't start with the model. I start with the value stream, the operating constraint, and the decision the business needs to make.

Delivery designed for handoff

The system is unfinished until the team can run it.

I treat governance, validation, recovery paths, and non-technical adoption as part of the build — not documentation written after the fact.

Work

Systems I've built, shipped, and handed over

Real systems, designed and shipped — each one built to be trusted in client-facing workflows and handed to the team that runs it.

Engagements are described by scope and industry; specifics available in conversation.

An agentic AI operating layer

Agentic systems · Platform

Independent / Granulytix — PE-adjacent & professional-services delivery

The bet was reusable infrastructure over one-off automation. I designed and built a private AI operating layer for consulting and professional-services delivery — a catalog of versioned workflow assets coordinating through a shared project-state hub, with agent roles deliberately separated from deterministic analytics, CI-enforced content rules, and validation/publish gates. The suite spans workplanning, source canonicalization, structured investigation, profitability modeling, workflow validation, developer tooling, and a governed analytical-method catalog in active development — built to compound across engagements rather than be rebuilt each time.

Design objectives

Lightweight and easy to manage, with low operational overhead.
Leverage the infrastructure and tools the team already uses, to drive adoption rather than force a new system on people.
Flexible enough to run on any client engagement without bespoke per-client tooling.
Built to extend continuously over time as new needs emerge.
Traceability and shared context, so any team member can see and build on what someone else already did.

Show architecture + proof

Architecture of the agentic operating layer: reusable operating assets coordinate through a shared-state hub; agent reasoning is held separate from deterministic computation; workflow outputs pass governance gates. The Analytic Method Catalog is in active development.

100+

reusable workflow assets

role-separated agents

The patternReusable AI workflows need shared state, typed contracts, and clean boundaries between agents and deterministic code.

A delivered AI reporting system built for client-team operation

Delivery · Handoff

Independent — roughly $50M mid-market marketing analytics firm

The engagement opened with a week-long operations assessment: I scored roughly ten AI opportunities by impact, data readiness, and dependencies, then sequenced a roadmap — reporting was the highest-leverage first phase. From there I built and handed over a private AI reporting workflow that turns behavioral-test data and project context into validated reports, decks, support packs, run history, and recovery-aware operations. It's JSON-first and schema-driven: deterministic code computes and freezes the numbers, AI agents author the narrative from bounded facts, and every stage is validated before anything reaches a client — delivered with an install path, runbooks, halt-recovery docs, adoption materials, and training, so the team runs it without me.

Design objectives

Fit the firm's fixed client-facing deck and report structure without letting unsupported numbers into the final output.
Keep deterministic code responsible for computations and frozen facts, while AI agents author prose only from bounded, validated evidence.
Make the workflow runnable by non-technical users, with clear runbooks, recovery paths, and handoff materials.
Operate inside the client's preferred LLM environment, including Claude, without requiring new engineering overhead or a separate platform build.
Preserve analyst review and auditability while reducing a roughly 100-hour engagement-delivery process to approximately 40 hours.

Show architecture + proof

Validation-gated reporting assembly line

Inputs

Behavioral-test exportraw engagement data

Project briefclient context + lenses

Design systemvoice, labels, deck shape

Setup validationschema + readiness checks

Run statehistory + recovery point

Evidence spine

Analyzedeterministic scoring + pivots

Freeze findingsnumbers become source of truth

Investigatebounded insight cards

Synthesizesource-backed story spine

Accuracy gateclaims checked before draft

Client output

Report sectionsparallel authoring packets

Refine gatestructure + evidence checks

Storyboarddeterministic slide contract

Rendered deckclient-facing HTML

Support packrunbooks + talk track

Controls

Typed artifactsJSON / Markdown contracts at each stage

Halt + resumesurgical recovery without restarting the run

Human reviewanalyst judgment preserved before send

How the reporting workflow keeps deterministic facts, bounded narrative work, validation gates, and operational handoff visibly separate.

~100h → ~40h

engagement-delivery process, analyst review preserved

Handoff

runbooks, recovery docs, adoption materials, training

JSON-first

schema-driven, validation-gated every stage

The patternAI writing becomes trustworthy when analytics, evidence, validation gates, and human review are cleanly separated.

A deterministic engine for regulatory text

Deterministic · Governance

Enterprise Neo — CTO / Head of Product & AI

As CTO, I led technology strategy and product direction and architected a deterministic, auditable engine that converts complex regulatory and legal text into traceable, machine-evaluable rules. Bounded AI assistance is paired with deterministic validation, so outputs are checked against structured business rules rather than accepted as black-box answers.

Design objectives

Correctness first: outputs verifiable against structured rules, not trusted on faith.
Full traceability and explainability for every result, suitable for compliance-sensitive use.
Deterministic computation separated from bounded AI assistance, with human review where reliability matters.
Measurable, regression-tested quality that holds as the source material changes over time.

Show architecture + proof

From government text to executable rules

USITC JSON scheduleHTS codes, descriptions, duty rates

USITC PDFschapter notes, general notes, Chapter 99

Versioned ETLone controlled import workflow

Schedule ingestionHTS tree + rate components

PDF hierarchy parsersequence-aware note tree

↓

Reference scannerHTS coverage + cross-references

Rule buildercountry, product, date, material scope

Optional AI correctionoutside the core, policy-gated, audited

Structured rule storesnapshots + mapped conditions

Deterministic evaluatorplain rule application

Traceable API outputcalculation parts + support payload

Regression harnessscenario quality tracking

Complexity is handled upstream — in parsing, reference resolution, and rule construction — so the final calculation engine stays deterministic and auditable.

How messy regulatory source material becomes structured, traceable rules before a deterministic engine evaluates them.

140

scenario regression harness

93.6%

passing · failures tracked as work items

Traceable

rule logic, source context, and evaluator output

The patternCompliance-sensitive AI needs deterministic structure around probabilistic assistance.

A multi-agent financial-analytics platform, end to end

Architecture · Multi-agent

Granulytix — CTO / Head of AI & Product Strategy / Co-Founder

As co-founder and CTO, I led product and architecture for a multi-agent financial-analytics platform spanning the full stack: a Flask product surface, a Pydantic-governed agent runtime (orchestrator, planner/synthesis, document search, data analyst, code reviewer and executor), Redis-backed memory and artifacts, PostgreSQL and vector retrieval, Azure OpenAI, serverless specialist agents on Azure Functions, and Terraform-managed cloud infrastructure.

Design objectives

Coordinate specialized agents — orchestration, planning, retrieval, data analysis, code execution, and review — under one governed runtime.
Bind every agent's inputs and outputs with Pydantic-typed contracts, so results stay structured and inspectable rather than free-form.
Separate fast session state and artifacts (Redis) from durable structured data (PostgreSQL) and semantic retrieval (vectors).
Run as managed cloud infrastructure — serverless specialist agents, Terraform-provisioned, secrets in Key Vault — so it scales without manual ops.

Show architecture + proof

Multi-agent financial analytics product stack

User experience

Financial analyst UIchat, tables, charts, follow-ups

Project workspacefiles, datasets, metadata

Rendered artifactsmarkdown, Plotly, data views

Application layer

Flask web approutes, auth, sessions

Typed payloadsuser + project context

Response assemblydisplay-ready JSON

Intelligence layer

Orchestratorplans and routes requests

SpecialistsSQL, search, Python, reasoning

Review + responseanalysis quality and synthesis

Data + memory

PostgreSQLmetadata + structured data

Redissessions, temp uploads, artifacts

Vector retrievaldocuments + project knowledge

Cloud foundation

Azure Functionsserverless agent endpoints

Azure OpenAI + Searchmodels and retrieval

Terraform + Key Vaultmanaged infrastructure

The full stack as one designed system — product surface, application logic, agent orchestration, data and memory, and cloud runtime.

Full-stack

product surface, agents, data, and cloud as one designed system

Pydantic-governed

typed contracts bind every agent's inputs and outputs

Azure-native

serverless agents, vector search, Terraform-managed infra

The patternAgentic products need product surface, memory, retrieval, execution, and infrastructure designed together — not bolted on after.

Background

From value creation to AI systems

The résumé has the full chronology. This section highlights the experience most relevant to senior AI strategy, delivery, value creation, and implementation leadership.

Experience

Principal, AI Implementation & Workflow Architecture

2025 — Present

Independent

Project-based applied-AI implementation, from discovery through adoption.

Won and delivered an AI reporting and engagement-delivery workflow for a mid-market marketing analytics firm — discovery, architecture, Python implementation, validation design, and training.
Built the first workflow in a broader operating-layer roadmap: hub-backed shared project state, deterministic analytics, bounded agents, source-provenance checks, and validation / publish gates.
Translate business use cases into deployment plans — workflow discovery, data readiness, prioritization, MVP scope, milestones, value hypotheses, and success metrics.

CTO / Head of Product & AI

2025 — Present

Enterprise Neo

Technology strategy, product direction, and architecture for an early-stage regulatory- and tariff-intelligence platform.

Designed and built the initial platform end to end — front end, back end, domain processing logic, data pipelines, APIs, deterministic rule evaluation, and AI-assisted workflows — then set direction for the team that scaled it.
Architected a deterministic engine for complex classification and duty scenarios with traceable, explainable outputs and operational reliability in compliance-sensitive workflows.
Named inventor on a filed U.S. utility patent application; set technical direction and delivery standards for vendor-led engineering through shifting headcount and budget.

CTO / Head of AI & Product Strategy / Co-Founder

2021 — 2025

Granulytix

Co-founded an AI-driven financial-analysis platform; owned product strategy, architecture, AI system design, and client delivery from concept through usable delivery.

Architected and built the initial multi-agent platform and visualization product — RAG pipelines, vector retrieval, role-based agents, shared context, audit trails, and validation patterns — then led the team that extended and operated it.
Directed client engagements from scoping through implementation; supported go-to-market through proposals, demos, positioning, and executive communication.
Built and managed secure cloud infrastructure across Azure Functions, Key Vault, Redis, PostgreSQL, Terraform, and GitHub Actions, with per-client data isolation.

Director / Management Consultant

2015 — 2021

Galt & Company (now AlixPartners)

Led teams of four to eight on Fortune 200 strategy engagements — performance improvement, market dynamics, shareholder value, and execution planning.

Contributed to engagements identifying $100M+ in economic-profit and optimization opportunity through granular profitability analysis and implementation planning.
Ran executive workshops and C-level briefings to align on priorities, operating-model changes, initiative roadmaps, and accountability.
Developed strategic alternatives across consumer, retail, pharma, infrastructure, and industrial contexts — including Mylan/Upjohn pharma strategy (business assessment, performance analysis, sales-force optimization, and granular financial economics) and Coca-Cola's North America bottler divestiture.

Senior Financial Analyst & Financial Management Program

2012 — 2015

Liberty Mutual

Completed the flagship Financial Management Program.

As Senior Financial Analyst, built reinsurance forecasting models and standardized reporting infrastructure in property & casualty insurance.

Skills & capabilities

AI Strategy & Value Creation

AI StrategyAI TransformationUse-Case PrioritizationOpportunity AssessmentData-Readiness AssessmentInvestor-Grade Business CasesValue StreamsEnterprise ValueCFO-Ready Value FramingGranular Process DiagnosisROI / KPI DesignAI Maturity AssessmentOperating-Model DesignRoadmaps

AI Solution Architecture & Delivery

LLM ApplicationsAgentic WorkflowsMulti-Agent SystemsRAG ArchitectureVector RetrievalSolution ArchitectureData InfrastructureData PipelinesAPIsPythonPostgreSQLRedisAWSAzureAzure OpenAI / OpenAI / Anthropic ClaudeTerraformGitHub ActionsCI/CDpgvectorPinecone

Governance, Validation & Adoption

AI GovernanceHuman-in-the-Loop ControlsSource ProvenanceOutput ValidationEvaluation PatternsAudit TrailsDeterministic RulesGuardrailsAccess ControlAdoption PlanningRunbooksTrainingNon-Technical Handoff

Consulting, Commercial & Team Leadership

Management ConsultingTechnical AdvisoryC-Suite Stakeholder ManagementExecutive DiscoveryProposals & DemosClient DeliveryEngagement LeadershipReusable Delivery IPFrameworksPlaybooksDiagnostic ToolsTeam Leadership & MentorshipFinancial ModelingStrategic Alternatives

Education & credentials

Providence College · B.S. Finance, Economics minor

Filed U.S. Utility Patent Application · named inventor

CPCU · Chartered Property Casualty Underwriter

Insights

Lessons from shipping, not reading

Lessons I keep coming back to — earned building and shipping these systems, not reading about them.

AI Access Is No Longer the Differentiator

Read white paper →

Firm-level AI ROI comes from operating-model change, not access. Model and seat access is commoditizing fast and, on its own, produces no durable edge — the return comes from the operating layer above the model: governed end-to-end workflows, persistent state, codified methodology, validation gates, and audit trails. This is the thesis behind how I approach every implementation.

An operating layer runs the work; a model only answers.

A foundational model is a brilliant intern with no memory and no method. Every system I've shipped proved the same thing: the return comes from the layer above it — orchestration, persistent state, codified methodology, validation, and audit trail — that turns a capable model into a process a firm can actually run.

Most pilots die before scaled adoption.

MIT's NANDA initiative found roughly 95% of enterprise GenAI pilots produce no measurable P&L impact. That matches what I've seen: the gap is rarely the model — it's the absence of governance, reusable infrastructure, and a real path to adoption. The systems I've watched actually survive all had those built in from day one. More pilots won't close the gap; operating discipline will.

Never let the model do the math.

Every multi-agent system I've built — from financial analysis to a deterministic regulatory engine — taught the same lesson: given latitude, an LLM will hallucinate, and it bites hardest on anything numeric. So computation never rides on the model. Anything calculated, summed, or aggregated runs through deterministic code or a dedicated subagent; every figure in a finished output traces back to a verifiable source; and validation gates sit in front of anything client-facing. Keeping probabilistic assistance separate from deterministic truth is what makes output a team can trust and defend — not just output that looks clever.

Handoff is architecture.

If non-technical users can't run it, recover it, and trust it, the system is unfinished. I learned to treat runbooks and recovery paths as part of the build — not documentation written afterward — so non-technical client teams have actually operated these systems without me. The work is done when the team can run it, not when the demo runs.

Applied AI leader and builder, grounded in business value creation.

Selected outcomes

Most AI leaders come from one side of the problem: strategy or engineering. I came up doing both — and learned to connect business value, system design, and adoption in the same motion.

The plan and the system stay connected.

The model is never the starting point.

The system is unfinished until the team can run it.

Where AI becomes real business value

Turning AI ideas into an investable roadmap.

Translating business goals into AI architecture.

Building governed systems, not isolated demos.

Making AI capability compound.

Systems I've built, shipped, and handed over

An agentic AI operating layer

A delivered AI reporting system built for client-team operation

A deterministic engine for regulatory text

A multi-agent financial-analytics platform, end to end

From value creation to AI systems

AI Strategy & Value Creation

AI Solution Architecture & Delivery

Governance, Validation & Adoption

Consulting, Commercial & Team Leadership

Lessons from shipping, not reading

AI Access Is No Longer the Differentiator

An operating layer runs the work; a model only answers.

Most pilots die before scaled adoption.

Never let the model do the math.

Handoff is architecture.

Let's talk.