# Stop Chatting With Spreadsheets — Francesco Galletta & Felippe Felisola Caso, Monzo

## Executive summary

The presentation argues that for high-stakes domains like financial analysis, the primary bottleneck when using AI agents is not speed, but trust. To build reliable AI systems, speakers introduce five core design principles—Shared Domain, Consistency, Evidence, Accountability, and Verification. These principles guide the construction of a 'harness' that enforces structured, deterministic, and traceable processes, ensuring that the system's outputs are reliable and auditable, especially when dealing with money.

## Key takeaways

- Trust is the Bottleneck, Not Speed: For financial applications, the challenge is not generating fast answers, but generating answers that are trustworthy. The focus must shift from maximizing tokens to building robust, reliable systems.
- The Five Principles of Trust: Trust must be engineered into the system using five principles: Shared Domain (ensuring model and user speak the same language), Consistency (using code for calculations), Evidence (showing receipts/data lineage), Accountability (maintaining human oversight), and Verification (using external reference points).
- Code for Determinism: Calculations and any process that must yield a consistent result should be implemented in code (e.g., Python scripts) rather than relying on the language model's internal arithmetic capabilities, which are non-deterministic.
- The Role of the Harness: A 'harness' is a structured framework designed to guide the agent through a problem-solving process, forcing the user to address critical steps and assumptions, thereby building trust and preventing the system from becoming a 'black box.'

## Technical details

- Shared Domain: The system must ensure the user's domain knowledge aligns with the model's understanding. The harness guides the user to challenge assumptions and clarify ambiguous terms, preventing the model from making incorrect inferences.
- Consistency and Determinism: To ensure reliable results, deterministic calculations must be implemented via code (e.g., Python scripts) and unit tested. Relying on the LLM's internal reasoning for arithmetic leads to non-deterministic and often incorrect outputs.
- Evidence and Traceability: The system must provide a clear audit trail, showing the source of every piece of information (the 'receipts'). This includes labeling inputs as facts (e.g., bank statements), assumptions (agent reasoning), or interpretations. Traceability must extend to code changes.
- Accountability: The human user remains ultimately accountable for the agent's output. The harness must incorporate intentional 'gates' (e.g., reviewing tasks instead of individual changes) to ensure the user reviews critical decisions and assumptions, preventing the system from becoming a black box.
- Verification: Verification requires a separate, external point of reference (a counterfactual) to check the agent's conclusions against. This prevents the system from being biased by its own internal data or assumptions.

## Practical implications

- When designing AI agents for critical functions (especially finance), prioritize building structured 'harnesses' over simple prompt-based skills.
- Always enforce deterministic calculations using external code libraries and rigorous unit testing to eliminate non-determinism.
- Design the agent workflow to force the user to acknowledge and validate assumptions and external inputs, rather than allowing the agent to proceed with unchecked inferences.
- Implement explicit feedback loops and review gates to maintain human accountability over the final decision, even if the process is automated.

## Topics

AI Agents, Financial Analysis, System Design, Deterministic Computing, Prompt Engineering, Build Engineering, LLM Orchestration, AIE CODE Summit, Monzo

Source: https://www.youtube.com/watch?v=ATMcd9tkhhc
