← Back to all field notes
Applied AI & R&D

Principles for Building Agent-Native AI Products

A field guide for designing commercially viable, lightweight software in an era where foundation models and general agentic hosts have commoditised traditional UI and CRUD.

1. Why a reset in thinking is needed

Traditional SaaS was built on three assumptions that no longer hold:

  • Software value lives in forms, tables, and workflows. Today, any general agentic host can ingest messy documents, reason over context, and generate structured drafts in seconds. A standalone multi-screen workbench is no longer a moat; it is switching friction.
  • Build the platform first, then onboard users. Building a monolithic engine, custom multi-layer abstractions, defensive enterprise ceremony, and a rich custom UI before proving one real loop with a design partner produces tens of thousands of lines of rigid code that is expensive to change and hard to adopt.
  • Humans should operate the software. Users do not want another dashboard to navigate or another spreadsheet to maintain. They want work drafted, checked, and monitored automatically, and they want to be interrupted only when judgement or action is actually required.

The result of following the old playbook today is predictable: heavy, over-engineered platforms that compete directly with free or cheap agent capabilities while asking customers to migrate away from the tools they already use.

2. Where defensible value lives now

When UI and generic text generation are commoditised, four durable moats remain:

  • System of record and institutional memory. A general LLM does not know an organisation’s tacit heuristics, operational nuances, or historical decisions, and it cannot apply them consistently across hundreds of cases. Capturing and structuring that memory is the core asset.
  • Deterministic execution and auditability. LLMs are strong at interpreting ambiguity and translating intent; they are unreliable at exact arithmetic, unit consistency, invariant enforcement, and cascading dependency updates. Ordinary deterministic code must own calculation, validation, state, and provenance.
  • Compounding closed-loop calibration. Software that ingests real-world outcomes, reconciles them against earlier predictions, and feeds calibrated adjustments back into future work gets measurably better with use. This creates a compounding data advantage that generic prompts cannot replicate.
  • Zero-friction, incremental adoption. Products that plug into existing systems of record and any agentic host as composable, headless tools can deliver value in week one, without forcing a rip-and-replace migration.

Commercial rule of thumb: avoid seat-based pricing tied to screen time. Price around workspace value, connected systems, or high-stakes outcomes protected (errors prevented, margins preserved, institutional knowledge retained).

3. Core architectural principles

3.1 Composable bounded contexts, not monoliths

Break the domain into a small set of loosely coupled, independently useful modules (for example: Rules and Heuristics, External Rates and Facts, Work Graph and Templates, Outcome Calibration, Supervisor Loop, and Ecosystem Connectors).

  • Every module should be usable on its own via standard agent tool interfaces (such as MCP and/or CLI).
  • A customer should be able to adopt one or two modules first (such as historical outcome auditing or conversational rule capture) and add the rest incrementally.
  • Any agentic host should be able to drive the system; never lock core capability behind a proprietary UI.

3.2 Closed languages as data, not code

For business rules, heuristics, templates, and external connectors, avoid both extremes: hardcoding logic in application code (inflexible) and letting LLMs execute arbitrary generated code (unsafe, unexplainable).

  • Define a small, closed, schema-validated declarative language stored as immutable data.
  • Build a tiny deterministic interpreter that validates constraints, executes calculations, and renders exact plain-English explanations.
  • Use the LLM as a bidirectional translator: converting natural human speech or text into candidate closed-language data, and explaining deterministic outputs back in context.
  • Every rule becomes inspectable, diffable, testable, and safe to execute without an LLM in the loop.

3.3 Unobtrusive, in-the-moment knowledge capture

Domain experts will rarely sit down to configure a rule engine in an admin panel.

  • Capture tacit heuristics during real work, directly inside the conversation or review flow.
  • When an expert states a rule of thumb or makes a non-obvious override, the agent proposes a structured closed-language rule, shows its plain-English readback and concrete impact on the current case, and asks for a single approval.
  • Keep the UX lightweight: natural language in, verified structured artifact out.

3.4 Immutable versioning and end-to-end citability

Every derived output must be able to answer “Where did this number or decision come from?” months or years later without history loss.

  • Make rules, templates, external observations, calibration snapshots, and published outputs immutable and version-addressed.
  • Every derived artifact stores exact pointers to the versions of the inputs, rules, and calibrations that produced it.
  • You do not need a heavy event-sourcing framework to achieve this: append-only versioned records and an immutable decision log provide full citability at a fraction of the complexity.

3.5 Reactive state graphs with triaged invalidation

Real-world projects are not static forms; upstream facts change (external prices shift, resource availability drops, requirements expand).

  • Model active work as a lightweight directed acyclic graph (DAG) connecting root inputs and external variables to derived values and human overrides.
  • When an upstream node changes, invalidate only affected downstream nodes and compute the exact delta.
  • Classify every resulting alert into three explicit severities:
    • Advisory: informational drift within acceptable tolerance. No block.
    • Requires Decision: human judgement is needed (for example, an override is invalidated, a rule condition flipped, or a threshold was breached).
    • Requires Action: an external or operational step is required before proceeding (for example, stale external data must be refreshed, or missing input must be gathered).

