AYUSH MAHAJAN
GOVERNED ENTERPRISE AGENT2026
Julie

Turning messy meeting notes into safe CRM actions.

I designed Julie so a person can describe what happened in a meeting, review the exact CRM changes it prepares, approve them, and see what the system of record actually contains afterward.

For
Teams that need AI inside consequential business workflows
Ayush owned
Product and system design across interpretation, review, governed execution, readback, and recovery
Scope
Meeting input → structured proposal → approval → CRM write → verified outcome
CONCEPTUAL / JULIE / GOVERNED ACTION MODELProduct-state diagram; not a product screenshot
THE MODELPROPOSESA PERSONAPPROVESTHE SYSTEMVERIFIES
  1. 01
    MEETINGNatural-language account
  2. 02
    CONTEXTRead-only CRM lookup
  3. 03
    PROPOSALTyped suggested actions
  4. 04
    REVIEWEdit, remove, clarify
  5. 05
    APPROVEExact payload + state
  6. 06
    EXECUTEDeterministic service
  7. 07
    READBACKCompare actual state
ACTUAL OUTCOMESUCCEEDEDPARTIALUNKNOWN → RECONCILEFAILED
01 / THE PRODUCT STORY

Before architecture, the workflow.

SITUATION

The meeting ends before the administrative work begins.

Notes still have to become CRM records, follow-up tasks, owners, dates, and linked entities. A summary helps someone remember the meeting, but it does not complete—or verify—the operational work.

FRICTION

A plausible proposal can still be the wrong action.

Company names may match multiple records, the CRM may change after preview, and a timed-out write may already have succeeded. Giving a model direct mutation authority turns ambiguity into hidden risk.

WHAT I BUILT

A review surface between interpretation and authority.

I designed Julie so the model can inspect context and prepare typed actions, while a durable application workflow owns clarification, editing, approval, execution, readback, reconciliation, and audit.

02 / WHAT USING IT FEELS LIKE

The product in human steps.

The default story stays at the level of the person and the work they are trying to finish.

  1. 01
    Describe the meeting

    Natural language remains the fastest way to capture what happened.

  2. 02
    Resolve the context

    Julie checks relevant accounts, contacts, deals, and existing CRM state.

  3. 03
    Review the proposal

    The person can clarify, edit, remove, or correct every suggested action.

  4. 04
    Approve exact changes

    Approval binds to a specific payload and CRM state, not a vague instruction.

  5. 05
    Execute with limits

    Deterministic application services perform the allowed mutation.

  6. 06
    Check what happened

    The CRM is read again and the real outcome is recorded for recovery or audit.

03 / THE DIFFICULT PRODUCT DECISION

How much authority should the model receive?

The AI may interpret and propose. A human CRM user—the signed-in team member responsible for the record—approves it. Application code—not Julie—carries it out.

If the shared customer record changes before execution, the product blocks the change and returns the proposal to that human reviewer. After execution, the deterministic workflow reads the CRM again before it claims success.

04 / WHAT CHANGED DURING DEVELOPMENT

The interface became a review surface, not a chat shell.

BEFORE

A conversational interface could collect a request, but it made state, ambiguity, and the exact mutation difficult to inspect before execution.

OBSERVATION

People needed to see matched entities, suggested notes and tasks, unresolved questions, and the precise effect of approval in one durable place.

CHANGE

The browser flow moved toward a server-backed preview with typed clarifications, editable and removable cards, explicit review states, and refresh-safe recovery.

RESULTING PRODUCT PRINCIPLE

The product could represent uncertainty before the write and preserve enough state to explain or reconcile the outcome afterward.

05 / VERIFIED EVIDENCE

What the record supports—and where it stops.

VERIFIEDcombined note + task

Acceptance evidence covers successful ordered execution and duplicate-approval reuse.

Source
Documented Julie acceptance scenarios
Boundary
Workflow evidence, not customer adoption.
PRESERVEDpartial outcome

A successful note remains recorded when a following task fails definitively.

Source
Documented Julie acceptance scenarios
Boundary
The UI does not collapse partial success into a generic failure or success message.
RECONCILEDunknown outcome

A timed-out task is checked against the CRM without blindly repeating the prior note or task.

Source
Documented Julie acceptance scenarios
Boundary
No single cumulative test count and no production-write-volume claim.
06 / OPTIONAL TECHNICAL ROUTE

Architecture is available, not compulsory.

The technical route traces the trust boundary, exact-payload approval, idempotent execution, external-state readback, and reconciliation paths behind the default product story.

FOR TECHNICAL READERSArchitecture, boundaries, failure modes, and verification
T01

Interpretation and authority are separate systems

Model output becomes structured workflow input; deterministic services retain mutation authority.

  • Hermes interpretation produces a strict MeetingInterpretation schema with one bounded repair attempt.
  • Read-only CRM tools retrieve account context without exposing write tools to the model.
  • PostgreSQL-backed previews preserve tenant, user, entity provenance, review state, expiry, and audit history.
  • Typed application actions perform note, task, or combined note-and-task mutations after approval.
T02

Approval binds to exact intent

A person approves a specific payload against a known CRM state—not an open-ended instruction.

  • Schema validation and deterministic normalization run before a proposal becomes executable.
  • Entity ambiguity creates a typed clarification instead of a guessed record match.
  • Optimistic concurrency detects CRM changes between preview and execution.
  • Tenant and user authorization are enforced by application services rather than prompt convention.
T03

Uncertainty remains visible after execution

External writes can be successful, partial, unknown, or failed; the product models each state explicitly.

  • Idempotency prevents duplicate execution when approval or transport is retried.
  • Partial success preserves the successful child action and identifies the failed one.
  • A timeout becomes OUTCOME_UNKNOWN rather than automatic failure or permission to retry.
  • Reconciliation reads the CRM, finds authoritative state, and updates the recorded outcome.
T04

The CRM—not the HTTP response—is the evidence

Readback compares requested state with authoritative external state before the workflow claims success.

  • Successful combined note-and-task execution preserves request order and stored identifiers.
  • Duplicate approval reuses the original result without additional create attempts.
  • Unknown task outcomes reconcile only the uncertain child rather than replaying successful work.
  • Append-only audit records preserve attempted, partial, unknown, and verified outcomes.
TECHNOLOGY CONTEXT

The implementation followed the product boundary.

  • FastAPI
  • PostgreSQL
  • SQLAlchemy
  • Alembic
  • Relaticle CRM
  • Hermes gateway
  • Azure AI Foundry
  • Framer Motion
07 / WHAT THIS PROVES FOR A CLIENT

This work shows I can put probabilistic AI inside a sensitive workflow without making the model the final authority—and can design the states needed when external systems only partly cooperate.

Have a useful AI idea trapped in an unclear brief or brittle prototype?

Send me the rough version →