3.6 Human as supervisor (HITL + durable async jobs + todo UX)

Treat the human as a supervisor, not a data-entry clerk.

  • Durable async jobs handle slow, external, or batch work (syncing external systems, parsing documents, refreshing rates, running calibration passes) and survive restarts cleanly.
  • Human-in-the-loop (HITL) is a first-class primitive: when a job or agent hits ambiguity, a threshold breach, or a new heuristic proposal, it parks a structured item in a todo-style supervisor inbox.
  • Minimise or eliminate prebuilt multi-screen UI. If a UI exists at all, it should behave like a crisp decision inbox, not an ERP.

3.7 Explicit, resettable, staleness-aware calibration

Closing the loop from real-world outcomes is essential, but naive “self-learning” systems silently corrupt business logic.

  • Separate base rules from calibration: never silently overwrite a human-authored rule with historical averages. Store empirical calibration as an explicit, inspectable overlay (with sample count, date window, and cited source records).
  • Reconcile before blaming: distinguish execution variance from unrecorded scope or requirement changes before feeding an outcome into calibration.
  • Handle staleness explicitly: attach recency windows and TTLs to external facts and calibrations so outdated data flags itself rather than quietly distorting decisions.
  • Always allow control: humans must be able to manually override, promote a calibration into a new base rule version, or reset calibration cleanly at any time.

3.8 Lean transactional core, flexible analytical edge

Do not over-engineer core persistence, and do not force messy external history into rigid operational tables.

  • Keep the operational system of record lean, local-friendly, and fixed-schema (versioned entities, DAG state, HITL inbox, durable jobs).
  • Treat heterogeneous historical and external data (legacy exports, supplier sheets, raw logs) as a separate, optional read-side analytical layer (for example, queryable analytical files paired with lightweight semantic lookup or query building). Only validated, reconciled facts graduate into the core system of record.

3.9 Thin, value-first ecosystem connectors

Users already have systems where operational data lives.

  • Start with read-only or export ingestion to deliver immediate analytical or drafting value with zero risk to the customer’s existing system.
  • Keep connectors thin, declarative where possible, and isolated from core domain logic.
  • Earn write-back integration only after the system has proven accuracy and trust.

4. Anti-patterns and reset triggers

Stop and challenge the design whenever you spot these warning signs:

  • UI-first bloat: building dense custom tables, navigation shells, and form validation before the headless agent tools can complete a real end-to-end task.
  • Enterprise ceremony before PMF: investing heavily in custom multi-layer DTO translations, complex local auth and session machinery, or rigid governance frameworks for a single-user or design-partner prototype.
  • Synthetic toy syndrome: iterating for weeks on invented sample data instead of sanitised, messy, real-world artifacts from a design partner.
  • LLM doing math or state: letting the model calculate totals, maintain cross-item consistency, or “remember” rules in prompts instead of delegating to a deterministic engine and versioned store.
  • Opaque learning: updating behaviour from historical data without showing which records drove the change, excluding confounded cases, or offering a one-click reset.
  • Platform lock-in: requiring users to abandon their existing operational tools on day one to get any value.
  • Over-abstracted core: introducing generic plugin frameworks, speculative multi-tenant infrastructure, or heavy event-sourcing machinery before a second concrete use case demands it.

5. Design-partner execution playbook

When starting a new AI product with a design partner:

  1. Collect real packets early. Ask for 3 to 5 sanitised, real, end-to-end historical cases (initial input, working draft, final output, actual real-world outcome) plus a 15-minute voice dump of their top 10 to 15 mental rules of thumb. Build all fixtures from these.
  2. Ship a standalone wedge first. Deliver immediate value using just one or two modules (for example, auditing historical variance or capturing rules conversationally during live work) before building the full end-to-end workflow.
  3. Design around the supervisor loop. Measure success by how many low-value steps disappear and how clearly high-value decisions surface, not by feature count or UI polish.
  4. Let the LLM carry the ambiguity, let the core carry the truth. Keep the codebase small enough to hold in your head. If a feature can be handled by the host agent calling two clean deterministic tools, do not build a dedicated subsystem for it.
// Share

Disclosure: LLMs have been used in the editing and research of this post.

// Context & author

You are reading Field Notes by Auxil

Auxil is the practice of Tim Farland, a principal engineer and hands-on CTO based on Waiheke Island, Auckland, working alongside a trusted peer network of senior specialists. Most of the work is product and platform rescue, taking prototypes to production, and fractional technical leadership.

Explore →

Tim Farland

Operator / Architect / Engineer
// Contact

Let's move your project forward

Tell me what you are building and where you want to get to. The first half-hour is free and confidential. If I am not the right person, I will say so and, where I can, point you to someone better suited.

I also consider permanent hands-on technical leadership roles, where the work is demanding and the role stays close to the code. Email is the best way to start that conversation.

Waiheke Island, Auckland · Available for remote or CBD hybrid engagements